Dapr’s gRPC Interface

Dapr and gRPC

Dapr implements both an HTTP and a gRPC API for local calls. gRPC is useful for low-latency, high performance scenarios and has language integration using the proto clients.

You can find a list of auto-generated clients .

The Dapr runtime implements a proto service that apps can communicate with via gRPC.

In addition to calling Dapr via gRPC, Dapr can communicate with an application via gRPC. To do that, the app needs to host a gRPC server and implements the

This tells Dapr to communicate with your app via gRPC over port 5005.

Kubernetes

On Kubernetes, set the following annotations in your deployment YAML:

  1. apiVersion: apps/v1
  2. kind: Deployment
  3. metadata:
  4.   name: myapp
  5.   namespace: default
  6.   labels:
  7.     app: myapp
  8. spec:
  9.   replicas: 1
  10.   selector:
  11.     matchLabels:
  12.       app: myapp
  13.   template:
  14.     metadata:
  15.       labels:
  16.         app: myapp
  17.       annotations:
  18.         dapr.io/enabled: "true"
  19.         dapr.io/app-id: "myapp"
  20.         dapr.io/app-protocol: "grpc"
  21. ...

The following steps show you how to create a Dapr client and call the SaveStateData operation on it:

  1. Import the package
  3. import (
  4.     "context"
  5.     "log"
  6.     "os"
  8.     dapr "github.com/dapr/go-sdk/client"
  9. )
  1. Create the client
  1. Invoke the Save State method
  1. // save state with the key key1
  2. err = client.SaveStateData(ctx, "statestore", "key1", "1", data)
  3. if err != nil {
  4.   logger.Panic(err)
  5. }
  6. logger.Println("data saved")

Hooray!

The following steps will show you how to create an app that exposes a server for Dapr to communicate with.

  1. Import the package
  1. package main
  3. import (
  4.     "context"
  5.     "fmt"
  6.     "log"
  7.     "net"
  9.     "github.com/golang/protobuf/ptypes/empty"
  11.     commonv1pb "github.com/dapr/go-sdk/dapr/proto/common/v1"
  12.     pb "github.com/dapr/go-sdk/dapr/proto/runtime/v1"
  13.     "google.golang.org/grpc"
  14. )
  1. Implement the interface
  1. Create the server
  1. func main() {
  2.     // create listener
  3.     lis, err := net.Listen("tcp", ":50001")
  4.     if err != nil {
  5.         log.Fatalf("failed to listen: %v", err)
  6.     }
  8.     // create grpc server
  9.     s := grpc.NewServer()
  10.     pb.RegisterAppCallbackServer(s, &server{})
  12.     fmt.Println("Client starting...")
  14.     // and start...
  15.     if err := s.Serve(lis); err != nil {
  16.         log.Fatalf("failed to serve: %v", err)
  17.     }
  18. }

This creates a gRPC server for your app on port 4000.

  1. Run your app

To run locally, use the Dapr CLI:

  1. dapr run --app-id goapp --app-port 4000 --app-protocol grpc go run main.go

On Kubernetes, set the required dapr.io/app-protocol: "grpc" and annotations in your pod spec template as mentioned above.