Get unlimited access to the best of Medium for less than $1/week.

Become a member

Como trabalhar com Kafka e Spring Boot de forma

simples
Renato Lessa · Follow
11 min read · Jul 4, 2021

Share More

Com a corrida das grandes industrias para modernização e construção de aplicações

robustas. É preciso dizer que estamos numa geração que se digitaliza do dia para noite, ou
pelo menos essa é a ideia e com isso muitos sistemas modernos exigem que os dados sejam
processados para a finalidade desejada, assim que estiverem disponíveis. Por exemplo, como
Arquiteto de Software, se falarmos sobre um sistema de registro ou monitoramento,
geralmente solicitamos os dados assim que ocorre um problema. Em suma importância, há
um alto requisito de entrega de dados mais rápida e robusta. Aqui, o Apache Kafka pode ser
uma boa opção para solucionar nosso propósito.

O Apache Kafka atua como um mediador para transmitir dados entre aplicações que geram
dados e aplicações que consomem dados.

Figura 1 — Ilustração do cenário

Quais os impedimentos de usar (Java Message Service)?

1) Depende da linguagem Java. Assim, ambos os participantes: Produtor e Consumidor

devem ser apenas Aplicativos Java.

2) Funciona em protocolo (TCP). Não é compatível com outro protocolo.

3) Se a mensagem for muito grande em tamanho, o MOM (apenas um software Message

Broker) se comportará muito lentamente.

4) No caso de vários produtores e consumidores, não é compatível com escalonamento.

Portanto, não podemos criar várias instâncias do MOM.

5) Além disso, existe a possibilidade de perda de dados, se o MOM estiver inativo ou se o

MOM não estiver respondendo. Por causa de uma única instância, se o produtor enviou a
mensagem ao MOM, e o MOM está inativo. Então, o consumidor não receberá mensagens.

♦ JMS é o melhor para os aplicativos de menor escala, como no caso de um menor número de
producer ou um menor número de consumidores, mas esse tema poderá ser retratado em
outro artigo.
O que é o Apache Kafka?

Apache Kafka é uma plataforma de software de código aberto desenvolvida pela Apache
Software Foundation escrita em Java e Scala. O projeto visa oferecer uma plataforma
unificada, de alto rendimento e baixa latência para lidar com feeds de dados em tempo real.
O Kafka pode se conectar a sistemas externos para importação e exportação de dados via
Kafka Connect e fornece Kafka Streams, uma biblioteca de processamento de fluxo Java.

Apache Kafka é uma plataforma de streaming de dados distribuída que pode publicar,
assinar, armazenar e processar fluxos de registros em tempo real. Ele é projetado para lidar
com fluxos de dados de várias fontes e entregá-los a vários consumidores. Em suma, ele move
grandes quantidades de dados, não apenas do ponto A para B, mas dos pontos A para Z e em
qualquer outro lugar que você precisar, tudo ao mesmo tempo.

Apache Kafka é uma alternativa a um sistema de mensagens corporativo tradicional. Ele

começou como um sistema interno desenvolvido pelo LinkedIN para lidar com 1,4 trilhão de
mensagens por dia, mas agora é uma solução de streaming de dados de código aberto para
uma variedade de necessidades corporativas.

APIs Kafka

O Kafka tem cinco API's principais para Java e Scala:

1) A Admin API é para gerenciar e inspecionar tópicos, brokers e outros objetos Kafka.

2) A Producer API é para publicar (gravar) um fluxo de eventos para um ou mais tópicos do
Kafka.

3) A Consumer API é para assinar (ler) um ou mais tópicos e processar o fluxo de eventos
produzidos para eles.

4) A Kafka Streams API é para implementar aplicações de processamento de fluxo e micros

serviços. Ele fornece funções de nível superior para processar fluxos de eventos, incluindo
transformações, operações com estado como agregações e junções, janelas, processamento
com base no horário do evento e muito mais. A entrada é lida de um ou mais tópicos para
gerar saída para um ou mais tópicos, transformando efetivamente os fluxos de entrada em
fluxos de saída.

5) A Kafka Connect API é para fazer o build e executar conectores de importação e

