Protocol Buffers in Go: Serialization, gRPC, and Performance

brew install protobuf

go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

syntax = "proto3";

package user;

option go_package = "github.com/yourname/yourapp/gen/userpb";

message Address {
  string street = 1;
  string city   = 2;
  string country = 3;
}

message User {
  string   id      = 1;
  string   name    = 2;
  string   email   = 3;
  int32    age     = 4;
  Address  address = 5;
}

message GetUserRequest {
  string id = 1;
}

message ListUsersResponse {
  repeated User users = 1;
}

message CreateUserRequest {
  User user = 1;
}

service UserService {
  rpc GetUser(GetUserRequest)       returns (User);
  rpc ListUsers(google.protobuf.Empty) returns (ListUsersResponse);
  rpc CreateUser(CreateUserRequest) returns (User);
}

protoc \
  --go_out=gen/userpb --go_opt=paths=source_relative \
  --go-grpc_out=gen/userpb --go-grpc_opt=paths=source_relative \
  user.proto

package main

import (
	"fmt"
	"log"

	"google.golang.org/protobuf/proto"

	userpb "github.com/yourname/yourapp/gen/userpb"
)

func main() {
	original := &userpb.User{
		Id:    "usr-001",
		Name:  "Alice",
		Email: "alice@example.com",
		Age:   31,
		Address: &userpb.Address{
			Street:  "10 Downing Street",
			City:    "London",
			Country: "UK",
		},
	}

	// Serialize to wire bytes.
	data, err := proto.Marshal(original)
	if err != nil {
		log.Fatalf("marshal: %v", err)
	}
	fmt.Printf("wire size: %d bytes\n", len(data))

	// Deserialize back into a new message.
	decoded := &userpb.User{}
	if err := proto.Unmarshal(data, decoded); err != nil {
		log.Fatalf("unmarshal: %v", err)
	}

	fmt.Printf("name: %s, city: %s\n", decoded.Name, decoded.Address.City)
}

package server

import (
	"context"
	"sync"

	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/types/known/emptypb"

	userpb "github.com/yourname/yourapp/gen/userpb"
)

type UserServer struct {
	userpb.UnimplementedUserServiceServer
	mu    sync.RWMutex
	store map[string]*userpb.User
}

func NewUserServer() *UserServer {
	return &UserServer{store: make(map[string]*userpb.User)}
}

func (s *UserServer) GetUser(ctx context.Context, req *userpb.GetUserRequest) (*userpb.User, error) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	u, ok := s.store[req.Id]
	if !ok {
		return nil, status.Errorf(codes.NotFound, "user %q not found", req.Id)
	}
	return u, nil
}

func (s *UserServer) ListUsers(ctx context.Context, _ *emptypb.Empty) (*userpb.ListUsersResponse, error) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	users := make([]*userpb.User, 0, len(s.store))
	for _, u := range s.store {
		users = append(users, u)
	}
	return &userpb.ListUsersResponse{Users: users}, nil
}

func (s *UserServer) CreateUser(ctx context.Context, req *userpb.CreateUserRequest) (*userpb.User, error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.store[req.User.Id] = req.User
	return req.User, nil
}

package main

import (
	"log"
	"net"

	"google.golang.org/grpc"

	userpb "github.com/yourname/yourapp/gen/userpb"
	"github.com/yourname/yourapp/server"
)

func main() {
	lis, err := net.Listen("tcp", ":50051")
	if err != nil {
		log.Fatalf("listen: %v", err)
	}
	s := grpc.NewServer()
	userpb.RegisterUserServiceServer(s, server.NewUserServer())
	log.Println("gRPC server listening on :50051")
	log.Fatal(s.Serve(lis))
}

package main

import (
	"context"
	"log"
	"time"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"

	userpb "github.com/yourname/yourapp/gen/userpb"
)

func main() {
	conn, err := grpc.NewClient(
		"localhost:50051",
		grpc.WithTransportCredentials(insecure.NewCredentials()),
	)
	if err != nil {
		log.Fatalf("dial: %v", err)
	}
	defer conn.Close()

	client := userpb.NewUserServiceClient(conn)

	// Every call gets its own deadline-bounded context.
	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()

	user, err := client.CreateUser(ctx, &userpb.CreateUserRequest{
		User: &userpb.User{
			Id:    "usr-001",
			Name:  "Alice",
			Email: "alice@example.com",
			Age:   31,
		},
	})
	if err != nil {
		log.Fatalf("CreateUser: %v", err)
	}
	log.Printf("created: %s", user.Id)
}