Master gRPC: From Basics to Building a Python Microservice

gRPC is a high‑performance open‑source RPC framework built on HTTP/2 and Protocol Buffers, supporting many languages.

What is gRPC?

RPC frameworks aim to make remote service calls simple and transparent, hiding transport (TCP/UDP), serialization (XML/JSON) and communication details so callers can invoke remote services like local functions.

Why HTTP/2?

HTTP/2 provides multiplexing, allowing multiple streams over a single connection and avoiding head‑of‑line blocking of HTTP/1.1, which improves compatibility and performance.

Core concepts of gRPC

An introduction to gRPC and protocol buffers.

Protocol Buffers (".proto" files) define data structures; the

protoc

tool generates language‑specific code, offering faster serialization and smaller payloads.

Writing a .proto file

<code>// Specify syntax
syntax = "proto3";

// Define a package
package greeterpb;

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

// Request message
message HelloRequest {
    string name = 1;
}

// Response message
message HelloReply {
    string message = 1;
}
</code>

Compiling the .proto file

<code># Compile proto file
python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. helloworld.proto
</code>

Server implementation (Python)

<code># helloworld_grpc_server.py
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()
</code>

Client implementation (Python)

<code># helloworld_grpc_client.py
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()
</code>

Quick start steps

1. Create a virtual environment and activate it.

<code>python -m pip install virtualenv
virtualenv venv
source venv/bin/activate
python -m pip install --upgrade pip
</code>

2. Install gRPC packages.

<code>python -m pip install grpcio
python -m pip install grpcio-tools
</code>

3. Clone the gRPC repository and run the hello‑world example.

<code>git clone -b v1.37.1 https://github.com/grpc/grpc
cd grpc/examples/python/helloworld
python greeter_server.py   # start server
python greeter_client.py   # run client
</code>

Application scenarios

gRPC is well suited for microservice architectures where language neutrality and high performance are required, such as backend services written in Go communicating with front‑end services written in JavaScript.

It can be deployed on Kubernetes for scalable, cloud‑native deployments.