Carregando
0x30Lição 4 de 15

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.

28 min Questionário com 7 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • 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:

RESTgRPC
TransporteHTTP/1.1 ou 2HTTP/2
ConteúdoJSON (legível por pessoas)Protocol Buffers (binário compacto)
Contratodocumento OpenAPI, muitas vezes opcionalarquivo .proto, obrigatório, gera o código do cliente e do servidor
Pontos fortesuniversal, fácil de depurar com curl, ótimo para APIs públicasrápido, fortemente tipado, com streaming, ótimo entre serviços internos
REST: get a dish
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}
menu.proto (gRPC)
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çaSegura?
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.

latency_budget.py
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%}")
Saída
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.

Exercício 1

Esta mudança quebra?

+25 XP

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: BREAKING
  • price_cents: type int -> string BREAKING
  • spicy_level: required -> optional BREAKING (os leitores dependiam dele)
  • notes: optional -> required ok
  • added allergens: ok

Depois, verdict: compatible ou verdict: breaking (needs a new version).

  • Release arriscado
  • Release seguro
main.py
Carregando editor…

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.

Exercício 2

Caiba no orçamento de latência

+25 XP

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
main.py
Carregando editor…

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…