Visão Geral

Curso Kafka Using Spring Boot.  Este curso prático é projetado para desenvolvedores Java, arquitetos de software e engenheiros de backend que desejam construir aplicações escaláveis e resilientes orientadas a eventos utilizando o Apache Kafka em conjunto com o Spring Boot. Do ponto de vista técnico, você aprenderá a configurar projetos Spring Boot para interagir com Kafka, implementando produtores e consumidores de mensagens de forma eficiente e robusta. Cobriremos tópicos essenciais como a configuração de KafkaTemplate para envio de mensagens, o uso da anotação @KafkaListener para consumo, tratamento de diferentes formatos de serialização/deserialização (incluindo JSON e Avro com Schema Registry), estratégias de tratamento de erros, transações e testes. O curso terá um forte foco em exemplos de código e laboratórios práticos, capacitando os participantes a desenvolver microsserviços e sistemas de processamento de dados em tempo real.

Curso Kafka Using Spring Boot, a habilidade de integrar Apache Kafka com Spring Boot é um diferencial enorme para empresas que buscam construir arquiteturas de microsserviços e sistemas orientados a eventos. Isso permite desenvolver aplicações mais rapidamente, reduzir a complexidade de integração, garantir alta disponibilidade e escalabilidade, e otimizar a comunicação entre serviços. Ao dominar essa combinação, as organizações podem acelerar a entrega de funcionalidades, melhorar a resiliência de seus sistemas e inovar em soluções de dados em tempo real. Profissionais com essa expertise são altamente valorizados no mercado, impulsionando a eficiência e a competitividade tecnológica.

Objetivo

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

• Configurar um projeto Spring Boot para integrar-se ao Apache Kafka.
• Implementar Produtores Kafka usando KafkaTemplate para enviar mensagens string, JSON e objetos customizados.
• Desenvolver Consumidores Kafka eficientes com a anotação @KafkaListener, gerenciando grupos de consumo e concorrência.
• Configurar serializadores e deserializadores customizados, incluindo a integração com Schema Registry (Avro).
• Implementar estratégias robustas de tratamento de erros para produtores e consumidores Kafka no Spring Boot.
• Compreender e aplicar transações Kafka para garantir semânticas "Exactly-once" em cenários específicos.
• Realizar testes unitários e de integração para aplicações Kafka com Spring Boot.
• Aplicar boas práticas de desenvolvimento para construir aplicações Kafka resilientes e performáticas.

Publico Alvo

• Desenvolvedores Java: Que querem construir aplicações que interagem com Kafka.
• Arquitetos de Software: Para entender como o Spring Boot simplifica a implementação de sistemas Kafka.
• Engenheiros de Backend: Que trabalham ou desejam trabalhar com microsserviços e arquiteturas orientadas a eventos.
• Engenheiros de Dados: Que desenvolvem ingestão ou transformação de dados em tempo real com Java.

Pre-Requisitos

• Conhecimento sólido de programação Java (experiência com Java 11+ é preferencial).
• Conhecimento intermediário de Spring Boot (criação de aplicações REST, injeção de dependência, anotações básicas).
• Noções básicas dos conceitos do Apache Kafka (Tópicos, Partições, Produtores, Consumidores, Offsets, Consumer Groups – idealmente, ter cursado "Apache Kafka: Conceitos Chave" ou equivalente).
• Familiaridade com Maven ou Gradle para gerenciamento de dependências.
• Noções de Git.

Materiais

Conteúdo Programatico

Módulo 1: Fundamentos e Configuração do Ambiente (3 horas)

• 1.1. Introdução ao Spring Boot e Kafka:
  • Por que usar Spring Boot com Kafka? Benefícios da auto-configuração e abstrações.
  • Arquitetura de uma aplicação Spring Boot Kafka.
• 1.2. Configuração do Ambiente de Desenvolvimento:
  • Iniciando um projeto Spring Boot com dependências Kafka via Spring Initializr.
  • Configurando um ambiente Kafka local com Docker Compose (Kafka, ZooKeeper, Kafka UI/Control Center).
  • Configurações básicas do Kafka no application.yml (bootstrap servers).
• 1.3. Conceitos Essenciais do Spring for Apache Kafka:
  • KafkaTemplate: a interface principal para envio de mensagens.
  • @KafkaListener: a anotação para criar consumidores.
  • Auto-configuração de fábrica de produtores e consumidores.
