APIs síncronas: REST e gRPC
Projete APIs de requisição e resposta entre serviços, evolua-as sem quebrar os clientes e faça o orçamento de latência das cadeias de chamadas.
- Comparar REST sobre HTTP/JSON com gRPC sobre HTTP/2 e Protocol Buffers
- Evoluir uma API sem quebrar quem a consome: mudanças aditivas, versionamento e descontinuação
- Estimar a latência de cadeias de chamadas em série e em paralelo, e definir timeouts
Quando o serviço de Pedidos precisa do preço de um prato agora, ele pergunta ao serviço de Cardápio e espera. Isso é comunicação síncrona: requisição e resposta. Os dois estilos mais comuns:
| REST | gRPC | |
|---|---|---|
| Transporte | HTTP/1.1 ou 2 | HTTP/2 |
| Conteúdo | JSON (legível por pessoas) | Protocol Buffers (binário compacto) |
| Contrato | documento OpenAPI, muitas vezes opcional | arquivo .proto, obrigatório, gera o código do cliente e do servidor |
| Pontos fortes | universal, fácil de depurar com curl, ótimo para APIs públicas | rápido, fortemente tipado, com streaming, ótimo entre serviços internos |
1GET /menu/dishes/42 HTTP/1.1
2Host: menu.internal
3Accept: application/json
4
5HTTP/1.1 200 OK
6Content-Type: application/json
7
8{"id": 42, "name": "Spicy Miso Ramen", "price_cents": 1450, "spicy_level": 3}1syntax = "proto3";
2
3service Menu {
4 rpc GetDish (GetDishRequest) returns (Dish);
5}
6
7message GetDishRequest {
8 int32 id = 1;
9}
10
11message Dish {
12 int32 id = 1;
13 string name = 2;
14 int32 price_cents = 3;
15 int32 spicy_level = 4; // added later: old clients simply ignore it
16}Evoluindo APIs sem quebrar ninguém
O deploy independente só funciona se um serviço puder mudar a sua API sem obrigar todos os que o chamam a mudar no mesmo momento. As regras para uma resposta que outros leem:
| Mudança | Segura? |
|---|---|
| Adicionar um campo opcional novo | ✅ clientes antigos o ignoram ( leitor tolerante (tolerant reader): os clientes devem ignorar campos desconhecidos) |
| Remover um campo | ❌ os clientes que o leem quebram |
| Renomear um campo | ❌ equivale a remover e adicionar |
Mudar o tipo de um campo ("1450" → 1450) | ❌ |
| Tornar opcional um campo obrigatório (pode passar a faltar) | ❌ para quem depende dele |
Quando você precisar quebrar algo, versione: /v2/menu/dishes/42 (ou um novo serviço gRPC), rode a v1 e a v2 lado a lado, avise os consumidores sobre a descontinuação e só remova a v1 quando o tráfego dela tiver acabado. No protobuf, nunca reutilize (reuse) o número de um campo.
A latência se acumula
Cada salto síncrono acrescenta latência, e uma cadeia só é tão disponível quanto todos os seus elos multiplicados: cinco serviços com 99,9% de disponibilidade cada dão cerca de 99,5%. Quando as chamadas não dependem umas das outras, faça-as em paralelo - o total passa a ser a mais lenta, não a soma. E sempre defina um timeout: sem ele, um serviço lento mais adiante prende as suas threads até você cair também.
1menu, customer, stock, payment = 40, 60, 25, 120 # milliseconds
2
3serial = menu + customer + stock + payment
4parallel_then_pay = max(menu, customer, stock) + payment # the three lookups don't depend on each other
5print(f"all serial: {serial} ms")
6print(f"lookups in parallel, then pay: {parallel_then_pay} ms")
7print(f"availability of 4 services at 99.9%: {0.999 ** 4:.4%}")all serial: 245 ms lookups in parallel, then pay: 180 ms availability of 4 services at 99.9%: 99.6006%
Principais conclusões
REST (HTTP + JSON) é universal e fácil de depurar; gRPC (HTTP/2 + protobuf) é rápido e fortemente tipado.
Mudanças aditivas são seguras; remover, renomear ou mudar o tipo de campos quebra os consumidores - versione e descontinue em vez disso.
Latência e falhas se acumulam ao longo de cadeias síncronas; paralelize as chamadas independentes.
Toda chamada remota precisa de um timeout.
Quiz da aula
7 perguntas · aprovação com 5 acertos · até 50 XP
Ao passar, você conclui a aula e mantém sua sequência. As perguntas erradas voltarão em sessões de revisão.
Pratique: simule padrões de microsserviços com Python
Crie pequenas simulações em Python dos padrões, como roteadores, sagas, outboxes, circuit breakers e traces, e execute-as com entradas de exemplo. Elas rodam localmente no navegador; não é preciso ter servidores nem contêineres.
Esta mudança quebra?
A entrada tem linhas de campo old: e depois linhas de campo new:, de um esquema de resposta: name type required|optional. Compare os dois e imprima uma linha por diferença, na ordem dos campos antigos e depois os campos novos, em ordem:
removed price: BREAKINGprice_cents: type int -> string BREAKINGspicy_level: required -> optional BREAKING(os leitores dependiam dele)notes: optional -> required okadded allergens: ok
Depois, verdict: compatible ou verdict: breaking (needs a new version).
- Release arriscado
- Release seguro
O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.
Caiba no orçamento de latência
A primeira linha da entrada é o orçamento de latência em milissegundos. Cada linha seguinte é uma etapa da requisição: serial name=ms (uma chamada) ou parallel name=ms name=ms ... (chamadas feitas ao mesmo tempo). As etapas rodam uma depois da outra. Imprima o custo de cada etapa (stage 1 (parallel): 60 ms, slowest customer), depois total: 180 ms of 200 ms - ok ou - OVER BUDGET by 25 ms. Por fim, imprima a chamada individual mais lenta: slowest call: payment (120 ms).
- Checkout
- Lento demais
O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.
Dúvidas sobre esta lição
Travou em algum ponto? Pergunte. Descobriu algo? Compartilhe. Explicar também é uma ótima forma de aprender.
Carregando publicações…