exportação de dados reutilizáveis ​que consomem (leem) ou produzem (gravam) fluxos de
eventos de e para sistemas e aplicativos externos para que possam se integrar ao Kafka. Por
exemplo, um conector para um banco de dados relacional como PostgreSQL pode capturar
todas as alterações em um conjunto de tabelas. No entanto, na prática, você normalmente
não precisa implementar seus próprios conectores porque a comunidade Kafka já fornece
centenas de conectores prontos para uso.

Figura 2— Ilustração do cenário

Por quê o Kafka é usado?

1) No entanto, Kafka é implementado na linguagem Java, mas suporta integração com

diferentes tecnologias e conceitos como Spark, Scala, Hadoop, BigData, etc.

2) Por causa de seu design de cluster, o Kafka oferece suporte à transferência de dados entre
vários sistemas complexos.

3) Além disso, o Kafka oferece suporte à integração com tecnologias não java, mesmo por
meio de chamadas REST.

4) Além disso, é independente de protocolo, pois podemos escrever códigos usando TCP, FTP,
HTTP, etc.

5) Igualmente importante, o Kafka oferece suporte a vários brokers de mensagens. Isso

significa que o escalonamento horizontal do software do broker é possível aqui.

6) Kafka usa o suporte do Zookeeper para lidar com o balanceamento de carga, estilo o Netflix
Eureka Microservices.
Quais os benefícios de usar o Kafka em relação a outras tecnologias existentes.

1) O Kafka oferece entrega rápida de mensagens. Além disso, um único broker Kafka pode
atender a milhares de clientes lidando com megabytes de leituras e gravações por segundo.

2) As mensagens no Kafka são persistentes, pois são replicadas no cluster para evitar
qualquer perda de dados.

3) No Kafka, há uma provisão para partições e simplificação de dados em um cluster de

máquinas para lidar com dados maiores.

4) Além disso, o Kafka oferece mecanismo de tolerância a falhas e durabilidade.

5) Além disso, o Kafka pode processar uma mensagem de tamanho muito grande. O tamanho
máximo da mensagem que o servidor Kafka pode receber é 1000000 bytes.

Quais são os componentes do Kafka?

Às vezes, todo o sistema Kafka também é conhecido como Kafka Cluster, pois pode consistir
em vários elementos e vários node servers. E é por isso que Kafka é classificado como um
sistema distribuído. No entanto, os quatro principais componentes do Kafka são:

Producer

Um Producer Kafka atua como uma fonte de dados que grava, otimiza e publica mensagens
para um ou mais tópicos Kafka. Os producers Kafka também serializam, compactam e
equilibram a carga de dados entre brokers por meio de partições.

Topic

Um Topic Kafka representa um canal pelo qual os dados são transmitidos. Além disso, os
produtores publicam mensagens em tópicos e os consumidores leem as mensagens do tópico
que assinam. Além disso, os Topics organizam e estruturam mensagens. Seus tipos
específicos de mensagens semelhantes serão publicados em tópicos específicos. Eles são
definidos por nomes exclusivos em um cluster Kafka. No entanto, não há limite para o
número de tópicos que podem ser criados.

Brokers

Na verdade, Brokers são os componentes de software executados em um nó. Muitas pessoas

na indústria definem um brokers Kafka como um servidor em execução em um cluster
Kafka. Em outras palavras, um cluster Kafka consiste em vários brokers. Normalmente,
vários brokers formam o cluster Kafka e obtêm balanceamento de carga e redundância e
failover confiáveis. Os brokers usam o Apache ZooKeeper para o gerenciamento e
coordenação do cluster. Cada instância do brokers é capaz de lidar com quantidades de
leitura e gravação. Cada brokers possui um ID exclusivo e é responsável por partições de um
ou mais logs de tópico.

Consumer

Os consumers Kafka lêem mensagens dos tópicos que assinam. Os consumidores

pertencerão a um grupo de consumers. Cada consumidor em um determinado grupo de
consumers terá a responsabilidade de ler um subconjunto das partições de cada topics ao
qual está inscrito.