• Prática: Criar um novo projeto Spring Boot. Configurar o Docker Compose para subir um cluster Kafka local. Configurar o application.yml para conexão inicial e testar a conexão.

Módulo 2: Implementando Produtores Kafka com Spring Boot (5 horas)

• 2.1. Enviando Mensagens Simples:
  • Utilizando KafkaTemplate<String, String> para enviar mensagens string.
  • Métodos send(): assíncronos e callbacks (ListenableFuture).
  • Tratamento de resultados (SuccessCallback, FailureCallback).
• 2.2. Enviando Objetos Java como JSON:
  • Configuração do JsonSerializer e JsonDeserializer.
  • Serialização automática de objetos POJO (Plain Old Java Object) para JSON.
  • Produzindo e consumindo JSON (ex: um objeto Order, User).
• 2.3. Estratégias de Tratamento de Erros para Produtores:
  • Configurações de retransmissão (retries, retry.backoff.ms).
  • Tratamento de exceções em callbacks de envio.
  • Estratégias de "backoff" e "circuit breaker" (conceitual).
• Prática: Implementar um serviço REST que recebe requisições e publica mensagens string e JSON em tópicos Kafka. Tratar os resultados de envio assíncronos.

Módulo 3: Implementando Consumidores Kafka com Spring Boot (5 horas)

• 3.1. Consumindo Mensagens com @KafkaListener:
  • Configuração básica de um KafkaListener.
  • Parâmetros da anotação (topics, groupId, concurrency).
  • Consumindo mensagens string e JSON.
• 3.2. Gerenciamento de Offsets e Modos de Commit:
  • Autocommit (enable.auto.commit).
  • Commit manual (ContainerAwareErrorHandler, AcknowledgingMessageListener).
  • Quando usar commit manual (AckMode).
• 3.3. Concorrência e Consumer Groups:
  • Como o Spring Boot gerencia múltiplas threads de consumidor.
  • Impacto da concorrência no rebalanceamento do consumer group.
  • Sintonizando o número de threads e o número de partições.
• Prática: Implementar múltiplos @KafkaListener para consumir mensagens dos tópicos criados. Configurar diferentes groupIds e concurrency. Experimentar com commit manual de offsets.

Módulo 4: Serialização Avançada, Schema Registry e Tratamento de Erros (4 horas)

• 4.1. Introdução ao Avro e Schema Registry:
  • Por que usar Avro (compatibilidade de esquema, eficiência).
  • O papel do Confluent Schema Registry.
  • Configurando serializadores/deserializadores Avro no Spring Boot Kafka.
• 4.2. Integração com Schema Registry:
  • Dependências Maven/Gradle para Avro e Schema Registry.
  • Gerando classes Avro a partir de schemas .avsc.
  • Exemplo prático de produção e consumo de mensagens Avro.
• 4.3. Estratégias Avançadas de Tratamento de Erros no Consumidor:
  • DefaultErrorHandler e Dead Letter Topic (DLT).
  • Customizando a estratégia de erro (retries, logging, DLT).
  • SeekToCurrentErrorHandler para reprocessamento.
  • Processamento idempotente para lidar com re-entregas.
• Prática: Integrar o projeto com o Confluent Schema Registry (pode ser via Docker). Criar um schema Avro, gerar as classes Java, e implementar produtores e consumidores de mensagens Avro. Configurar um DefaultErrorHandler com DLT.

Módulo 5: Transações, Testes e Boas Práticas (3 horas)

• 5.1. Transações Kafka com Spring Boot:
  • Entendendo a semântica "Exactly-once" com transações.
  • Configuração de produtores transacionais.
  • Usando @Transactional e KafkaTemplate em um contexto transacional.
  • Considerações de desempenho e trade-offs.
• 5.2. Testando Aplicações Kafka com Spring Boot:
  • Testes unitários de produtores e consumidores.
  • Testes de integração com spring-kafka-test (EmbeddedKafka).
  • Teste de fluxos ponta a ponta.
• 5.3. Monitoramento e Boas Práticas:
  • Métricas de produtores e consumidores (JMX, Micrometer).
  • Configurações importantes para performance e resiliência (batch.size, linger.ms, fetch.min.bytes).
  • Design de tópicos e chaves.
  • Logging e observabilidade.
  • Segurança (SSL/TLS, SASL - conceitual).
• Prática: Implementar um cenário transacional simples. Escrever testes de integração para um produtor e consumidor usando EmbeddedKafka.