Práctica 02 · Servicios Distribuidos

    Sistemas orientados a eventos que aguantan cuando algo sale mal.

    Backbones en Kafka, microservicios con bordes claros y las prácticas operativas que los mantienen aburridos a propósito.

    Proof
    10M+
    eventos diarios procesados
    < 50ms
    p99 entre servicios
    99,95%
    disponibilidad de servicio
    El brief

    Sistemas aburridos que sobreviven a sus autores.

    Los sistemas distribuidos fallan en las costuras — los momentos entre servicios donde los retries chocan, las colas se acumulan y las suposiciones divergen. Diseñamos esas costuras primero.

    Construimos backbones orientados a eventos para operaciones B2B donde la latencia es una métrica de cara al cliente y el uptime es una métrica contractual. Cada patrón que enviamos fue endurecido en producción a escala.

    Lo que te llevás

    Entregables y la postura operativa que compran.

    Entregables tangibles
    • Arquitectura de servicios con bordes y contratos documentados
    • Esquemas de evento con estrategia de versionado
    • Patrones de resiliencia (circuit breaker, retry, bulkhead)
    • Tracing distribuido y logs estructurados en la malla
    • Suite de chaos test y runbooks para los modos de falla principales
    • Rotación de on-call, SLOs y ruteo de alerta
    Qué cambia en operación
    < 5min

    tiempo mediano para identificar qué servicio está degradado

    0

    eventos perdidos en caída de consumer — DLQ + replay en todos lados

    p99 < 50ms

    latencia entre servicios en régimen

    Semanal

    cadencia de chaos drill — los modos de falla se ensayan

    Capacidades

    Qué construimos en el stack.

    Hacé clic en una capacidad para ver cómo la abordamos.

    Cómo la abordamos

    Arquitectura orientada a eventos

    Streaming en Kafka con schema registry, consumer groups y dead-letter queues.

    • Diseño schema-first con reglas de versionado y compatibilidad
    • Consumer groups dimensionados a las particiones, con tooling de replay
    • Patrones de DLQ para poison messages con UI de operador
    • Outbox pattern para emisión transaccional de eventos
    Cómo la abordamos

    Diseño de microservicios

    Bordes dibujados alrededor de capacidades de negocio — deploys independientes, contratos claros, sin DB compartida.

    • Bordes derivados de análisis de dominio, no del organigrama
    • Versionado de API con política de deprecación
    • Pipelines de deploy independientes con gates de retrocompatibilidad
    • Ownership estricto — sin escritura compartida entre servicios
    Cómo la abordamos

    Tolerancia a fallas

    Circuit breakers, backoff exponencial, bulkheads y timeouts presupuestados — resiliencia embebida, no atornillada.

    • Circuit breakers con recuperación half-open
    • Presupuesto de timeout por dependencia y pools bulkhead
    • Handlers idempotentes y semántica at-least-once
    • Caminos de degradación graciosa definidos por servicio
    Cómo la abordamos

    Observabilidad

    Tracing distribuido, logs estructurados y métricas que permiten identificar problemas en la malla.

    • Traces OpenTelemetry con propagación de baggage consistente
    • Logging estructurado con IDs de correlación
    • Dashboards de golden signals por servicio (latencia, tráfico, error, saturación)
    • Alertas basadas en SLO atadas a error budget
    Workflow

    Del mapeo de dominio al lanzamiento probado con chaos.

    Cinco etapas dimensionadas a la complejidad de tu dominio, nunca a un template fijo.

    1. Semana 1–2 · Dominio

      Event mapping & descubrimiento de bordes

      Workshops de event-storming con tus domain experts para sacar a la luz los eventos, comandos y agregados que deben guiar los bordes de servicio.

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

      Contratos de servicio & esquemas de evento

      Diseño schema-first de los contratos entre servicios, política de versionado de eventos y topología de productores, consumidores y DLQs.

      DeliverableSchema registry + documentación de contratos
    3. Semana 4–8 · Implementación

      Patrones de resiliencia en cada handler

      Circuit breakers, handlers idempotentes, escaleras de retry y bulkheads — aplicados por dependencia, no como wrapper global.

      DeliverableServicios endurecidos + mapa de dependencias
    4. Semana 6–10 · Observabilidad

      Tracing, SLOs y dashboards de golden signals

      Traces OpenTelemetry end-to-end, logs estructurados con correlación, alertas basadas en SLO y dashboards por servicio.

      DeliverableStack de observabilidad + definición de SLOs
    5. Semana 10–12 · Readiness

      Chaos drills & captura de runbooks

      Rompemos cosas a propósito en staging — y a veces en producción — para validar que tus runbooks, alertas y rotaciones funcionen como esperás.

      DeliverableSuite de chaos + runbooks + on-call listo
    Arquitectura

    Cómo un evento atraviesa la malla.

    Los productores emiten vía outbox; los consumidores procesan at-least-once con reruteo a DLQ ante falla.

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

    Productor → tópico Kafka → consumer group (con DLQ) → servicios downstream → tejido de observabilidad.

    Tecnología

    Herramientas que elegimos primero.

    Defaults — no dogmas. Elegimos la herramienta más chica que sobrevive al próximo año de volumen.

    Runtimes principales
    • Go
    • Node.js / TypeScript
    • Python
    • Java
    Streaming
    • Apache Kafka
    • RabbitMQ
    • Redis Streams
    • NATS
    Service mesh
    • Istio
    • Linkerd
    • Envoy
    Observabilidad
    • OpenTelemetry
    • Jaeger
    • Prometheus
    • Grafana
    • Loki
    Plataforma
    • Kubernetes
    • AWS
    • GCP
    Cómo trabajamos

    Tres formatos, un compromiso con ownership.

    Elegí el formato que entre en tu equipo — todos terminan con tu equipo cargando el pager.

    Modelo de engagement

    Build con alcance fijo · Sprint de rescate · Retainer

    Un build de arquitectura greenfield, un sprint para estabilizar un sistema en problemas, o un retainer para trabajo continuo de plataforma — como equipo externo.

    Timeline típico

    10–14 semanas hasta el primer corte

    Del event-storming a una malla en producción atendiendo tráfico real con observabilidad completa.

    Propiedad

    100% tuyo, siempre

    Arquitectura, código fuente, propiedad intelectual y runbooks se transfieren a ti. Sin lock-in, y sin personas que gestionar.

    FAQ

    Preguntas que escuchamos antes del kickoff.

    Si la tuya no está, preguntala directo.

    Iniciar un proyecto distribuido

    ¿Necesitás sistemas que aguanten el mundo real?

    Contanos el throughput, el SLO de latencia y las integraciones. Volvemos con una forma y un timeline.