Kafka 101
Tags: architecture, eventdriven, programming, beginners
Published: 2021-11-16 12:25:28

## O que é o Apache Kafka?

### Primeira coisa vamos falar sobre streaming.

O streaming de eventos é o equivalente digital do sistema nervoso central do corpo humano. É a base tecnológica para o mundo "sempre ativo", onde as empresas são cada vez mais definidas e automatizadas por software e onde o usuário de software é mais software.

Tecnicamente falando, o streaming de eventos é a prática de capturar dados em tempo real de fontes de eventos como  bancos de dados, sensores dispositivos móveis, serviços em nuvem e aplicativos de software na forma de fluxos de eventos; armazenar esses fluxos de eventos de forma durável para recuperação posterior; manipular, processar e reagir aos fluxos de eventos em tempo real e também retrospectivamente; e encaminhar os fluxos de eventos para diferentes tecnologias de destino, conforme necessário. 

O streaming de eventos, portanto, garante um fluxo contínuo e interpretação dos dados para que as informações certas estejam no lugar certo, na hora certa.

### Para que posso usar o streaming de eventos?

O streaming de eventos é aplicado a uma ampla variedade de casos de uso em uma infinidade de setores e organizações. 

 ### Seus muitos exemplos incluem:

- Para processar pagamentos e transações financeiras em tempo real, como em bolsas de valores, bancos e seguros.
- Para rastrear e monitorar carros, caminhões, frotas e remessas em tempo real, como na logística e na indústria automotiva.
- Para capturar e analisar continuamente os dados do sensor de dispositivos IoT ou outros equipamentos, como fábricas e parques eólicos.
- Para coletar e reagir imediatamente às interações e pedidos do cliente como no varejo, no setor de hotéis e viagens e em aplicativos móveis.
- Para monitorar pacientes em cuidados hospitalares e prever mudanças nas condições para garantir o tratamento oportuno em emergências.
- Conectar, armazenar e disponibilizar dados produzidos por diferentes divisões de uma empresa.
- Para servir como base para plataformas de dados, arquiteturas orientadas a eventos e microsserviços.

### Apache Kafka® é uma plataforma de streaming de eventos. O que isso significa?

O Kafka combina três recursos principais para que você possa implementar seus casos de uso para streaming de eventos de 
ponta a ponta com uma única solução testada em batalha:

  1) Para publicar (gravar) e assinar (ler) fluxos de eventos, incluindo importação / exportação contínua de seus dados de outros sistemas.
  2) Para armazenar streams de eventos de forma durável e confiável pelo tempo que você quiser.
  3) Para processar fluxos de eventos conforme eles ocorrem ou retrospectivamente.

  E toda essa funcionalidade é fornecida de maneira distribuída, altamente escalável, elástica, tolerante a falhas e segura. O Kafka pode ser implantado em hardware máquinas virtuais e contêineres, e no local, bem como na nuvem. 
  
  Você pode escolher entre o autogerenciamento de seus ambientes Kafka e o uso de serviços totalmente gerenciados oferecidos por diversos fornecedores.

## Como funciona o kafka 

Kafka é um sistema distribuído que consiste em servidores e clientes que se comunicam por meio de um protocolo de rede TCP de alto desempenho . Ele pode ser implantado em hardware bare-metal, máquinas virtuais e contêineres no local, bem como em ambientes de nuvem.

**Servidores:** O Kafka é executado como um cluster de um ou mais servidores que podem abranger vários datacenters ou regiões de nuvem. Alguns desses servidores formam a camada de armazenamento, chamados de corretores. Outros servidores executam o Kafka Connect para importar e exportar dados continuamente como fluxos de eventos para integrar o Kafka com seus sistemas existentes, como bancos de dados relacionais, bem como outros clusters Kafka. Para permitir que você implemente casos de uso de missão crítica, um cluster Kafka é altamente escalonável e tolerante a falhas: se algum de  seus servidores falhar, os outros servidores assumirão seu trabalho para garantir operações contínuas sem qualquer perda de dados.

**Clientes:** Eles permitem que você escreva aplicativos e microsserviços distribuídos que leem, gravam e processam fluxos de eventos em paralelo, em escala e de maneira tolerante a falhas, mesmo no caso de problemas de rede ou de máquina. O Kafka vem com alguns desses clientes incluídos, que são aumentados por dezenas de clientes fornecidos pela comunidade Kafka: os clientes estão disponíveis para Java e Scala, incluindo a biblioteca Kafka Streams de nível superior, para Go, Python, C/C++ e muitas outras programações linguagens, bem como APIs REST.


## O que é um Tópico.

Os eventos são organizados e armazenados de forma duradoura em tópicos. Muito simplificado, um tópico é semelhante a uma pasta em um sistema de arquivos, e os eventos são os arquivos dessa pasta. Um exemplo de nome de tópico poderia ser "pagamentos". Os tópicos no Kafka são sempre multiprodutor e multi-assinante: um tópico pode ter zero, um ou muitos produtores que gravam eventos nele, bem como zero, um ou muitos consumidores que assinam esses eventos. Os eventos em um tópico podem ser lidos com a frequência necessária - ao contrário dos sistemas de mensagens tradicionais os eventos não são excluídos após o consumo. Em vez disso, você define por quanto tempo o Kafka deve reter seus eventos por meio de uma definição de configuração por tópico, após o qual os eventos antigos serão descartados. O desempenho do Kafka é efetivamente constante em relação ao tamanho dos dados, portanto, armazenar dados por um longo tempo é perfeitamente adequado.