Os dados no cluster Kafka são distribuídos entre vários brokers. Existem várias cópias dos
mesmos dados no cluster Kafka. Eles são chamados de réplicas. Esse mecanismo torna o
Kafka ainda mais confiável, tolerante a falhas e estável. Se ocorrer um erro com um broker, o
outro brokers começará a executar as funções do componente quebrado. Portanto, não há
chances de perda de informações.

Figura 3— Ilustração do cenário

O que é o Zookeeper?

Como o Kafka, o ZooKeeper também é uma ferramenta de código aberto fornecida pela
Apache Software Foundation. Ele fornece um serviço centralizado em sistemas distribuídos,
como o fornecimento de informações de configuração, sincronização, registro de
nomenclatura e outros serviços de grupo em grandes clusters. Kafka usa o Zookeeper para
rastrear o status dos nós no cluster Kafka.

Qual é a função do Zookeeper com o Kafka?

Ao trabalhar com qualquer sistema distribuído, deve haver uma maneira de coordenar as
tarefas. Em nosso contexto, Kafka é um sistema distribuído que usa o ZooKeeper para
coordenar suas tarefas. No entanto, existem algumas outras tecnologias, como Elasticsearch
e MongoDB, que têm seus próprios mecanismos integrados para coordenar tarefas.

1) Ao trabalhar com o Apache Kafka, a função principal do ZooKeeper é rastrear o status dos
nós no cluster Kafka e também manter uma lista de tópicos e mensagens do Kafka.

2) Na verdade, o ZooKeeper coordena a topologia de brokers e cluster.

3) O ZooKeeper atua como um sistema de arquivos consistente para informações de

configuração. Além disso, contém uma lista de todos os brokers Kafka com ele. Ele notifica o
Kafka se algum broker ficar inativo, se a partição for desativada ou se um novo broker estiver
ativo ou se a partição estiver ativa.

4) O ZooKeeper também acessa quantos dados cada cliente tem permissão para ler e gravar.

5) Além disso, o Kafka usa o Zookeeper para armazenar deslocamentos de mensagens

consumidas para um tópico específico e partição por um grupo de consumidores específico.

As mensagens contidas nas partições são atribuídas a um número de ID exclusivo que é

chamado de deslocamento. A função do deslocamento é identificar exclusivamente cada
mensagem dentro da partição.

Agora vamos colocar a mão na massa:

Como instalar o Kafka ?

Step#1 : Como Fazer o download do Kafka

Aqui, nessa POC eu utilizo o Kafka 2.6.0 e executamos nosso exemplo com sucesso. Ainda,
você pode tentar a versão mais recente disponível e estável.

1) Entre no site para realizar o download do Kafka

https://www.apache.org/dyn/closer.cgi?path=/kafka/2.6.0/kafka_2.12-2.6.0.tgz

2) Clique em HTTP LINK, Semelhante a:

https://archive.apache.org/dist/kafka/2.6.0/kafka_2.12-2.6.0.tgz

O download será realizado no seguinte formato .tgz format…

Step#2 : Como Instalar o Kafka

 1. Extrair para uma pasta:
Clique com o botão direito em kafka_2.12–2.6.0.tgz, Extrair a pasta Kafka em seu diretório
de preferência.

2) Copie esta pasta para uma unidade de seu sistema se estiver utilizando Windows C:/ ou D:/,
no caso do Linux você pode colocar a pasta em /opt/development, se estiver utilizando o IOS
os princípios são os mesmo, /Users. Lembrando que o local do armazenamento da pasta
Kafka é somente uma sugestão, você pode coloca-la por exemplo em um Workspace e fazer a
referencia do caminho.

Isso é tudo para a parte de instalação.

Inicialização do Apache Kafka com Spring Boot

Como nosso objetivo final é aprender como trabalhar com o Apache Kafka no Spring Boot, É
hora de passar por isso passo a passo. Já instalamos o software Kafka conforme descrito na
seção anterior. Agora, vamos em frente e vamos ver na pratica a implementação .

Step#1: Crie um novo projeto Spring Boot Starter usando STS

Ao criar o Projeto inicial, selecione Spring Web, Spring para Apache Kafka e Spring Boot
DevTools como dependências do projeto inicial.

