gRPC Streaming

You are a gRPC protocol expert. The user wants to implement server-side streaming, client-side streaming, and bidirectional streaming with gRPC using protocol buffers.

What to check first

• Run protoc --version to ensure protocol buffer compiler is installed
• Verify your gRPC language runtime is installed: npm list grpc (Node.js) or pip list | grep grpcio (Python)
• Check that your .proto file is in the correct directory and includes syntax = "proto3"; at the top

Steps

1. Define your proto messages and service with streaming RPC methods using stream keyword in .proto file
2. Compile proto files with protoc --go_out=. --go-grpc_out=. service.proto (Go) or equivalent for your language
3. Implement the service interface in your server code, handling Send() for server-streaming and receiving streams for client/bidirectional
4. Create a server listener with lis, err := net.Listen("tcp", ":50051") and register your service
5. In client code, call streaming methods which return grpc.ServerStream or grpc.ClientStream interface
6. Use stream.Send() to write messages and stream.Recv() to read messages in a loop
7. Call stream.SendAndClose() on server side when done sending in client-streaming scenarios
8. Handle context cancellation with context.WithCancel() for graceful shutdown of long-lived streams

Code

// chat.proto
syntax = "proto3";

package chat;
option go_package = "github.com/example/chat";

message Message {
  string sender = 1;
  string text = 2;
}

service ChatService {
  // Server streaming: one request, multiple responses
  rpc GetMessages(Message) returns (stream Message);
  
  // Client streaming: multiple requests, one response
  rpc SendMessages(stream Message) returns (Message);
  
  // Bidirectional streaming: multiple requests and responses
  rpc Chat(stream Message) returns (stream Message);
}

// server.go
package main

import (
	"context"
	"fmt"
	"io"
	"log"
	"net"
	"google.golang.org/grpc"
	pb "github.com/example/chat"
)

type server struct {
	pb.UnimplementedChatServiceServer
}

// Server streaming: send multiple messages for one request
func (s *server) GetMessages(req *pb.Message, stream grpc.ServerStream) error {
	for i := 0; i < 3; i++ {
		response := &pb.Message{
			Sender: "Server",
			Text:   fmt.Sprintf("Message %d from %s", i+1, req.Sender),
		}
		if err := stream.SendMsg(response); err != nil {
			return err

Note: this example was truncated in the source. See the GitHub repo for the latest full version.

Common Pitfalls

• Treating this skill as a one-shot solution — most workflows need iteration and verification
• Skipping the verification steps — you don't know it worked until you measure
• Applying this skill without understanding the underlying problem — read the related docs first

When NOT to Use This Skill

• When a simpler manual approach would take less than 10 minutes
• On critical production systems without testing in staging first
• When you don't have permission or authorization to make these changes

How to Verify It Worked

• Run the verification steps documented above
• Compare the output against your expected baseline
• Check logs for any warnings or errors — silent failures are the worst kind

Production Considerations

• Test in staging before deploying to production
• Have a rollback plan — every change should be reversible
• Monitor the affected systems for at least 24 hours after the change