Java + Kafka, Como essa parceria fucniona ?

 

 

O que é kafka e como ele funciona ?

Para entender a parceria entre Java e Kafka, primeiro precisamos compreender o que é o Apache Kafka e como ele opera, o Kafka é uma plataforma distribuída de streaming de eventos baseada no modelo PUB/SUB , o que significa que ele publica e consome mensagens de forma assíncrona. Seu funcionamento se baseia em tópicos, que atuam como canais de comunicação onde as mensagens são organizadas e distribuídas para os consumidores.

 

Agora que entendemos oque é o kafka vamos entender o ponto principal os tópicos, cada tópico no Kafka é responsável por armazenar mensagens e distribuí-las para os consumidores que estão interessados nesse conteúdo. Além disso, os tópicos podem ser divididos em partições, permitindo escalabilidade e processamento paralelo isso é o grande diferencial do kafka pros demais serviços de mensageria.

Vou exemplificar como os tópicos funcionam:

• spring-topic-dukes-notification --> Este tópico pode ser utilizado para notificações que devem ser enviadas após uma regra de negócio específica ser acionada no sistema.
• spring-topic-dukes-saga --> Um tópico que pode ser utilizado, por exemplo, para gerenciar eventos após a inserção de um novo produto.

Mesmo dentro de um mesmo tópico, as mensagens podem ser armazenadas em diferentes partições. Isso significa que um consumidor pode estar lendo mensagens da partição 0, enquanto outro pode estar consumindo mensagens de outra partição dentro do mesmo tópico, desta forma o mecanismo garante que o Kafka possa processar grandes volumes de dados de forma eficiente, distribuindo a carga entre múltiplos consumidores.

 

1. Procucers && Consumers

Agora que explicamos os tópicos e partições, podemos falar sobre os produtores (quem envia mensagens para o Kafka) e os consumidores (quem recebe essas mensagens).

• Produtor (Producer): Envia mensagens para um tópico específico. Pode definir para qual partição a mensagem será enviada.
  
• Consumidor (Consumer): Lê as mensagens de um tópico. Pode fazer parte de um grupo de consumidores, o que permite que várias instâncias processem mensagens em paralelo.

2. Retenção de Mensagens

Outro ponto importante é que o Kafka não apaga as mensagens logo após serem consumidas. Elas são armazenadas por um período definido por exemplo: 7 dias. Assim ele garante que novos consumidores possam ler mensagens antigas se necessário. 

3. Confiabilidade

O Kafka garante que as mensagens não se percam através de três conceitos:

• Replicação: Cada partição pode ter réplicas em diferentes servidores.
• Confirmação de mensagens: O produtor pode exigir que o Kafka confirme quando a mensagem foi gravada.
• Commit de Offset: Os consumidores registram até onde já leram para evitar duplicação ou perda de mensagens.

 
 
 
 
 

Kafka + Java 

Agora que construímos uma base mais sólida sobre o Kafka, entendemos que ele possui muitos conceitos que, à primeira vista, podem parecer complexos. No entanto, com estudo e prática, é possível dominá-los e aproveitar todo o seu potencial.

 

Escolhendo uma Interface para Monitoramento

O Kafka, por padrão, não possui uma interface gráfica, mas existem algumas ferramentas que ajudam a visualizar os tópicos, mensagens e consumidores de forma mais intuitiva. Algumas das principais opções são:

• Redpanda Console – Uma interface moderna e simples para visualizar tópicos e mensagens.
• Kafka UI – Uma ferramenta leve para monitorar consumidores e tópicos.

Para um ambiente de desenvolvimento, o Redpanda Console é bem legal, é fácil de configurar e tem uma boa experiência visual para acompanhar os eventos no Kafka. Segue aqui tambem o kafka e seu repositorio link.

Subindo o Kafka e a Interface Visual

Para rodar o Kafka localmente e visualizar as mensagens de forma mais prática, podemos utilizar o Docker para subir o Kafka e uma ferramenta gráfica. Isso ajuda muito para fazer o gerenciamento e monitoramento dos tópicos sem precisar de configurações mt complexa.

Com o Kafka rodando, conseguimos acessar a interface gráfica e visualizar em tempo real as mensagens que são enviadas e consumidas pelos nossos sistemas.

 Aqui um exemplo de como fiz subindo pelo Docker Compose:

Configurando o Kafka no Java

Depois de garantir que o servidor Kafka está funcionando, o próximo passo é configurar nossa aplicação Java para se conectar a ele.

No Spring Boot, por exemplo, essa configuração pode ser feita no arquivo de propriedades da aplicação. Basicamente, é necessário informar:

• O endereço do servidor Kafka
• Como as mensagens serão serializadas e desserializadas
• Qual será o grupo de consumidores
•  

Aqui um exemplo de como fica:

 

 Neste caso especifico estou usando o mongo como banco e veja que temos dois tópicos que são utilizados o  start-saga que usei para receber produtos quando criados, já o notify-ending uso para disparar a mensagem para o consumer que o order-group pretendo mais pra frente postar esse projeto para que possam ver na pratica como funciona.

 

Essas configurações garantem que nossa aplicação conseguirá publicar e consumir mensagens corretamente dentro dos tópicos definidos.

 

 

Gabriel Carrijo

Back-end Developer Java | Spring Boot | Quarkus | Microservices | SQL & NOSQL | SOLID | Design Patterns