Dapr Go SDK

You can host actors using an app-initiated actor event stream (SubscribeActorEventsAlpha1) instead of exposing standard HTTP actor endpoints. In this model, the application dials the Dapr sidecar's gRPC port and receives all actor callbacks—including method invocations, reminders, timers, and deactivations—over a single bidirectional stream.

Important Requirements:

• This feature is currently in Alpha.
• The Dapr sidecar must be run with the --app-protocol grpc flag.
• The application must listen on a gRPC port (e.g., :50051) to back the sidecar's app channel.

Key Behavior:

• Actor callbacks are delivered over the event stream, not via direct calls to the application's gRPC port.
• The stream automatically handles reconnections and re-registers actor types if the sidecar restarts or the stream drops.

// The implementation logic is similar to the standard HTTP actor example,
// but uses the client.SubscribeActorEvents method to host the actor.
client.SubscribeActorEvents(...)

The Dapr Go client provides simple methods for state management, as well as advanced options for bulk operations and transactions.

Simple State Operations

Use SaveState, GetState, and DeleteState for basic key-value operations.

Advanced State Operations

• Bulk Operations: Use SaveBulkState to save multiple *dapr.SetStateItem objects at once, or GetBulkState to retrieve multiple keys in a single call.
• Transactions: Use ExecuteStateTransaction to perform multiple upsert or delete operations atomically using *dapr.StateOperation objects.

// Simple Save
if err := client.SaveState(ctx, store, "key1", data, nil); err != nil {
    panic(err)
}

// Bulk Save with SetStateItem
item1 := &dapr.SetStateItem{
    Key:   "key1",
    Value: []byte("hello"),
    Options: &dapr.StateOptions{
        Concurrency: dapr.StateConcurrencyLastWrite,
        Consistency: dapr.StateConsistencyStrong,
    },
}
if err := client.SaveBulkState(ctx, store, item1); err != nil {
    panic(err)
}

// Transactional Operations
ops := []*dapr.StateOperation{
    {
        Type: dapr.StateOperationTypeUpsert,
        Item: &dapr.SetStateItem{Key: "key1", Value: []byte(data)},
    },
    {
        Type: dapr.StateOperationTypeDelete,
        Item: &dapr.SetStateItem{Key: "key2"},
    },
}
err := client.ExecuteStateTransaction(ctx, store, map[string]string{}, ops)

The Dapr Go SDK provides several ways to interact with a state store:

Simple Operations

Use SaveState, GetState, and DeleteState for basic key-value operations.

Bulk and Transactional Operations

• Bulk Save: Use SaveBulkState to save multiple *dapr.SetStateItem objects at once.
• Bulk Get: Use GetBulkState to retrieve multiple keys in a single operation.
• Transactions: Use ExecuteStateTransaction to execute multiple *dapr.StateOperation (Upsert or Delete) operations atomically.

Querying State

Use QueryState to retrieve, filter, and sort data. Note: This API is currently in alpha.

Granular Control

The dapr.SetStateItem type allows you to specify Etag, Metadata, and dapr.StateOptions (for Concurrency and Consistency) for individual items.

// Simple Save/Get/Delete
if err := client.SaveState(ctx, store, "key1", data, nil); err != nil { panic(err) }
item, err := client.GetState(ctx, store, "key1", nil)
if err := client.DeleteState(ctx, store, "key1", nil); err != nil { panic(err) }

// Bulk Save
item1 := &dapr.SetStateItem{
    Key: "key1",
    Value: []byte("hello"),
    Options: &dapr.StateOptions{
        Concurrency: dapr.StateConcurrencyLastWrite,
        Consistency: dapr.StateConsistencyStrong,
    },
}
client.SaveBulkState(ctx, store, item1)

// Transactional
ops := []*dapr.StateOperation{
    {Type: dapr.StateOperationTypeUpsert, Item: &dapr.SetStateItem{Key: "key1", Value: data}},
    {Type: dapr.StateOperationTypeDelete, Item: &dapr.SetStateItem{Key: "key2"}},
}
client.ExecuteStateTransaction(ctx, store, meta, ops)

// Query (Alpha)
query := `{"filter": {"EQ": {"value.Id": "1"}}, "sort": [{"key": "value.Balance", "order": "DESC"}]}`
queryResponse, err := client.QueryState(ctx, "querystore", query)

This tutorial demonstrates how to instrument a Go application with Dapr to perform state management operations (Save, Get, Delete) and run it locally using the Dapr CLI.

Prerequisites

• Docker
• Go
• Dapr CLI
• Dapr initialized locally via self-hosting

Workflow

1. Build the application: Use go build to create the executable.
2. Run with Dapr: Use the dapr run command to launch your application within the Dapr runtime.
3. Interact with State: Use the application's CLI commands to trigger Dapr sidecar operations like put, get, or del.

# Build the app
go mod vendor
go build -o order order.go

# Run the app with Dapr to persist state
dapr run --app-id order-app --dapr-grpc-port 3500 --log-level error -- ./order put --id 20

# Run the app with Dapr to retrieve state
dapr run --app-id order-app --dapr-grpc-port 3500 --log-level error ./order get