Visão Geral

Curso Apache Kafka com Spring Boot Desenvolvendo Aplicações Orientadas a Eventos. Este curso prático e intensivo foi desenhado para desenvolvedores Java, arquitetos de software e engenheiros de backend que desejam dominar a integração do Apache Kafka em suas aplicações usando o poderoso framework Spring Boot. Do ponto de vista técnico, você mergulhará nos conceitos fundamentais do Kafka (produtores, consumidores, tópicos, partições, offsets) e aprenderá a construir microsserviços orientados a eventos. Cobriremos a configuração detalhada do Spring Kafka, a criação de produtores e consumidores robustos, o gerenciamento de serialização/desserialização, tratamento de erros, idempotência, transações e o uso do Kafka Streams para processamento de dados em tempo real. O curso focará em exemplos de código prático, cenários de uso comum e as melhores práticas para construir sistemas escaláveis e resilientes.

Curso Apache Kafka com Spring Boot Desenvolvendo Aplicações Orientadas a Eventos, a arquitetura orientada a eventos e o Apache Kafka são pilares da infraestrutura moderna de software, habilitando sistemas altamente escaláveis, resilientes e desacoplados. Dominar essa combinação significa que os profissionais podem construir plataformas que processam grandes volumes de dados em tempo real, melhoram a comunicação entre microsserviços e respondem rapidamente a eventos de negócio. Isso se traduz em maior agilidade no desenvolvimento, inovação mais rápida de produtos e otimização da performance de sistemas críticos. Profissionais com expertise em Kafka e Spring Boot são altamente valorizados no mercado, pois são essenciais para construir as próximas gerações de aplicações distribuídas.

Objetivo

Ao final do Curso Apache Kafka com Spring Boot Desenvolvendo Aplicações Orientadas a Eventos, você será capaz de:

• Compreender os conceitos fundamentais do Apache Kafka e seu modelo de dados.
• Configurar e integrar o Spring Kafka em projetos Spring Boot.
• Desenvolver Produtores (Producers) Kafka para enviar mensagens de forma eficiente.
• Construir Consumidores (Consumers) Kafka robustos para processar mensagens.
• Gerenciar serialização e desserialização de dados (JSON, Avro, Protobuf) no Kafka.
• Implementar estratégias de tratamento de erros, retries e Dead Letter Queues (DLQs).
• Entender e aplicar conceitos de idempotência e transações no Kafka.
• Utilizar o Kafka Streams para construir aplicações de processamento de fluxo de dados.
• Aplicar melhores práticas para performance, escalabilidade e resiliência em aplicações Kafka com Spring Boot.

Publico Alvo

• Desenvolvedores Java/Spring Boot: Que querem integrar Kafka em seus projetos.
• Arquitetos de Software: Interessados em projetar sistemas orientados a eventos com Kafka.
• Engenheiros de Backend: Buscando aprimorar suas habilidades em mensageria e processamento de dados em tempo real.

Pre-Requisitos

• Conhecimento sólido de Java e Spring Boot: Entendimento de injeção de dependências, componentes Spring, REST APIs.
• Noções básicas de Maven ou Gradle.
• Familiaridade com a linha de comando (terminal).
• (Desejável) Noções básicas de sistemas distribuídos.

Materiais

Conteúdo Programatico

Módulo 1: Fundamentos do Apache Kafka (3 horas)

• 1.1. Introdução à Arquitetura Orientada a Eventos:
  • Eventos vs. Mensagens (Queues).
  • Desacoplamento e escalabilidade.
• 1.2. O que é Apache Kafka?
  • Conceitos principais: Tópicos, Partições, Offsets.
  • Produtores, Consumidores, Brokers.
  • Log de Commit Distribuído e durabilidade.
• 1.3. Componentes do Ecossistema Kafka:
  • Zookeeper (visão de alto nível).
  • Kafka Connect, Kafka Streams (introdução).
• 1.4. Configuração e Execução Local do Kafka:
  • Hands-on: Rodando Kafka e Zookeeper via Docker Compose.
  • Hands-on: Criação de tópicos e comandos básicos do CLI do Kafka.
• Prática: Montar o ambiente Kafka local. Criar tópicos.

