Prática 02 · Serviços Distribuídos

    Sistemas orientados a eventos que ficam de pé quando algo dá errado.

    Backbones em Kafka, microsserviços com fronteiras claras e as práticas operacionais que os mantêm entediantes, de propósito.

    Proof
    10M+
    eventos diários processados
    < 50ms
    p99 entre serviços
    99,95%
    disponibilidade de serviço
    O briefing

    Sistemas entediantes que sobrevivem aos seus autores.

    Sistemas distribuídos falham nas costuras — nos momentos entre serviços onde retries colidem, filas acumulam e premissas divergem. Desenhamos essas costuras primeiro.

    Construímos backbones orientados a eventos para operações B2B onde latência é métrica de cara para o cliente e uptime é métrica contratual. Cada padrão que entregamos foi endurecido em produção em escala.

    O que você leva

    Entregáveis e a postura operacional que eles compram.

    Entregáveis tangíveis
    • Arquitetura de serviços com fronteiras e contratos documentados
    • Schemas de evento com estratégia de versionamento
    • Padrões de resiliência (circuit breaker, retry, bulkhead)
    • Tracing distribuído e logs estruturados na malha
    • Suíte de chaos test e runbooks para os principais modos de falha
    • Rotação de on-call, SLOs e roteamento de alerta
    O que muda na operação
    < 5min

    tempo mediano para identificar qual serviço está degradado

    0

    eventos perdidos em queda de consumer — DLQ + replay em todo lugar

    p99 < 50ms

    latência entre serviços em regime

    Semanal

    ensaio de chaos — modos de falha são treinados

    Capacidades

    O que construímos no stack.

    Clique em uma capacidade para ver como abordamos.

    Como abordamos

    Arquitetura orientada a eventos

    Streaming em Kafka com schema registry, consumer groups e dead-letter queues.

    • Schema-first com regras de versionamento e compatibilidade
    • Consumer groups dimensionados às partições, com ferramentas de replay
    • Padrões de DLQ para poison messages com UI de operador
    • Outbox pattern para emissão transacional de eventos
    Como abordamos

    Design de microsserviços

    Fronteiras desenhadas em torno de capacidades de negócio — deploys independentes, contratos claros, sem banco compartilhado.

    • Fronteiras derivadas de análise de domínio, não do organograma
    • Versionamento de API com política de depreciação
    • Pipelines de deploy independentes com gates de retrocompatibilidade
    • Ownership estrito — sem escrita compartilhada entre serviços
    Como abordamos

    Tolerância a falhas

    Circuit breakers, backoff exponencial, bulkheads e timeouts orçados — resiliência embutida, não colada depois.

    • Circuit breakers com recuperação half-open
    • Orçamento de timeout por dependência e pools bulkhead
    • Handlers idempotentes e semântica at-least-once
    • Caminhos de degradação graciosa definidos por serviço
    Como abordamos

    Observabilidade

    Tracing distribuído, logs estruturados e métricas que permitem identificar problemas na malha.

    • Traces OpenTelemetry com propagação de baggage consistente
    • Logging estruturado com IDs de correlação
    • Dashboards de golden signals por serviço (latência, tráfego, erro, saturação)
    • Alertas baseados em SLO atrelados a error budget
    Workflow

    Do mapeamento de domínio ao lançamento testado em chaos.

    Cinco etapas dimensionadas à complexidade do seu domínio, nunca a um template fixo.

    1. Semana 1–2 · Domínio

      Event mapping & descoberta de fronteiras

      Workshops de event-storming com seus domain experts para revelar eventos, comandos e agregados que devem guiar as fronteiras de serviço.

      DeliverableMapa de eventos + diagrama de bounded contexts
    2. Semana 2–4 · Arquitetura

      Contratos de serviço & schemas de evento

      Design schema-first dos contratos entre serviços, política de versionamento de eventos e topologia de produtores, consumidores e DLQs.

      DeliverableSchema registry + documentação de contratos
    3. Semana 4–8 · Implementação

      Padrões de resiliência em cada handler

      Circuit breakers, handlers idempotentes, escalas de retry e bulkheads — aplicados por dependência, não como wrapper global.

      DeliverableServiços endurecidos + mapa de dependências
    4. Semana 6–10 · Observabilidade

      Tracing, SLOs e dashboards de golden signals

      Traces OpenTelemetry ponta-a-ponta, logs estruturados com correlação, alertas baseados em SLO e dashboards por serviço.

      DeliverableStack de observabilidade + definição de SLOs
    5. Semana 10–12 · Prontidão

      Ensaios de chaos & captura de runbooks

      Quebramos coisas em staging — e às vezes em produção — para validar que runbooks, alertas e rotações funcionam como você espera.

      DeliverableSuíte de chaos + runbooks + on-call pronto
    Arquitetura

    Como um evento atravessa a malha.

    Produtores emitem via outbox; consumidores processam at-least-once com reroteamento por DLQ em caso de falha.

    SOURCEProducer + outboxLOGKafka topicpartitions · retentionCONSUMER AIdempotent handlerCONSUMER BCircuit breaker · retryCONSUMER CBulkhead poolDLQDead-letter · replay toolingDOWNSTREAMServices + APIsIndependent deploysVersioned contractsSLO-based alertingOTel + Jaeger

    Produtor → tópico Kafka → consumer group (com DLQ) → serviços downstream → tecido de observabilidade.

    Tecnologia

    Ferramentas que escolhemos primeiro.

    Defaults — não dogmas. Escolhemos a menor ferramenta que sobrevive ao próximo ano de volume.

    Runtimes principais
    • Go
    • Node.js / TypeScript
    • Python
    • Java
    Streaming
    • Apache Kafka
    • RabbitMQ
    • Redis Streams
    • NATS
    Service mesh
    • Istio
    • Linkerd
    • Envoy
    Observabilidade
    • OpenTelemetry
    • Jaeger
    • Prometheus
    • Grafana
    • Loki
    Plataforma
    • Kubernetes
    • AWS
    • GCP
    Como engajamos

    Três formatos, um compromisso com ownership.

    Escolha o formato que cabe no seu time — todos terminam com seu time carregando o pager.

    Modelo de engajamento

    Build com escopo fixo · Sprint de resgate · Retainer

    Um build de arquitetura greenfield, um sprint para estabilizar um sistema em apuros, ou um retainer para trabalho contínuo de plataforma — como time externo.

    Linha do tempo típica

    10–14 semanas até o primeiro corte

    Do event-storming a uma malha em produção atendendo tráfego real com observabilidade completa.

    Propriedade

    100% seu, sempre

    Arquitetura, código-fonte, propriedade intelectual e runbooks são transferidos a você. Sem lock-in, e sem pessoas para gerenciar.

    FAQ

    Perguntas que ouvimos antes do kickoff.

    Se a sua não estiver aqui, pergunte direto.

    Iniciar um projeto distribuído

    Precisa de sistemas que aguentem o mundo real?

    Conte a vazão, o SLO de latência e as integrações. Voltamos com um formato e uma linha do tempo.