gRPC for Microservices

Why gRPC Matters

Microservices multiply the cost of every protocol decision. A request that crosses 8 services on its way to a database pays the JSON tax 8 times. Multiply that by your QPS and the difference between “fine” and “painful” is measured in racks of servers. gRPC was built at Google specifically because at their scale the savings were unignorable, and the same math applies to anyone whose internal east-west traffic is in the millions of RPS.

What gRPC actually gives you

• A contract. The .proto file is checked into git, reviewed in PRs, versioned, and used to generate clients and servers in every language you support.
• A small wire format. Protocol Buffers are typically 3–10x smaller than equivalent JSON.
• Streaming, first-class. Unary, server-streaming, client-streaming, and bidirectional — all on the same connection.
• Deadlines, cancellation, metadata, and back-pressure baked into the protocol, not bolted on per-service.
• Multi-language polyglot. Go, Java, C++, Python, Ruby, Node, C#, Rust, Kotlin, Swift, Dart all generated from the same source.

The Building Blocks

gRPC is a stack of three things that fit together cleanly. Knowing what each layer does makes debugging dramatically easier — you can say “the framing is fine but the proto schema drifted” instead of waving at the whole stack.

HTTP/2 in one paragraph

HTTP/1.1 opens one TCP connection per concurrent request (or pipelines poorly). HTTP/2 opens one TCP connection and multiplexes thousands of independent streams over it. Headers are compressed with HPACK so you don’t pay for repeating Authorization on every call. Streams have flow control, so a slow consumer can’t drown a fast producer. For an internal mesh making millions of calls between the same two pods, this is the difference between “TCP setup is half my latency” and “TCP setup is invisible.”

Protocol Buffers in one paragraph

Protobuf encodes each field as a small integer tag plus a varint-encoded value. There are no field names on the wire, no quotes, no whitespace. A 1 KB JSON object is often 200 bytes of protobuf. The schema is mandatory at compile time but invisible at runtime — both sides need the .proto to make sense of the bytes. That mandatory schema is the source of half the value.

Protocol Buffers Crash Course

This is the minimum proto3 you need to read and write production schemas. Save it as greeter/v1/greeter.proto:

syntax = "proto3";

package greeter.v1;

option go_package = "github.com/example/greeter/v1;greeterv1";

// Reserve numbers and names from removed fields so they can never be reused.
message Greeting {
  reserved 4, 7;
  reserved "old_field";

  string name           = 1;
  string language       = 2;   // e.g. "en", "ja"
  int32  enthusiasm     = 3;   // 1..10
  repeated string tags  = 5;   // arbitrary labels
  Mood   mood           = 6;

  oneof contact {
    string email = 8;
    string phone = 9;
  }

  optional string nickname = 10; // proto3 explicit presence
}

enum Mood {
  MOOD_UNSPECIFIED = 0;        // always reserve 0 for the default
  MOOD_HAPPY       = 1;
  MOOD_NEUTRAL     = 2;
  MOOD_GRUMPY      = 3;
}

message SayHelloRequest  { Greeting greeting = 1; }
message SayHelloResponse { string message = 1; }

service Greeter {
  // Unary
  rpc SayHello(SayHelloRequest) returns (SayHelloResponse);

  // Server streaming
  rpc SayHelloRepeatedly(SayHelloRequest) returns (stream SayHelloResponse);

  // Client streaming
  rpc SayHelloToCrowd(stream SayHelloRequest) returns (SayHelloResponse);

  // Bidirectional
  rpc ChatGreetings(stream SayHelloRequest) returns (stream SayHelloResponse);
}

Scalar types worth knowing

The Four RPC Patterns

Go server implementing all four

package main

import (
    "context"
    "io"
    "log"
    "net"

    "google.golang.org/grpc"
    greeterv1 "github.com/example/greeter/v1"
)

type server struct {
    greeterv1.UnimplementedGreeterServer
}

// 1. Unary
func (s *server) SayHello(ctx context.Context, req *greeterv1.SayHelloRequest) (*greeterv1.SayHelloResponse, error) {
    return &greeterv1.SayHelloResponse{Message: "hello " + req.GetGreeting().GetName()}, nil
}

