Microserviços em Produção: Comunicação Anti‑Caos

Você já viveu isso:

Você entrega. Passa no “funciona na minha máquina”. Sobe. Fica verde.

E aí chega a vida real.

• Um serviço fica lento (nem cai).

• O seu começa a acumular.

• O p99 sobe.

• O pool satura.

• O retry “pra ajudar” vira metralhadora.

• A fila cresce.

• A DLQ enche.

• Ninguém sabe onde começou.

• Todo mundo acha que “a culpa é do Kafka / do gateway / da rede / do outro time”.

E aí vem o pior: o incidente que não parece bug. Parece “azar”. Parece “hoje tá estranho”.

Só que não é azar.

É falta de critério. Falta de limite. Falta de contrato. Falta de operação.

Você não precisa de mais uma aula “REST vs gRPC” com opinião. Nem de “Kafka do zero”.

Você precisa de uma coisa muito mais valiosa:

Um jeito de decidir e construir comunicação que aguenta produção.

Este curso é sobre isso: tirar você do “eu acho” e colocar você no “eu decido”.

Sem hype. Sem religião de ferramenta. Com o mínimo operável que separa “microserviço bonito” de “microserviço de produção”.

O que esse curso resolve (de verdade)

Se hoje você:

• vive com medo de cascata quando uma dependência degrada

• não tem clareza de quando usar sync vs async vs tempo real

• já sofreu (ou vai sofrer) com duplicidade / out-of-order / reprocessamento

• não consegue diagnosticar rápido onde está o tempo e onde está o erro

• olha pra uma DLQ e só vê uma “lixeira que ninguém abre”

• sente que produção é uma caixa‑preta: “funciona… até não funcionar”

…então você está no lugar certo.

O que você vai conseguir fazer ao final do curso

Você vai sair com repertório e artefatos pra:

• Escolher sync/async/tempo real/gRPC com critérios claros (e defender a decisão)

• Construir integrações com limites e comportamento sob falha

• Evitar o anti‑pattern mais caro: “parece resiliência, vira incidente”

• Tratar duplicidade e reprocesso como realidade (sem prejuízo e sem pânico)

• Ter observabilidade mínima que encontra a verdade (sem debate de opinião)

• Operar com checklists e runbooks (pra não inventar processo no meio do fogo)

Qual o conteúdo (sem enrolação)

Você vai ver, com linguagem direta e foco em produção:

• Modelo mental de latência, falhas e cascata

• Sync vs Async (trade-offs reais e impacto em UX)

• REST de produção (semântica, erros e contrato)

• Timeout + retry (política, budget, backoff/jitter — sem DDoS acidental)

• Idempotência (o seguro‑vida do seu dinheiro e do seu estoque)

• At-least-once (duplicidade, out‑of‑order e reprocessamento seguro)

• DLQ + runbooks (quando a fila vira incêndio)

• Tempo real com critério (SSE vs WebSocket + limites e backpressure)

• gRPC (quando vale e quando só complica)

• Observabilidade mínima (logs, métricas, traces e correlação)

Materiais (pra você aplicar na segunda-feira)

Você não vai sair só com “entendi”. Você vai sair com artefatos.

Ao total são mais de 10 e aqui estão os principais:

• Matriz de decisão (sync/async, SSE/WS, REST/gRPC)

• Checklists de produção (o que revisar antes de ir pro ar)

• Runbooks (o que fazer quando dá ruim)

• Templates (contrato, envelope de evento, idempotência, SLO/SLI)

• Plano de prática de 14 dias (pra virar hábito, não “PDF esquecido”)

Pra quem é (e pra quem não é)

É pra você se:

• já construiu APIs/integrações e quer parar de sofrer com produção

• é pleno/sênior e quer critério e padrão pra você (e pro time)

• quer pensar como quem opera, não como quem só entrega feature

Não é pra você se:

• quer “hello world” de ferramenta

• quer copiar e colar sem pensar em comportamento sob falha

• quer promessa mágica de “nunca mais ter incidente”

Honestidade final

Produção sempre vai ter falha.

A diferença é: você vai ser refém da falha… ou você vai projetar pra falhar com dignidade.

Se você quer ser o tipo de engenheiro que olha pra uma integração e enxerga — antes de quebrar — onde ela vai doer…

dá o play.