Build High‑Performance Go Microservices with gRPC and Protobuf

1. Why choose gRPC?

gRPC is a high‑performance RPC framework developed by Google, built on HTTP/2. Its advantages include binary Protobuf encoding (more compact than JSON), bidirectional streaming, automatic code generation, and cross‑language support (Go, Python, Java, C++, etc.). Compared with traditional REST APIs, gRPC offers lower latency and higher throughput, especially under high concurrency.

2. Protobuf basics: defining service interfaces

Protobuf uses

.proto

files to describe services and message structures. The example below defines a simple Calculator service with an

Add

RPC method and the corresponding request and response messages.

<code>// calculator.proto
syntax = "proto3";

package calculator;

service Calculator {
  rpc Add (AddRequest) returns (AddResponse);
}

message AddRequest {
  int32 a = 1;
  int32 b = 2;
}

message AddResponse {
  int32 result = 1;
}
</code>

The service definition creates the RPC method, and the request/response messages define input and output data.

3. Generating Go code

Running the Protocol Buffers compiler generates Go source files:

<code>protoc --go_out=. --go-grpc_out=. calculator.proto</code>

This command produces

calculator.pb.go

and

calculator_grpc.pb.go

, which contain the client and server stubs.

4. Implementing the gRPC server in Go

<code>package main

import (
    "context"
    "log"
    "net"

    "google.golang.org/grpc"
    pb "path/to/calculator" // replace with your package path
)

type server struct {
    pb.UnimplementedCalculatorServer
}

func (s *server) Add(ctx context.Context, req *pb.AddRequest) (*pb.AddResponse, error) {
    result := req.A + req.B
    return &pb.AddResponse{Result: result}, nil
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterCalculatorServer(s, &server{})
    log.Println("Server running on :50051")
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}
</code>

5. Implementing the gRPC client in Go

<code>package main

import (
    "context"
    "log"
    "os"
    "time"

    "google.golang.org/grpc"
    pb "path/to/calculator" // replace with your package path
)

func main() {
    conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()

    c := pb.NewCalculatorClient(conn)
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()

    res, err := c.Add(ctx, &pb.AddRequest{A: 5, B: 3})
    if err != nil {
        log.Fatalf("could not add: %v", err)
    }
    log.Printf("Result: %d", res.Result)
}
</code>

6. Testing

Start the server with

go run server.go

, then run the client with

go run client.go

. The client prints:

<code>Result: 8</code>

7. gRPC vs REST performance comparison

Key metrics:

Data size: gRPC uses smaller binary payloads, REST uses larger text payloads.

Parsing speed: gRPC parses faster, REST slower.

Latency: gRPC (HTTP/2) has lower latency, REST (HTTP/1.1) higher.

Streaming support: gRPC offers full bidirectional streaming; REST provides limited streaming via SSE or WebSocket.

8. Conclusion

gRPC is best suited for internal microservice communication (e.g., Kubernetes clusters).

REST is more appropriate for public-facing APIs.

9. Advanced: gRPC streaming modes

gRPC supports four communication patterns:

Unary (single request‑response).

Server streaming (server sends a stream of messages).

Client streaming (client sends a stream of messages).

Bidirectional streaming (both sides exchange streams simultaneously).

Future tutorials will explore these streaming modes in depth.