Módulo 2: Configurando o Spring Boot para Kafka (4 horas)

• 2.1. Adicionando Dependências Spring Kafka:
  • Maven e Gradle.
  • Spring Initializr.
• 2.2. Configuração do Produtor Kafka no Spring Boot:
  • application.properties/application.yml para produtores.
  • KafkaTemplate: A abstração principal para envio de mensagens.
• 2.3. Configuração do Consumidor Kafka no Spring Boot:
  • application.properties/application.yml para consumidores.
  • Listener Containers e ConcurrentKafkaListenerContainerFactory.
• 2.4. Serialização e Desserialização (Serdes):
  • Serializadores e Desserializadores padrão (String, Long, Integer).
  • Serialização JSON com JsonSerializer/JsonDeserializer e Jackson.
  • Hands-on: Configurar Serdes para diferentes tipos de dados.
• Prática: Criar um projeto Spring Boot. Configurar produtores e consumidores. Enviar e receber mensagens String e JSON.

Módulo 3: Desenvolvendo Produtores Kafka Robustos (4 horas)

• 3.1. Enviando Mensagens com KafkaTemplate:
  • Envio síncrono vs. assíncrono.
  • Obtendo o resultado do envio (ListenableFuture).
• 3.2. Chaves de Mensagem (Message Keys):
  • Importância das chaves para ordenação e particionamento.
  • Particionamento customizado.
• 3.3. Headers de Mensagem:
  • Adicionando metadados às mensagens.
• 3.4. Tratamento de Erros no Produtor:
  • Retries e delivery.timeout.ms.
  • Callbacks de sucesso e falha.
• 3.5. Idempotência do Produtor:
  • Garantindo "Exactly-Once" para o produtor.
  • enable.idempotence.
• Prática: Implementar um produtor com chaves e headers. Configurar delivery.timeout.ms e callbacks para tratamento de erros. Ativar idempotência.

Módulo 4: Desenvolvendo Consumidores Kafka Resilientes (4 horas)

• 4.1. Criando Listeners de Mensagens:
  • @KafkaListener: Anotação para criar consumidores simples.
  • Grupos de Consumidores e Partições.
  • @Headers, ConsumerRecord, Acknowledgment.
• 4.2. Gerenciamento de Offsets:
  • Estratégias de Commit de Offset (auto.offset.commit, manual).
  • AckMode: Gerenciando confirmações de processamento.
• 4.3. Tratamento de Erros no Consumidor:
  • Log de erros, retries automáticos (Spring Retry).
  • ErrorHandlingKafkaTemplate e ContainerStoppingErrorHandler.
  • Dead Letter Queues (DLQs): Encaminhando mensagens falhas para um tópico separado.
• 4.4. Concorrência e Escalonamento de Consumidores:
  • concurrency no @KafkaListener.
  • Escalonamento horizontal de consumidores.
• Prática: Implementar consumidores com commit manual de offset. Configurar um mecanismo de DLQ para mensagens que falham no processamento. Testar concorrência.

Módulo 5: Tópicos Avançados e Kafka Streams (5 horas)

• 5.1. Transações com Kafka e Spring Boot:
  • KafkaTransactionManager e @Transactional.
  • Garantindo atomicidade em operações de produtor-consumidor.
• 5.2. Testes com Spring Kafka:
  • KafkaTestUtils, @EmbeddedKafka.
  • Escrevendo testes de integração para produtores e consumidores.
• 5.3. Introdução ao Kafka Streams:
  • O que é Kafka Streams e por que usá-lo.
  • Conceitos de KStream, KTable, GlobalKTable.
  • Topologia de processamento.
• 5.4. Construindo Aplicações Kafka Streams com Spring Boot:
  • Configurando o Spring Cloud Stream (para simplificar Streams).
  • Transformações básicas: filter, map, groupByKey, aggregate.
  • Janelas de tempo (Windowing).
• 5.5. Monitoramento e Métricas:
  • Métricas JMX do Kafka.
  • Integração com Spring Boot Actuator e Prometheus/Grafana.
• Prática: Implementar uma transação básica. Escrever um teste de integração para um produtor/consumidor. Desenvolver uma aplicação simples de Kafka Streams para agregar dados.