Python + gRPC + RPC + Streaming

Por

O REST funciona bem, até deixar de funcionar. Quando você tem comunicação entre serviços que precisa de baixa latência, eficiência binária ou streaming, bate no teto do REST rapidamente. O gRPC resolve isso com Protocol Buffers para serialização compacta e HTTP/2 para transporte multiplexado.

TL;DR: Construa um serviço Python com gRPC usando unary RPC e streaming, da definição do arquivo proto até a implementação do cliente e servidor.
Stack: Python, gRPC, Protocol Buffers (protobuf), grpcio
Nível: Intermediário
Tempo de leitura: ~8 min

Pense no arquivo .proto como um contrato tipado entre seus serviços: ambos os lados concordam com os formatos das mensagens antes de qualquer código rodar. Se o contrato quebrar, o build falha, não a produção.

Por que gRPC

O gRPC usa HTTP/2 para transporte e Protocol Buffers para serialização, tornando-o mais rápido e compacto que o REST tradicional sobre HTTP/1.1 com JSON. A serialização binária do Protobuf gera mensagens menores, o multiplexing do HTTP/2 permite que várias requisições compartilhem uma conexão, e conexões persistentes eliminam o overhead de reconectar a cada chamada.

Criar o arquivo proto

O arquivo proto é a fonte da verdade para a sua API. Ele define os métodos do serviço e os tipos de mensagem. O código Python gerado vem desse arquivo.

syntax = "proto3";

package order;

service OrderService {
  rpc CreateOrder (OrderRequest) returns (OrderConfirmation) {}
}

message OrderRequest {
  string customer_name = 1;
  string product_name = 2;
  int32 quantity = 3;
}

message OrderConfirmation {
  string order_id = 1;
  string message = 2;
}

Instalar grpcio

pip install grpcio

Gerar stubs Python

python3 -m grpc_tools.protoc -I. --python_out=./order_request --grpc_python_out=./order_request order_request/order.proto

Implementar server.py

import grpc
from concurrent import futures
import order_pb2
import order_pb2_grpc

class OrderService(order_pb2_grpc.OrderServiceServicer):
    def CreateOrder(self, request, context):
        order_id = "ORDER-123"
        message = f"Pedido criado! ID: {order_id}"
        return order_pb2.OrderConfirmation(order_id=order_id, message=message)

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    order_pb2_grpc.add_OrderServiceServicer_to_server(OrderService(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    server.wait_for_termination()

if __name__ == '__main__':
    serve()

Implementar client.py

import grpc
import order_pb2
import order_pb2_grpc

def run():
    with grpc.insecure_channel('localhost:50051') as channel:
        stub = order_pb2_grpc.OrderServiceStub(channel)
        response = stub.CreateOrder(order_pb2.OrderRequest(
            customer_name="João Silva",
            product_name="Produto A",
            quantity=2
        ))
        print(f"Resposta do servidor: {response.message}")

if __name__ == '__main__':
    run()

O que você construiu

Um serviço Python gRPC funcional com um contrato proto definindo mensagens e métodos, um servidor que implementa esses métodos, e um cliente que os chama. O mesmo padrão escala para streaming bidirecional e streaming server-side mudando a definição proto e a implementação do serviço.

Próximos passos

  • Adicione streaming server-side usando stream no tipo de retorno do proto e yield nas respostas do método servidor.
  • Adicione TLS ou mutual TLS entre seus serviços gRPC, especialmente se eles se comunicam por fronteiras de rede.
  • Integre com um service mesh como Envoy ou Istio para load balancing, retries e observabilidade no seu tráfego gRPC sem tocar no código da aplicação.

Dúvidas ou feedback? Me encontre no LinkedIn ou GitHub.

Deixe um comentário