Visão Geral

O curso Event Sourcing with Kafka apresenta de forma prática como implementar arquiteturas baseadas em event sourcing utilizando o Apache Kafka como event log distribuído.
Os participantes aprenderão a modelar eventos, projetar estados derivados (projections/read models), reprocessar eventos, implementar consistência eventual, lidar com versionamento de eventos, utilizar Kafka Streams/ksqlDB como mecanismo de projeção e aplicar padrões de mercado como CQRS e Saga.
O curso é altamente prático, com laboratórios individuais e foco em aplicações de produção.

Objetivo

Após realizar este Curso Event Sourcing with Kafka, você será capaz de:

• Entender profundamente o padrão event sourcing
• Modelar eventos imutáveis e consistentes
• Implementar write models e read models usando Kafka
• Criar projeções utilizando Kafka Streams ou ksqlDB
• Reprocessar eventos e reconstruir estados
• Projetar serviços event-sourced com CQRS
• Lidar com versionamento, contratualização e evolução de eventos
• Definir estratégias de governança de eventos
• Aplicar princípios de resiliência e escalabilidade em arquiteturas orientadas a eventos

Publico Alvo

• Desenvolvedores Backend
• Engenheiros de Software
• Engenheiros de Dados
• Arquitetos de Software
• Profissionais que trabalham com microserviços
• Times que utilizam Kafka para integrações ou pipelines distribuídos

Pre-Requisitos

• Conhecimento básico de Apache Kafka
• Noções de programação (Java, Go, Node ou outro backend)
• Conhecimento de arquitetura de software
• Noções de SQL (para parte do ksqlDB, opcional)

Materiais

Conteúdo Programatico

1. Introduction to Event Sourcing

1. What is event sourcing?
2. Events vs snapshots vs state
3. Command → Event → State changes
4. Advantages and challenges
5. Event sourcing vs message passing vs log-based systems

2. Apache Kafka as an Event Store

1. Why Kafka fits event sourcing
2. Topics, partitions, retention, compaction
3. Kafka as a distributed, immutable event log
4. Understanding event ordering and partition keys

3. Event Modeling

1. Defining domain events
2. Idempotency
3. Event naming conventions
4. Designing event schemas
5. Using Schema Registry
6. Backward and forward compatibility

4. Implementing Write Models

1. Command handling
2. Validations and business logic
3. Producing domain events to Kafka
4. Ensuring atomic event writes
5. Transactional outbox pattern vs direct event sourcing

5. Implementing Read Models (Projections)

1. What are projections?
2. When and why to use read models
3. Projection consistency
4. Materialized views
5. Rebuilding projections from scratch

6. Projections with Kafka Streams

1. KStream/KTable for projections
2. Aggregations and transformations
3. Windowed and session-based projections
4. Local state stores and recovery
5. Interactive queries to expose read models

7. Projections with ksqlDB (Optional)

1. Creating streams and tables
2. Aggregations using SQL
3. Creating materialized views
4. Exposing read-side APIs

8. Reprocessing and Replaying Events

1. Replaying entire event histories
2. Resetting consumer groups
3. Strategies for rebuilding read models
4. Handling large event histories

9. Data Storage and Snapshots

1. When to snapshot
2. Hybrid event sourcing (events + snapshots)
3. Storing snapshots outside Kafka
4. Reconciliation strategies

10. CQRS with Kafka

1. Separation of command and query responsibilities
2. CQRS patterns
3. CQRS without event sourcing
4. CQRS combined with event sourcing

11. Distributed Transactions and Sagas

1. Why distributed transactions are avoided
2. Saga orchestration vs choreography
3. Event-driven sagas in Kafka
4. Compensating actions and rollback events

12. Governance, Security, and Versioning

1. Event catalogs
2. Event versioning strategies
3. Event deprecation policies
4. Security and data privacy considerations
5. GDPR considerations (immutability vs right to delete)

13. Observability and Monitoring

1. Monitoring Kafka consumer lag
2. Monitoring projection services
3. Tracking failed events
4. Schema validation and error handling
5. DLQ strategies

14. Hands-on Labs

1. Creating an event-sourced domain model
2. Producing commands and generating events
3. Building projections with Kafka Streams
4. Rebuilding a read model from historical events
5. Creating a saga that spans multiple services
6. Implementing snapshots
7. Monitoring and debugging an event-sourced system

15. Best Practices

1. Choosing partition keys for event streams
2. Avoiding anti-patterns in event sourcing
3. Designing maintainable event schemas
4. Ensuring replay safety
5. Production considerations