Step#2: Aplicando @EnableKafka em sua classe

Para obter os recursos do Apache Kafka com Spring Boot, precisamos aplicar @EnableKafka
na classe principal conforme abaixo.

package com.renatolessa.kafka.api;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.annotation.EnableKafka;

@SpringBootApplication
@EnableKafka
public class KafkaApplication{

public static void main(String[] args) {

SpringApplication.run(KafkaApplication.class, args);

}
Step#3: Crie uma classe MessageRepository personalizada

Aqui, criaremos uma classe MessageRepository personalizada. Além disso, criaremos uma
lista e adicionaremos cada mensagem recebida nessa lista. Além disso, criaremos dois
métodos; um para adicionar uma mensagem e outro para recuperar todas as mensagens. Por
exemplo, o código abaixo demonstra o conceito.

package com.renatolessa.kafka.api.reposioty;
import java.util.ArrayList;
import java.util.List;
import org.springframework.stereotype.Component;

@Component
public class MessageRepository {

private List<String> list = new ArrayList<>();

public void addMessage(String message) {

list.add(message);
}

public String getAllMessages() {

return list.toString();
}
}

Step#4: Crie uma classe MessageProducer

Para produzir as mensagens e enviar para o Tópico, criaremos uma classe MessageProducer
conforme abaixo.

package com.renatolessa.kafka.api.sender;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;

@Component
public class MessageProducer {

private Logger log =LoggerFactory.getLogger(MessageProducer.class);

@Autowired
private KafkaTemplate<String, String> kafkaTemplate;
 @Value("${myapp.kafka.topic}")
private String topic;

public void sendMessage(String message) {

log.info("MESSAGE SENT FROM PRODUCER END -> " + message);
kafkaTemplate.send(topic, message);
}
}

Step#5: Crie uma classe MessageConsumer

Agora é a vez de criar uma classe MessageConsumer que consome as mensagens enviadas
pelo Produtor via Tópico.

package com.renatolessa.kafka.api.consumer;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
import com.dev.spring.kafka.message.repository.MessageRepository;

@Component
public class MessageConsumer {

private Logger log = LoggerFactory.getLogger(MessageConsumer.class);

@Autowired
private MessageRepository messageRepo;

@KafkaListener(topics = "${myapp.kafka.topic}", groupId ="xyz")

public void consume(String message) {
log.info("MESSAGE RECEIVED AT CONSUMER END -> " + message);
messageRepo.addMessage(message);
}
}

Step#6: Crie um RestController como classe KafkaRestController

Agora, criaremos um RestController que receberá as mensagens do navegador da Web como

entrada para o Producer. Em outras palavras, enviaremos mensagens para Kafka para
processá-las por meio de uma chamada de Rest call.

package com.renatolessa.kafka.api.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.dev.spring.kafka.message.repository.MessageRepository;
import com.dev.spring.kafka.sender.MessageProducer;

@RestController
public class KafkaRestController {

@Autowired
private MessageProducer producer;

@Autowired
private MessageRepository messageRepo;

//Send message to kafka

@GetMapping("/send")
public String sendMsg(
@RequestParam("msg") String message) {
producer.sendMessage(message);
return "" +"'+message +'" + " sent successfully!";
}

//Read all messages

@GetMapping("/getAll")
public String getAllMessages() {
return messageRepo.getAllMessages() ;
}
}

Step#7: Crie um arquivo application.yml

No final, iremos criar um arquivo application.yml conforme abaixo. Lembre-se de remover o

arquivo application.properties da pasta src/main/resources e incluir este arquivo. Se você
mantiver os dois arquivos, application.properties será efetivado por padrão.

application.yml
server:
port: 9090

spring:
kafka:
producer:
bootstrap-servers: localhost:9091
key-serializer: org.apache.kafka.common.serialization.StringSerializer
value-serializer: org.apache.kafka.common.serialization.StringSerializer

consumer:
bootstrap-servers: localhost:9091
key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
 myapp:
kafka:
topic: relesiKafkaTest

A estrutura do seu projeto se pareceria com algo abaixo da tela.