// 2. Server streaming
func (s *server) SayHelloRepeatedly(req *greeterv1.SayHelloRequest, stream greeterv1.Greeter_SayHelloRepeatedlyServer) error {
    for i := 0; i < 5; i++ {
        if err := stream.Send(&greeterv1.SayHelloResponse{Message: "hello again"}); err != nil {
            return err
        }
    }
    return nil
}

// 3. Client streaming
func (s *server) SayHelloToCrowd(stream greeterv1.Greeter_SayHelloToCrowdServer) error {
    var names []string
    for {
        in, err := stream.Recv()
        if err == io.EOF {
            return stream.SendAndClose(&greeterv1.SayHelloResponse{
                Message: "hello to " + joinNames(names),
            })
        }
        if err != nil {
            return err
        }
        names = append(names, in.GetGreeting().GetName())
    }
}

// 4. Bidirectional
func (s *server) ChatGreetings(stream greeterv1.Greeter_ChatGreetingsServer) error {
    for {
        in, err := stream.Recv()
        if err == io.EOF {
            return nil
        }
        if err != nil {
            return err
        }
        if err := stream.Send(&greeterv1.SayHelloResponse{
            Message: "echo: " + in.GetGreeting().GetName(),
        }); err != nil {
            return err
        }
    }
}

func main() {
    lis, _ := net.Listen("tcp", ":50051")
    s := grpc.NewServer()
    greeterv1.RegisterGreeterServer(s, &server{})
    log.Fatal(s.Serve(lis))
}

Python client

import grpc
from greeter.v1 import greeter_pb2, greeter_pb2_grpc

def main():
    # Channels are long-lived. One per (host, port) per process.
    with grpc.insecure_channel("localhost:50051") as channel:
        stub = greeter_pb2_grpc.GreeterStub(channel)

        # Unary
        resp = stub.SayHello(
            greeter_pb2.SayHelloRequest(
                greeting=greeter_pb2.Greeting(name="Robbie", language="en"),
            ),
            timeout=2.0,
            metadata=[("x-request-id", "abc-123")],
        )
        print(resp.message)

        # Server streaming
        for r in stub.SayHelloRepeatedly(
            greeter_pb2.SayHelloRequest(greeting=greeter_pb2.Greeting(name="Robbie"))
        ):
            print(r.message)

        # Client streaming
        def gen():
            for name in ["Ada", "Linus", "Grace"]:
                yield greeter_pb2.SayHelloRequest(
                    greeting=greeter_pb2.Greeting(name=name),
                )
        print(stub.SayHelloToCrowd(gen()).message)

Schema Evolution

Protobuf’s wire format was designed for the “tolerant reader” principle: unknown fields are silently kept and re-emitted, missing fields take the default value, and field numbers are the only identity. That gives you a long list of safe changes:

Buf for schema CI

Buf is the tool you almost certainly want for managing .proto at scale. The relevant pieces:

• buf lint — consistent style: package naming, file layout, field-number gaps.
• buf breaking — compares HEAD to main and refuses PRs that break wire compatibility (renumbering a field, removing one without reserving, etc.).
• buf generate — replaces hand-rolled protoc invocations.
• Buf Schema Registry (BSR) — npm/pypi for protos, with versioned modules other repos can depend on instead of copying .proto files around.

Interceptors and Cross-Cutting Concerns

An interceptor sees every request and response on its way through. The four canonical uses:

• Auth. Validate a JWT in metadata; attach the caller identity to context.
• Observability. OpenTelemetry trace span per RPC, latency histograms, error counters by status code.
• Deadlines. Refuse already-expired requests; propagate the remaining budget to downstream calls.
• Retries / hedging. Built into the gRPC client config — declarative, not handwritten.

Client interceptor adding auth metadata (Go)

func AuthInterceptor(token string) grpc.UnaryClientInterceptor {
    return func(
        ctx context.Context,
        method string,
        req, reply interface{},
        cc *grpc.ClientConn,
        invoker grpc.UnaryInvoker,
        opts ...grpc.CallOption,
    ) error {
        ctx = metadata.AppendToOutgoingContext(ctx,
            "authorization", "Bearer "+token,
            "x-client-version", build.Version,
        )
        return invoker(ctx, method, req, reply, cc, opts...)
    }
}

