Visão Geral

O Curso Kafka for Microservices Architecture ensina como utilizar Apache Kafka como backbone para arquiteturas de microserviços baseadas em eventos, permitindo que aplicações distribuídas se comuniquem de forma assíncrona, escalável e resiliente.
Durante o treinamento, os participantes aprenderão a projetar pipelines de eventos, integrar serviços com Kafka, implementar event-driven patterns e gerenciar mensageria, streams e resiliência.
O curso combina teoria, laboratórios e projetos práticos, preparando os alunos para construir arquiteturas de microserviços robustas com Kafka.

Objetivo

Ao concluir o curso Kafka for Microservices Architecture, o participante será capaz de:

• Projetar arquiteturas de microserviços baseadas em eventos com Kafka.
• Implementar producers, consumers e stream processors em microserviços.
• Aplicar event-driven patterns, como CQRS, Event Sourcing e Saga.
• Gerenciar tópicos, partições e replicação para garantir escalabilidade e resiliência.
• Monitorar e depurar pipelines Kafka em arquiteturas distribuídas.
• Integrar Kafka com Docker, Kubernetes e sistemas externos.

Publico Alvo

• Arquitetos de software que projetam sistemas distribuídos baseados em eventos.
• Desenvolvedores de microserviços que desejam integrar Kafka a suas aplicações.
• Engenheiros de dados que trabalham com pipelines event-driven.
• Profissionais DevOps e SREs que suportam ambientes de microserviços escaláveis.

Pre-Requisitos

• Conhecimento básico de Apache Kafka (producers, consumers, topics).
• Experiência com desenvolvimento de microserviços (Java, Spring Boot, Python ou Node.js).
• Familiaridade com Docker, Kubernetes e conceitos de event-driven architecture.
• Noções de mensageria e integração de sistemas distribuídos.

Informações Gerais

Metodologia:

• Curso ao vivo e online, via Microsoft Teams.
• Ministrado por instrutor especialista em Kafka e microservices.
• Aulas com exemplos práticos, laboratórios e projeto final.
• Ambiente individual para cada participante com Kafka, Docker e Kubernetes.
• Projeto final de microservices pipeline completo e escalável.
• Fornecimento de material digital, scripts e templates de configuração.

Materiais

Conteúdo Programatico

Module 1: Introduction to Microservices and Kafka

1. Overview of microservices architecture
2. Role of Kafka in event-driven microservices
3. Key concepts: producers, consumers, topics, and streams
4. Benefits and challenges of event-driven microservices

Module 2: Event-Driven Patterns

1. Pub-Sub, Event Sourcing, and CQRS patterns
2. Saga orchestration and choreography
3. Handling consistency and eventual consistency
4. Designing resilient event flows

Module 3: Kafka Integration with Microservices

1. Implementing producers and consumers in microservices
2. Topic partitioning and message keys for scalability
3. Serialization and schema management (Avro, JSON, Protobuf)
4. Error handling, retries, and dead-letter queues

Module 4: Stream Processing and State Management

1. Introduction to Kafka Streams and ksqlDB
2. Stateless vs stateful processing
3. Aggregations, joins, and windowed operations
4. Maintaining application state and fault tolerance

Module 5: Security and Governance

1. Securing communication with SSL/TLS and SASL
2. Access control and authorization for microservices
3. Schema Registry governance and schema evolution
4. Best practices for multi-service data governance

Module 6: Deployment and Scalability

1. Containerizing microservices with Docker
2. Deploying Kafka-enabled microservices in Kubernetes
3. Scaling producers and consumers horizontally
4. Monitoring pipelines and resource optimization

Module 7: Monitoring, Logging, and Troubleshooting

1. Metrics collection and dashboards (Prometheus, Grafana)
2. Tracing events across services
3. Troubleshooting common issues in microservices Kafka pipelines
4. Implementing observability and alerting

Module 8: Hands-On Project

Project: Design and implement a microservices architecture using Kafka, including multiple producers and consumers, event-driven patterns, stream processing, and deployment in Docker/Kubernetes.