Os tópicos são particionados , o que significa que um tópico é espalhado por vários "depósitos" localizados em diferentes corretores Kafka. Esse posicionamento distribuído de seus dados é muito importante para a escalabilidade, pois permite que os aplicativos clientes leiam e gravem os dados de/para vários corretores ao mesmo tempo. Quando um novo evento é publicado em um tópico, ele é, na verdade, anexado a uma das partições do tópico.

Eventos com a mesma chave de evento (por exemplo, um cliente ou ID de veículo) são gravados na mesma partição, e Kafka garante que qualquer consumidor de uma determinada partição de tópico sempre lerá os eventos dessa partição exatamente na mesma ordem em que foram gravados.

![Kafka](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ahlzbzvmtddknx5zxhcu.png)

**Figura:** Este tópico de exemplo tem quatro partições P1 – P4. Dois clientes produtores diferentes estão publicando, independentemente um do outro, novos eventos no tópico, gravando eventos na rede nas partições do tópico. 

Eventos com a mesma chave (denotados por suas cores na figura) são gravados na mesma partição. Observe que ambos os produtores podem gravar na mesma partição, se apropriado.

Para tornar seus dados tolerantes a falhas e altamente disponíveis, todos os tópicos podem ser replicados, mesmo em regiões geográficas ou datacenters para que sempre haja vários corretores que tenham uma cópia dos dados, caso algo dê errado, você deseja fazer manutenção nos corretores e assim por diante. Uma configuração de produção comum é um fator de replicação de 3, ou seja, sempre haverá três cópias de seus dados. Essa replicação é realizada no nível das partições de tópico.

## Configurando o ambiente.

### Instalar o Kafka

Link para baixar o [Kafka](https://kafka.apache.org/downloads)

Depois disso você pode descompactar em qualquer pasta `No meu caso eu descompactei na pasta C:`

Depois disso você pode descompactar em qualquer pasta `No meu caso eu descompactei na pasta C:`


### Rodando o kafka na sua maquina MAC/linux

- Acessar a pasta `seucaminho/kafka.2.12-2.3.1/bin/`
- 
**OBS:** fique atento com a versão que vc baixou 

- Depois Executar o comando:
```
kafka-server-start.sh config/server.properties
```

### Rodando o kafka na sua maquina windows:

- Acessar a a pasta `C://kafka.2.12-2.3.1/bin/windows`.

**OBS:** fique atento com a versão que vc baixou

- Executar o comando:

```
kafka-server-start.bat  C:\kafka_2.12-2.3.1\config\server.properties
```

### Criando um Tópico via comando

### Criando um tópico no Windows

```
kafka-topics.bat --create --bootstrap-server localhost:9092 --replication-factor 1 --partitions 1 --topic NOME_DO_TOPICO
```

### Criando um tópico no Mac/linux

```
kafka-topics.sh --create --bootstrap-server localhost:9092 --replication-factor 1 --partitions 1 --topic NOME_DO_TOPICO
```

### Listando Tópicos via comando

### Listando um tópico no Windows

```
kafka-topics.bat --list --bootstrap-server localhost:9092
```

### Listando um tópico no Mac/linux

```
kafka-topics.sh --list --bootstrap-server localhost:9092
```

### Produzindo mensagem para um Tópico via comando

### Produzindo uma mensagem em um tópico no Windows

```
kafka-console-producer.bat --broker-list localhost:9092 --topic NOME_DO_TOPICO
```

**OBS:** Após rodar esse comando cada texto que vc digitar no terminal e apertar enter será uma mensagem do tópico

### Produzindo uma mensagem em um tópico no Mac/linux

```
kafka-console-producer.sh --broker-list localhost:9092 --topic NOME_DO_TOPICO
```

**OBS:** Após rodar esse comando cada texto que vc digitar no terminal e apertar enter será uma mensagem do tópico

### Consumindo um Tópico via comando

### Consumindo um tópico no Windows

```
kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic NOME_DO_TOPICO --from-beginning
```

### Consumindo um tópico no Mac/linux

```
kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic NOME_DO_TOPICO --from-beginning
```

### Listando Tópicos via docker-compose

```
docker-compose exec kafka kafka-topics --list --bootstrap-server localhost:9092
```

### Consumindo um Tópico via docker-compose

```
docker-compose exec kafka kafka-console-consumer --bootstrap-server localhost:29092 --topic NOME_DO_TOPICO --from-beginning
```

### Referências Kafka

https://www.confluent.io/

https://kafka.apache.org/intro

https://kafka.apache.org/21/documentation.html

https://kafka.apache.org/21/documentation.html#consumerconfigs