Visão Geral

O curso Event-Driven Microservices with Kafka Streams ensina como projetar, desenvolver e operar microserviços orientados a eventos utilizando Apache Kafka e Kafka Streams.
Durante o treinamento, os participantes aprenderão como criar serviços independentes, capazes de se comunicar por meio de eventos, aplicar padrões arquiteturais modernos, gerenciar estado distribuído, implementar pipelines de processamento e integrar múltiplos microserviços de maneira resiliente, escalável e altamente performática.
O curso é totalmente prático, com laboratórios individuais e foco em aplicações reais.

Objetivo

Após realizar este curso Event-Driven Microservices with Kafka Streams, você será capaz de:

• Entender os princípios de Event-Driven Architecture (EDA)
• Projetar microserviços baseados em eventos
• Utilizar Kafka Streams para construir serviços com estado distribuído
• Implementar pipelines complexos com agregações, joins e windowing
• Integrar microserviços através de eventos, tópicos e schemas
• Aplicar padrões de arquitetura como event sourcing, CQRS e saga
• Implementar microserviços resilientes, escaláveis e observáveis
• Definir estratégias de versionamento e governança de eventos
• Utilizar as melhores práticas para aplicações em produção

Publico Alvo

• Engenheiros de Software
• Engenheiros de Dados
• Desenvolvedores Backend
• Arquitetos de Software
• Times que trabalham com microserviços
• Profissionais que trabalham com integração e mensageria

Pre-Requisitos

• Conhecimento básico de Apache Kafka
• Conhecimento em programação (Java recomendado)
• Noções de arquitetura de microsserviços
• Noções de Docker e containers (desejável)

Materiais

Conteúdo Programatico

1. Introduction to Event-Driven Architecture

1. What is Event-Driven Architecture
2. Benefits and challenges
3. Events, commands, state, and streams
4. Communication patterns
5. Why Kafka Streams for microservices

2. Apache Kafka Essentials (Quick Review)

1. Topics, partitions, brokers
2. Producers and consumers
3. Delivery semantics
4. Schema Registry overview
5. Designing event schemas

3. Kafka Streams Fundamentals for Microservices

1. Streams and stateful processing
2. KStream and KTable
3. Stateless operations (map, filter, flatMap)
4. Stateful operations and aggregations
5. Windowing
6. State stores and local persistence

4. Developing Event-Driven Microservices

1. Building microservices with Kafka Streams
2. Designing microservice boundaries
3. Event naming conventions
4. Key design patterns for events
5. Ensuring idempotency and exactly-once behavior

5. Service-to-Service Communication

1. Event-first communication
2. Using topics as service APIs
3. Choreography vs orchestration
4. Event versions and schema evolution
5. Backward and forward compatibility

6. Advanced Kafka Streams Concepts

1. Processor API
2. Custom processors and transformers
3. Interactive queries
4. Failover, standby replicas, and fault tolerance
5. Scaling Kafka Streams with partitions

7. Event Sourcing and CQRS

1. What is event sourcing
2. Implementing write models and read models
3. Replay and reprocessing strategies
4. Using Streams to project state
5. CQRS patterns with Kafka Streams

8. Saga Pattern and Distributed Transactions

1. Challenges of distributed transactions
2. Saga orchestration vs choreography
3. Implementing sagas with Kafka
4. Compensation and rollback logic

9. Integrating Microservices with ksqlDB (Optional Extension)

1. ksqlDB as a query layer
2. Materialized views
3. Creating aggregations for microservices
4. Bridging Streams apps with SQL-based processing

10. Observability and Monitoring

1. Monitoring Kafka Streams metrics
2. Logging and tracing
3. Distributed tracing with events
4. Monitoring lags and throughput
5. State store metrics

11. Testing Event-Driven Microservices

1. Unit testing Streams topologies
2. Using TestInputTopic and TestOutputTopic
3. Integration tests with embedded Kafka
4. Contract testing with schemas

12. Deployment and Production Considerations

1. Running Kafka Streams in containers
2. Memory and resource management
3. Horizontal scaling strategies
4. Handling version upgrades
5. Blue-green and canary deployments

13. Hands-on Labs

1. Creating an event-driven microservice
2. Implementing stateful processing with KTable
3. Creating event-sourced projections
4. Implementing sagas between two services
5. Monitoring and debugging the microservices
6. Deploying microservices using Docker

14. Best Practices for Enterprise Implementations

1. Designing stable event contracts
2. Avoiding anti-patterns
3. Ensuring fault tolerance
4. Managing data retention and compaction
5. Governance and event cataloging