 Figura 4— Ilustração do cenário

Como testar a aplicação?

Para testar o aplicativo, siga as etapas abaixo.

1) Iniciar Zookeeper
bash>cd ~/kafka_2.12–2.6.0

bash> ~ ./bin/zookeeper-server-start.bat ./config/zookeeper.properties

bash> ~/Users/renatolessa/bin/zookeeper-server-start.bat ./config/zookeeper.properties

2) Iniciar Kafka setup

bash> cd ~/Users/renatolessa/kafka_2.12–2.6.0
bash> ~ ./bin/kafka-server-start.bat .\config\server.properties

3) Criando o Topic

bash>./bin/kafka-topics.bat — create — zookeeper localhost:2181 — replication-factor 1 —

partitions 1 — topic relesiKafkaTest

4) Run Spring Boot Application

5) Depois de iniciar a aplicação, digite os URLs abaixo no navegador e teste os resultados.

http:// localhost:9090/send?msg=I like

http:// localhost:9090/send?msg=to work on
http:// localhost:9090/send?msg=Kafka
http:// localhost:9090/send?msg=with Spring Boot

http://localhost:9090/getAll

6) Verifique também sua saída no console. Você verá uma saída semelhante à tela abaixo.
 Figura 5— Ilustração do cenário

Conclusão

Depois de passar por toda a parte teórica e de exemplo de como trabalhar com o Apache
Kafka no Spring Boot na pratica, finalmente, devemos ser capazes de implementar um
Projeto Spring Boot usando o Apache Kafka. Da mesma forma, esperamos de você estender
ainda mais esses exemplos e implementá-los em seu projeto de acordo com sua necessidade
e regra de negócio.

Além disso, se houver alguma atualização no futuro, também atualizarei esse artigo.

A ideia geral de escrever esse artigo é repassar o entendimento para quem quer começar a
trabalhar com arquitetura em eventos e que possa ter uma entendimento um pouco mais
simples sobre o tema, lembrando que esse artigo é apenas uma passo inicial para trabalhar
com Kafka ainda tem uma grande jornada pelo caminho.

O Apache Kafka tem uma documentação sensacional.

Kafkawithspringboot Kafkasimple Springboot Javawithkafka Java

Follow

Written by Renato Lessa

3 Followers

Enterprise Technology Architecture | Solution Architect

More from Renato Lessa

Renato Lessa

Yes, many financial institutions and banks use Java as one of the main
programming languages for…
Java technology provides banks and financial institutions with the security they need for their open
banking solutions. In addition, Java…

10 min read · Jan 17

 Renato Lessa

Descomplicando a Orientação Objetos

Introdução

10 min read · Jul 16, 2022

Open in app

Search Medium

Renato Lessa
Spring Validation With Relational Databases
Persistence

4 min read · Jun 24, 2021

See all from Renato Lessa

Recommended from Medium

Berkay Haberal in Stackademic

How Java Memory Works?

Before we move on to the performence things, we need to learn that what is really going on in the
background of JVM (Java Virtual Machine)…

4 min read · Jul 30

479 5
 karthik jeyapal

Circular Dependency in Spring Boot: How to Detect and Fix It

In Spring Boot, circular dependency occurs when two or more beans depend on each other. This can
happen when a bean requires another bean…

7 min read · Apr 15

15 1

Lists

It's never too late or early to start something

15 stories · 114 saves

General Coding Knowledge

20 stories · 325 saves

New_Reading_List
174 stories · 102 saves
 Devalère T KAMGUIA

Master Data Processing With Spring Batch: Best Practices

Best practices that will empower you to create efficient and robust batch processing workflows.

9 min read · Jun 5

16

Ionut Anghel
REST Endpoint Best Practices Every Developer Should Know
5 min read · Mar 18

535 4

Victor Timi in Level Up Coding

“Good Commit” vs “Your Commit”: How to Write a Perfect Git Commit Message
A good commit shows whether a developer is a good collaborator — Peter Hutterer, Linux.

· 8 min read · Sep 5

1.3K 16
 The Java Trail

Spring Boot: Exception Handling Best Practices

Use @ControllerAdvice for global exception handling

5 min read · Sep 3

90

See more recommendations