conn, _ := grpc.Dial("orders:50051",
    grpc.WithUnaryInterceptor(AuthInterceptor(token)),
    grpc.WithStatsHandler(otelgrpc.NewClientHandler()), // OTel built-in
)

Server interceptor enforcing deadlines and tracing

func DeadlineInterceptor(min time.Duration) grpc.UnaryServerInterceptor {
    return func(
        ctx context.Context,
        req interface{},
        info *grpc.UnaryServerInfo,
        handler grpc.UnaryHandler,
    ) (interface{}, error) {
        deadline, ok := ctx.Deadline()
        if !ok {
            return nil, status.Error(codes.InvalidArgument, "deadline required")
        }
        if time.Until(deadline) < min {
            return nil, status.Error(codes.DeadlineExceeded, "insufficient time budget")
        }
        return handler(ctx, req)
    }
}

s := grpc.NewServer(
    grpc.ChainUnaryInterceptor(
        otelgrpc.UnaryServerInterceptor(),       // trace + metrics
        DeadlineInterceptor(50*time.Millisecond),    // budget guard
        AuthServerInterceptor(jwtVerifier),       // authn
        LoggingInterceptor(logger),               // structured logs
    ),
)

gRPC vs REST

Neither is universally better. The honest answer is “different tools, different boundaries.”

Browser and Edge

Three options for hitting gRPC from a browser

• gRPC-Web. A subset of gRPC translated by a proxy (typically Envoy or a sidecar). Streaming is server-side only. Mature and widely deployed.
• Connect. Buf’s protocol — same .proto, but supports three wire formats: gRPC, gRPC-Web, and Connect’s own JSON/protobuf-over-HTTP variant. Servers built with connect-go or connect-es speak all three on the same port. No proxy required.
• gRPC-gateway. Generates a REST/JSON facade in front of a gRPC service from annotations in the .proto. Great when you want a public REST API and an internal gRPC API from one source of truth.

TypeScript Connect client

import { createPromiseClient } from "@connectrpc/connect";
import { createConnectTransport } from "@connectrpc/connect-web";
import { Greeter } from "./gen/greeter/v1/greeter_connect";
import { Greeting } from "./gen/greeter/v1/greeter_pb";

const transport = createConnectTransport({
    baseUrl: "https://api.example.com",
    interceptors: [
        (next) => async (req) => {
            req.header.set("authorization", `Bearer ${getToken()}`);
            return await next(req);
        },
    ],
});

const client = createPromiseClient(Greeter, transport);

// Unary — works in any modern browser via fetch
const res = await client.sayHello({
    greeting: new Greeting({ name: "Robbie", language: "en" }),
});
console.log(res.message);

// Server streaming — iterate over async results
for await (const reply of client.sayHelloRepeatedly({
    greeting: new Greeting({ name: "Robbie" }),
})) {
    console.log(reply.message);
}

Real-World Examples

Google built Stubby in the early 2000s as the internal RPC framework that glued together every service in the company. gRPC, open-sourced in 2015, is Stubby with the Google-isms removed and the proto schema published. Internally, every microservice call at Google — trillions per second — flows through this stack.

Netflix migrated significant chunks of its internal communication to gRPC for the same reason it built Hystrix and Eureka before it: at Netflix scale, percent-level CPU savings translate to actual money and headroom. They contribute to the gRPC ecosystem and use it heavily for service mesh data planes.

Square rolled gRPC out across its mobile and backend teams, and built Wire, an alternative protobuf runtime optimized for Android. The driving force was mobile bandwidth: smaller payloads make the app faster on bad networks.

Dropbox wrote about their move from a homegrown RPC system to gRPC, citing the language polyglot support (they use Python, Go, Rust) and the existing tooling for retries, deadlines, and observability as the killer features — not raw performance.

Buf publishes Connect, the modern alternative protocol, and runs the Buf Schema Registry. Their bet is that the future of cross-org RPC isn’t plain gRPC but a wire-compatible superset that includes the browser path natively.

Cloudflare, Lyft, Uber, and Slack all use gRPC heavily for service-to-service communication. The thread is consistent: high-QPS internal traffic where the constants matter.

Best Practices

The single most useful sentence about gRPC