Client

    The Go SDK allows you to interface with all of the .

    To invoke a specific method on another service running with Dapr sidecar, the Dapr client Go SDK provides two options:

    Invoke a service without data:

    Invoke a service with data:

    1. content := &dapr.DataContent{
    2.     ContentType: "application/json",
    3.     Data:        []byte(`{ "id": "a123", "value": "demo", "valid": true }`),
    4. }
    6. resp, err = client.InvokeMethodWithContent(ctx, "app-id", "method-name", "post", content)

    State Management

    For simple use-cases, Dapr client provides easy to use Save, Get, Delete methods:

    1. ctx := context.Background()
    2. data := []byte("hello")
    3. store := "my-store" // defined in the component YAML 
    5. // save state with the key key1, default options: strong, last-write
    6. if err := client.SaveState(ctx, store, "key1", data); err != nil {
    7.     panic(err)
    8. }
    9. // get state for key key1
    10. item, err := client.GetState(ctx, store, "key1")
    11. if err != nil {
    12.     panic(err)
    13. }
    14. fmt.Printf("data [key:%s etag:%s]: %s", item.Key, item.Etag, string(item.Value))
    17. if err := client.DeleteState(ctx, store, "key1"); err != nil {
    18.     panic(err)
    19. }

    Similarly, GetBulkState method provides a way to retrieve multiple state items in a single operation:

    1. keys := []string{"key1", "key2", "key3"}
    2. items, err := client.GetBulkState(ctx, store, keys, nil,100)

    And the ExecuteStateTransaction method to execute multiple upsert or delete operations transactionally.

    1. ops := make([]*dapr.StateOperation, 0)
    3. op1 := &dapr.StateOperation{
    4.     Type: dapr.StateOperationTypeUpsert,
    5.     Item: &dapr.SetStateItem{
    6.         Key:   "key1",
    7.         Value: []byte(data),
    8.     },
    9. }
    10. op2 := &dapr.StateOperation{
    11.     Type: dapr.StateOperationTypeDelete,
    12.     Item: &dapr.SetStateItem{
    13.         Key:   "key2",
    14.     },
    15. }
    16. ops = append(ops, op1, op2)

    To publish data onto a topic, the Dapr Go client provides a simple method:

    1. data := []byte(`{ "id": "a123", "value": "abcdefg", "valid": true }`)
    2. if err := client.PublishEvent(ctx, "component-name", "topic-name", data); err != nil {
    3.     panic(err)
    4. }

    Output Bindings

    The Dapr Go client SDK provides two methods to invoke an operation on a Dapr-defined binding. Dapr supports input, output, and bidirectional bindings.

    For simple, output only biding:

    1. in := &dapr.InvokeBindingRequest{
    2.     Name:      "binding-name",
    3.     Operation: "operation-name",
    4.     Data: []byte("hello"),
    5.     Metadata: map[string]string{"k1": "v1", "k2": "v2"},
    6. }
    8. out, err := client.InvokeBinding(ctx, in)

    The Dapr client also provides access to the runtime secrets that can be backed by any number of secrete stores (e.g. Kubernetes Secrets, HashiCorp Vault, or Azure KeyVault):

    1. opt := map[string]string{
    2.     "version": "2",
    3. }
    5. secret, err := client.GetSecret(ctx, "store-name", "secret-name", opt)

    Authentication

    By default, Dapr relies on the network boundary to limit access to its API. If however the target Dapr API is configured with token-based authentication, users can configure the Go Dapr client with that token in two ways:

    Environment Variable

    If the DAPR_API_TOKEN environment variable is defined, Dapr will automatically use it to augment its Dapr API invocations to ensure authentication.

    Explicit Method

    1. func main() {
    2.     client, err := dapr.NewClient()
    3.     if err != nil {
    4.         panic(err)
    5.     }
    6.     defer client.Close()
    7.     client.WithAuthToken("your-Dapr-API-token-here")
    8. }