Conteúdo

Pensar em comunicação assíncrona entre microsserviços é um caminho interessante quando a aplicação demanda serviços que podem demorar para responder. Para evitar problemas de timeouts e retentativas, utilizam-se filas ou tópicos, aos quais um processo adiciona uma mensagem informando o processamento a ser feito e outro a recebe quando estiver disponível e executa. O Kafka é atualmente um dos principais sistemas para a implementação de processamento assíncrono. Além de disponibilizar os tópicos para a produção e consumo de mensagens, suas diversas funcionalidades facilitam a implementação de nossas aplicações, com a distribuição e o balanceamento de carga entre os consumidores e o processamento de fluxos de dados.

Neste livro, Eduardo Zambom Santana mostra a utilização do Kafka para fazer a comunicação assíncrona entre microsserviços implementados com o Spring Boot. Por meio de uma aplicação completa, você passará pela criação dos tópicos e a produção e consumo de mensagens, até chegar a partes mais complexas do Kafka, como a utilização de grupos de consumidores, o mecanismo de retentativas, testes unitário de código e o processamento de fluxo de dados com Kafka Streams.

Saiba o que você vai aprender

Sumário

• 1 Introdução
• 1.1 Apache Kafka
• 1.2 Spring Boot
• 1.3 Python
• 1.4 Outras ferramentas

• 2 Instalando o Kafka
• 2.1 Tópicos
• 2.2 Enviando e recebendo mensagens para o Kafka
• 2.3 Consumer Groups
• 2.4 Parando o Kafka

• 3 Criando uma API REST Spring Boot
• 3.1 Configuração do projeto
• 3.2 Banco de dados e Spring Boot
• 3.3 Modelo e repositório
• 3.4 DTOs e Controller
• 3.5 Executando a aplicação

• 4 Produzindo mensagens
• 4.1 Configuração
• 4.2 Implementando o produtor
• 4.3 Enviando os objetos para o tópico
• 4.4 Verificando o tópico do Kafka

• 5 Consumidor
• 5.1 Configuração e banco de dados
• 5.2 Implementando o consumidor
• 5.3 Execução da aplicação

• 6 Finalizando a shop-api
• 6.1 Execução da aplicação

• 7 Diferentes grupos de consumidores
• 7.1 Consumer Groups
• 7.2 Implementando a nova aplicação
• 7.3 Implementando o consumidor
• 7.4 Implementando a rota REST
• 7.5 Testando a aplicação

• 8 Paralelizando tarefas
• 8.1 Partições
• 8.2 Recriando o tópico
• 8.3 Executando a aplicação com mais de um consumidor

• 9 Usando chaves nas mensagens
• 9.1 Adicionando chaves nas mensagens
• 9.2 Recebendo as chaves nas mensagens
• 9.3 Executando a aplicação

• 10 Retentativas
• 10.1 Configuração da aplicação
• 10.2 Implementando o consumidor
• 10.3 Melhorando as retentativas

• 11 Administrando o Kafka no Java
• 11.1 Configuração da aplicação
• 11.2 Administrando o Kafka

• 12 Conectando no Kafka com o Python
• 12.1 Configurando a aplicação
• 12.2 Implementando o cliente do Kafka
• 12.3 Inicializando o consumidor
• 12.4 Implementando uma rota com o Flask
• 12.5 Executando a aplicação

• 13 Configurações do Kafka
• 13.1 Configurações gerais
• 13.2 Configurações do consumidor
• 13.3 Configurações do produtor

• 14 Executando todas as aplicações com o Docker
• 14.1 Mudanças nas aplicações
• 14.2 Criando os contêineres
• 14.3 docker-compose

• 15 Testes de unidade
• 15.1 Configurando as aplicações
• 15.2 Testes na shop-api
• 15.3 Testes na shop-validator
• 15.4 Testes na shop-report
• 15.5 Testes na shop-retry

• 16 Kafka Streams
• 16.1 Configuração da aplicação
• 16.2 Processamento de fluxos
• 16.3 Enviando resultados para outros tópicos
• 16.4 Janelas de tempo
• 16.5 Conclusão