Primeiros passos com Kafka - Parte 2
Published: 2021-03-08 00:15:48

Créditos da foto de capa: [Margan Zajdowicz](https://www.freeimages.com/photographer/marganz-55286) from [FreeImages](https://freeimages.com/)

E lá vamos nós para a continuação do papo sobre Kafka!

Hoje em dia é muito comum o uso do formato JSON quando estamos enviando ou recebendo dados em nossos serviços.
Embora não seja o mais comum, você também pode utilizar JSON quando for trabalhar com Kafka.
Dependendo do tipo de linguagem que você for utilizar para seus serviços, outros formatos mais indicados seriam Protocol Buffers ou Avro. Como Protocol Buffer possúi gerador de código para diversas linguagens e também passou recentemente a ser suportado pela plataforma da Confluent, eu indico que você considere o uso de Protocol Buffers em vez de Avro. Mas isso é papo para outra publicação.

Hoje vamos ver quais comandos podemos utilizar para enviar mensagens JSON no Kafka.
Eu gosto muito de poder mostrar um exemplo como estes em JSON, porque fica mais fácil para entender como as coisas funcionam e se você for em algum momento utilizar a plataforma da Confluent, fica mais fácil para realizar os testes iniciais.

### Do que vamos precisar?

Conforme vimos na Parte 1, vamos precisar de pelo menos um nó do Kafka rodando.

Que tal utilizarmos como exemplo plantas?
Vamos iniciar criando um tópico.

```
docker-compose exec broker kafka-topics --create \
    --bootstrap-server broker:9092 \
    --topic plantas \
    --partitions 3 \
    --replication-factor 1
```

Imagine que estamos utilizando o Kafka para controle lotes de plantas que são vendidos.
Cada lote possui um código identificador, o valor do lote, de qual planta é composto o lote, e estufa onde está localizado o lote para a retirada.

Poderíamos pensar no seguinte modelo para as mensagens:
```
{
   "lote": "abc-123",
   "valor": 123.45,
   "planta": "abcde",
   "estufa": "estufa-a"
}
```

### Enviando mensagens JSON para o Kafka

Agora que temos um contexto, vamos criar algumas mensagens nesse tópico.

Uma forma seria utilizando o comando **kafka-console-producer** como vimos na publicação anterior. Porém, não é exatamente prático quando queremos enviar algo no formato JSON.

Recentemente eu descobri o [kafkacat](https://github.com/edenhill/kafkacat).
Para utilizar o kafkacat podemos instalar a ferramenta, ou da forma que eu costumo utilizar, através de um container no Docker.
Abaixo temos um exemplo de como podemos utilizar esta ferramenta para enviar mensagens no formato JSON, sem precisar instalar o kafkacat.

```
docker run -i --rm --network cp-all-in-one_default edenhill/kafkacat:1.6.0 -P -b broker:29092 -t plantas \
<<EOF

{"lote":"abc-123","valor":1500.57,"planta":"orquidea phalaenopsis","estufa":"orq-1"}
{"lote":"efg-432","valor":430.00,"planta":"bromelia ruby","estufa":"brm-4"}
{"lote":"xyz-987","valor":235.00,"planta":"bromelia fasciata","estufa":"brm-1"}
EOF
```

Pronto! Não tem segredo!
Vou explicar um pouco sobre os parâmetros acima.
Repare que foi necessário passar o `--network` do Docker. Isso é necessário para que o container consiga acessar os demais containers que estão rodando no Docker, ou seja, aquele que subimos ao executar o `docker-compose` da primeira publicação.
Quando executamos o comando, passamos o argumento `-P` para informar que estamos produzindo mensagens. O `-b` é onde informamos em qual nó do Kafka vamos produzir as mensagens.
Já o `-t` serve para informarmos em qual tópico as mensagens serão escritas. 
Em seguida, utilizo o bom e velho comando [EOF](https://linuxhint.com/what-is-cat-eof-bash-script/) que você pode executar em qualquer sistema Unix.

### E para consumir essas mensagens?

Para conseguir consumir essas mensagens no terminal, você pode fazer exatamente como na publicação anterior, utilizando o comando **kafka-console-consumer**.
Por outro lado, se você estiver consumindo mensagens JSON em alguma aplicação, será necessário mapear corretamente o modelo da mensagem.

Mas você também pode usar o kafkacat para ler as mensagens:
```
docker run -i --rm --network cp-all-in-one_default edenhill/kafkacat:1.6.0 -G meu-grupo -b broker:29092 plantas
```
Aqui nós temos de diferente apenas o `-G`, que serve para informar qual é o nome do grupo consumidor.

### Ah, mais uma coisa sobre o kafkacat

Se você quiser, pode enviar mensagens com uma chave utilizando esta ferramenta. 
Pensando no mesmo exemplo de plantas, poderiamos apenas adicionar o parâmetro `-K:` e a chave antes de cada mensagem, como no comando abaixo.
```
docker run -i --rm --network cp-all-in-one_default edenhill/kafkacat:1.6.0 -P -b broker:29092 -t plantas -K: \
<<EOF

1:{"lote":"foo-466","valor":60.50,"planta":"cactus enxertado","estufa":"cac-1"}
2:{"lote":"bar-311","valor":430.00,"planta":"bromelia ruby","estufa":"brm-3"}
3:{"lote":"usd-560","valor":440.00,"planta":"bromelia lingulata","estufa":"brm-3"}
EOF
```

### E é isso!

Bastante simples, não é mesmo?

Agora você já conhece a parte básica de como enviar e consumir mensagens de texto e também JSON no Kafka.

Espero que estas duas publicações tenham sido de alguma ajuda! Até a próxima!