Master gRPC: Build High‑Performance RPC Services with Python

gRPC is a high‑performance, general‑purpose open‑source RPC framework built on HTTP/2 and using Protocol Buffers for serialization, supporting many programming languages.

What is the gRPC framework

The goal of an RPC framework is to make remote service calls simple and transparent by hiding transport (TCP/UDP), serialization (XML/JSON) and communication details, allowing callers to invoke remote services as if they were local.

Key advantages

High compatibility, high performance, easy to use

Components

Uses HTTP/2 as the transport layer

Uses protobuf as a high‑performance serialization protocol

Generates SDKs via the protoc gRPC plugin

Communication patterns

Unary: client sends one request, server sends one response

Server‑streaming: client sends one request, server sends multiple responses

Client‑streaming: client sends multiple requests, server sends one response

Bidi‑streaming: both sides exchange multiple messages

Why HTTP/2

HTTP/2 provides maximum service compatibility and is widely supported by proxy tools. Its main advantage is multiplexing, allowing multiple streams to share a single connection without head‑of‑line blocking.

Core concepts: Protocol Buffers

ProtoBuf defines data structures in .proto files, similar to JSON or XML. The protoc tool generates language‑specific classes, offering faster encoding/decoding and smaller payloads.

Define a proto file

syntax = "proto3";

package greeterpb;

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

// Message definitions
message HelloRequest {
    string name = 1;
}
message HelloReply {
    string message = 1;
}

Compile the proto

Use protoc with the following options: --python_out: output path for protobuf‑generated code --grpc_python_out: output path for gRPC‑generated code -I: include path for .proto files

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

Server implementation (Python)

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

class Greeter(helloworld_pb2_grpc.GreeterServicer):
    def SayHello(self, request, context):
        return helloworld_pb2.HelloReply(message='hello {}'.format(request.name))
    def SayHelloAgain(self, request, context):
        return helloworld_pb2.HelloReply(message='hello {}'.format(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(60*60*24)
    except KeyboardInterrupt:
        server.stop(0)

if __name__ == '__main__':
    serve()

Client implementation (Python)

import grpc
import helloworld_pb2
import helloworld_pb2_grpc

def run():
    channel = grpc.insecure_channel('localhost:50051')
    stub = helloworld_pb2_grpc.GreeterStub(channel)
    response = stub.SayHello(helloworld_pb2.HelloRequest(name='czl'))
    print("Greeter client received: " + response.message)
    response = stub.SayHelloAgain(helloworld_pb2.HelloRequest(name='daydaygo'))
    print("Greeter client received: " + response.message)

if __name__ == '__main__':
    run()

Quick start

Set up a virtual environment, install grpcio and grpcio-tools, clone the gRPC repository, and run the example server and client:

# Create virtual environment
python -m pip install virtualenv
virtualenv venv
source venv/bin/activate
python -m pip install --upgrade pip

# Install gRPC packages
python -m pip install grpcio grpcio-tools

# Clone example repository
git clone -b v1.37.1 https://github.com/grpc/grpc
cd grpc/examples/python/helloworld

# Run
python greeter_server.py
python greeter_client.py

Updating the service

Modify the .proto file, regenerate code with protoc, and adjust client/server code accordingly.

Application scenarios

gRPC is well suited for microservice architectures, especially when language neutrality and high performance are required, and it integrates smoothly with Kubernetes deployments.