Apache Kafka e Spring Boot Comunicação assíncrona entre microsserviços

Eduardo Felipe Zambom Santana

*Você terá acesso às futuras atualizações do livro.

Sobre o livro

Normalmente quando precisamos fazer a comunicação entre microsserviços, logo pensamos em utilizar a comunicação síncrona, fazendo uma chamada HTTP de um serviço para outro. Esse tipo de implementação funciona na maioria dos casos, mas pode haver funcionalidades que podem causar diversos problemas. Por exemplo, imagine que queremos chamar um serviço que pode demorar alguns segundos até alguns minutos para responder. Se utilizarmos uma implementação síncrona, essa comunicação será bastante lenta e, se a aplicação não estiver preparada para isso, pode causar vários problemas como timeouts e retentativas de chamadas, o que pode piorar a situação da aplicação.

Para esse caso, a utilização de comunicação assíncrona pode ser interessante. Nela, informamos que queremos realizar um processamento, mas não esperamos que a resposta seja enviada na hora, e sim ficamos esperando uma notificação de que o processamento foi realizado ou que alguma falha aconteceu. Uma forma bastante utilizada para essa implementação são as filas ou tópicos, na qual um processo adiciona uma mensagem na fila ou tópico informando que um processamento deve ser feito, e outro recebe essa mensagem quando estiver disponível e faz o processamento. Normalmente, o primeiro processo é conhecido como produtor, e o segundo, como consumidor. Existem diversas funcionalidades que podem ser implementadas com processamento assíncrono, por exemplo: para processamentos demorados, para a comunicação com aplicações de terceiros e para a implementação de funcionalidades que não estão no fluxo principal da aplicação.

O Kafka é atualmente um dos principais sistemas para a implementação de processamento assíncrono disponível, pois ele, além de disponibilizar os tópicos para a produção e consumo de mensagens, também tem diversas funcionalidades que facilitam bastante a implementação de nossas aplicações, como a distribuição e o balanceamento de carga entre os consumidores e o processamento de fluxos de dados.

O objetivo principal deste livro é mostrar como implementar aplicações utilizando o Kafka para fazer a comunicação assíncrona entre microsserviços implementados com o Spring Boot. Implementaremos uma aplicação completa, que vai ser incrementada capítulo a capítulo, começando pelos conceitos mais básicos como a criação dos tópicos e a produção e consumo de mensagens. Depois mostraremos a utilização das partes mais complexas do Kafka, como a utilização de grupos de consumidores para a distribuição e balanceamento de carga das mensagens, o mecanismo de retentativas quando houver falhas no processamento das mensagens e o processamento de fluxo de dados. Também apresentaremos algumas implementações interessantes como um consumidor implementado em Python, a configuração do Kafka na aplicação e a criação de testes de unidade para o código que envolve o Kafka.

Para quem é este livro?

Este livro foi escrito para pessoas programadoras que desejam entender e utilizar Kafka para a implementação da comunicação assíncrona entre microsserviços. Os exemplos de código foram implementados utilizando o Spring Boot, mas mesmo programadores de outros frameworks e outras linguagens podem utilizar o livro, já que o funcionamento do Kafka é o mesmo para qualquer linguagem de programação utilizada, mudando apenas a implementação.

Quando precisamos implementar a comunicação entre microsserviços, quase sempre já pensamos em utilizar a comunicação síncrona, mas veremos neste livro que a comunicação assíncrona pode ser bastante útil em diversos casos de uso, evitando problemas que poderiam ser causados em chamadas HTTP. Portanto, é importante que desenvolvedores e desenvolvedoras entendam como funciona a comunicação assíncrona.

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

Dados do produto

Número de páginas:
189
ISBN:
978-65-86110-98-2
Data publicação:
01/2022

Compartilhe!

Compartilhe no Facebook Compartilhe no Twitter

*Você terá acesso às futuras atualizações do livro.