Mastering gRPC with Python: From Basics to Real‑World Microservices

Overview of gRPC

gRPC is a high‑performance open‑source RPC framework built on HTTP/2 and using Protocol Buffers (protobuf) for efficient binary serialization. It abstracts transport and serialization so that remote procedures can be invoked as if they were local functions.

Why HTTP/2

HTTP/2 provides multiplexed streams over a single TCP connection, eliminating head‑of‑line blocking and reducing latency, which makes gRPC well‑suited for high‑throughput service‑to‑service communication.

Protocol Buffers

Protobuf defines data structures in language‑neutral .proto files. The protoc compiler generates source code for many languages, producing compact payloads and fast encode/decode.

Define a service

syntax = "proto3";
package greeterpb;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
  rpc SayHelloAgain (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Generate Python stubs

Install the required packages:

python -m pip install --upgrade pip
python -m pip install grpcio grpcio-tools

Compile the proto file with the gRPC plugin:

python -m grpc_tools.protoc \
    --python_out=. \
    --grpc_python_out=. \
    -I. helloworld.proto

This creates helloworld_pb2.py (message classes) and helloworld_pb2_grpc.py (service base classes and client stub).

Server implementation (Python)

from concurrent import futures
import time, grpc
import helloworld_pb2, helloworld_pb2_grpc

class Greeter(helloworld_pb2_grpc.GreeterServicer):
    def SayHello(self, request, context):
        return helloworld_pb2.HelloReply(message=f'hello {request.name}')
    def SayHelloAgain(self, request, context):
        return helloworld_pb2.HelloReply(message=f'hello {request.name}')

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    try:
        while True:
            time.sleep(86400)  # keep alive
    except KeyboardInterrupt:
        server.stop(0)

if __name__ == '__main__':
    serve()

Client implementation (Python)

import grpc
import helloworld_pb2, helloworld_pb2_grpc

def run():
    channel = grpc.insecure_channel('localhost:50051')
    stub = helloworld_pb2_grpc.GreeterStub(channel)
    resp1 = stub.SayHello(helloworld_pb2.HelloRequest(name='Alice'))
    print('Response:', resp1.message)
    resp2 = stub.SayHelloAgain(helloworld_pb2.HelloRequest(name='Bob'))
    print('Response:', resp2.message)

if __name__ == '__main__':
    run()

Running the example

Start the server in one terminal: python3 helloworld_grpc_server.py In another terminal run the client:

python3 helloworld_grpc_client.py

Typical use cases

gRPC is commonly used in microservice architectures where language‑agnostic, low‑latency RPC is required. It works well for server‑to‑server communication and can also be used from mobile or web clients when HTTP/2 support is available.

Deploying gRPC in Kubernetes

Deploy a gRPC server as a standard container: create a Deployment, expose it with a Service, and optionally place an Envoy sidecar or other HTTP/2‑aware proxy to handle traffic routing and observability.

References

Original article: https://www.escapelife.site/posts/395e12c9.html