How to: Use the gRPC interface in your Dapr application

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.

Find a list of auto-generated clients in the Dapr SDK documentation.

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

In addition to calling Dapr via gRPC, Dapr supports service-to-service calls with gRPC by acting as a proxy. Learn more in the gRPC service invocation how-to guide.

This guide demonstrates configuring and invoking Dapr with gRPC using a Go SDK application.

Configure Dapr to communicate with an app via gRPC

• Self-hosted
• Kubernetes

dapr run --app-protocol grpc --app-port 5005 node app.js

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
  namespace: default
  labels:
    app: myapp
spec:
  replicas: 1
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
      annotations:
        dapr.io/enabled: "true"
        dapr.io/app-id: "myapp"
        dapr.io/app-protocol: "grpc"
        dapr.io/app-port: "5005"
...

Invoke Dapr with gRPC

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

1. Import the package:

   package main
   
   import (
   	"context"
   	"log"
   	"os"
   
   	dapr "github.com/dapr/go-sdk/client"
   )
   

2. Create the client:

   // just for this demo
   ctx := context.Background()
   data := []byte("ping")
   
   // create the client
   client, err := dapr.NewClient()
   if err != nil {
     log.Panic(err)
   }
   defer client.Close()
   

   3. Invoke the SaveState method:

   // save state with the key key1
   err = client.SaveState(ctx, "statestore", "key1", data)
   if err != nil {
     log.Panic(err)
   }
   log.Println("data saved")
   

Now you can explore all the different methods on the Dapr client.

Create a gRPC app with Dapr

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

1. Import the package:

   package main
   
   import (
   	"context"
   	"fmt"
   	"log"
   	"net"
   
   	"github.com/golang/protobuf/ptypes/any"
   	"github.com/golang/protobuf/ptypes/empty"
   
   	commonv1pb "github.com/dapr/dapr/pkg/proto/common/v1"
   	pb "github.com/dapr/dapr/pkg/proto/runtime/v1"
   	"google.golang.org/grpc"
   )
   

2. Implement the interface:

   // server is our user app
   type server struct {
        pb.UnimplementedAppCallbackServer
   }
   
   // EchoMethod is a simple demo method to invoke
   func (s *server) EchoMethod() string {
   	return "pong"
   }
   
   // This method gets invoked when a remote service has called the app through Dapr
   // The payload carries a Method to identify the method, a set of metadata properties and an optional payload
   func (s *server) OnInvoke(ctx context.Context, in *commonv1pb.InvokeRequest) (*commonv1pb.InvokeResponse, error) {
   	var response string
   
   	switch in.Method {
   	case "EchoMethod":
   		response = s.EchoMethod()
   	}
   
   	return &commonv1pb.InvokeResponse{
   		ContentType: "text/plain; charset=UTF-8",
   		Data:        &any.Any{Value: []byte(response)},
   	}, nil
   }
   
   // Dapr will call this method to get the list of topics the app wants to subscribe to. In this example, we are telling Dapr
   // To subscribe to a topic named TopicA
   func (s *server) ListTopicSubscriptions(ctx context.Context, in *empty.Empty) (*pb.ListTopicSubscriptionsResponse, error) {
   	return &pb.ListTopicSubscriptionsResponse{
   		Subscriptions: []*pb.TopicSubscription{
   			{Topic: "TopicA"},
   		},
   	}, nil
   }
   
   // Dapr will call this method to get the list of bindings the app will get invoked by. In this example, we are telling Dapr
   // To invoke our app with a binding named storage
   func (s *server) ListInputBindings(ctx context.Context, in *empty.Empty) (*pb.ListInputBindingsResponse, error) {
   	return &pb.ListInputBindingsResponse{
   		Bindings: []string{"storage"},
   	}, nil
   }
   
   // This method gets invoked every time a new event is fired from a registered binding. The message carries the binding name, a payload and optional metadata
   func (s *server) OnBindingEvent(ctx context.Context, in *pb.BindingEventRequest) (*pb.BindingEventResponse, error) {
   	fmt.Println("Invoked from binding")
   	return &pb.BindingEventResponse{}, nil
   }
   
   // This method is fired whenever a message has been published to a topic that has been subscribed. Dapr sends published messages in a CloudEvents 0.3 envelope.
   func (s *server) OnTopicEvent(ctx context.Context, in *pb.TopicEventRequest) (*pb.TopicEventResponse, error) {
   	fmt.Println("Topic message arrived")
           return &pb.TopicEventResponse{}, nil
   }
   

3. Create the server:

   func main() {
   	// create listener
   	lis, err := net.Listen("tcp", ":50001")
   	if err != nil {
   		log.Fatalf("failed to listen: %v", err)
   	}
   
   	// create grpc server
   	s := grpc.NewServer()
   	pb.RegisterAppCallbackServer(s, &server{})
   
   	fmt.Println("Client starting...")
   
   	// and start...
   	if err := s.Serve(lis); err != nil {
   		log.Fatalf("failed to serve: %v", err)
   	}
   }
   

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

Run the application

• Self-hosted
• Kubernetes

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

Other languages

You can use Dapr with any language supported by Protobuf, and not just with the currently available generated SDKs.

Using the protoc tool, you can generate the Dapr clients for other languages like Ruby, C++, Rust, and others.

Related Topics

• Service invocation building block
• Service invocation API specification