Getting started with the Dapr Service (Callback) SDK for Go

    Start by importing Dapr Go service/grpc package:

    To create a gRPC Dapr service, first, create a Dapr callback instance with a specific address:

    2. if err != nil {
    3.     log.Fatalf("failed to start the server: %v", err)
    4. }

    Or with address and an existing net.Listener in case you want to combine existing server listener:

    1. list, err := net.Listen("tcp", "localhost:0")
    2. if err != nil {
    3.     log.Fatalf("gRPC listener creation failed: %s", err)
    4. }

    To handle events from specific topic you need to add at least one topic event handler before starting the service:

    1. sub := &common.Subscription{
    2.         PubsubName: "messages",
    3.         Topic:      "topic1",
    4.     }
    6.     log.Fatalf("error adding topic subscription: %v", err)
    7. }

    The handler method itself can be any method with the expected signature:

    1. func eventHandler(ctx context.Context, e *common.TopicEvent) (retry bool, err error) {
    2.     log.Printf("event - PubsubName:%s, Topic:%s, ID:%s, Data: %v", e.PubsubName, e.Topic, e.ID, e.Data)
    3.     // do something with the event
    4.     return true, nil
    5. }

    Optionally, you can use routing rules to send messages to different handlers based on the contents of the CloudEvent.

    1. if err := s.AddServiceInvocationHandler("echo", echoHandler); err != nil {
    2.     log.Fatalf("error adding invocation handler: %v", err)
    3. }

    The handler method itself can be any method with the expected signature:

    1.     log.Printf("echo - ContentType:%s, Verb:%s, QueryString:%s, %+v", in.ContentType, in.Verb, in.QueryString, string(in.Data))
    3.     out = &common.Content{
    4.         Data:        in.Data,
    5.         ContentType: in.ContentType,
    6.         DataTypeURL: in.DataTypeURL,
    7.     }
    8.     return
    9. }

    To handle binding invocations you will need to add at least one binding invocation handler before starting the service:

    The handler method itself can be any method with the expected signature:

    1. func runHandler(ctx context.Context, in *common.BindingEvent) (out []byte, err error) {
    2.     log.Printf("binding - Data:%v, Meta:%v", in.Data, in.Metadata)
    3.     // do something with the invocation here 
    4.     return nil, nil
    5. }