Processamento e análise de dados em tempo real com Kafka e Python
O Kafka é uma poderosa ferramenta multi propósito, que tem ganhando destaque, pois apresenta desempenho, estabilidade e escalabilidade, é altamente recomendada para processamento de dados por streaming, que é o exemplo que vamos tratar nesse artigo.

O objetivo desse artigo é abordar um dos temas mais quentes no momento relacionado a Big Data e Analytics: processamento e análise de dados por streaming.
Tratar dados por streaming, ou seja, em tempo real, é uma das demandas mais requisitadas do momento, pois a necessidade de tomar decisões sobre dados que são muito voláteis ou em sistemas críticos, tem aumentado consideravelmente. Assim problemas que antes eram tratados apenas por processamento em batch, agora ganham a necessitada de se ter mais uma camada, a de streaming.
A imagem abaixo se trata da arquitetura de Big Data chamadad Kappa, onde exemplifica o que foi mencionado anteriormente, existindo uma camada para tratar dados por batch (Batch Layer), ou seja, processamento de dados mais pesados, histórico e de forma agendada. E outra camada para processamento de dados de forma rápida e em tempo real, no caso streaming (Speed Layer), que permite processamento e análise dos dados com menor delay.

Mais e o tal de Kafka no titulo do artigo?
Conforme o site oficial do Kafka:
“Apache Kafka é uma plataforma distribuída de mensagens e streaming”.
O Kafka é mais conhecido por ser uma ferramenta de mensageira, porém conforme a sua documentação e a experiência que adquirimos ao utilizá-lo, descobrimos que ele vai muito além, contendo uma arquitetura robusta para prover streaming de dados com segurança, desempenho, disponibilidade e escalabilidade.
Para entender melhor o Kafka, vamos a alguns conceitos sobre ele:
- Mensagens (Messages): trata-se dos dados que serão transmitidos através do Kafka, normalmente são mensagens de textos que podem ser traduzidas em diversos formatos, como JSON e XML.
- Tópicos (Topic): é o canal por onde é feito a troca dos dados entre os interessados, no caso produtores e consumidores das mensagens.
- Produtores (Producer): trata-se de quem está produzindo as mensagens em um determinado tópico de interesse.
- Consumidores (Consumer): trata-se de quem está consumindo as mensagens que são publicadas em um determinado tópico.
- Servidor (Broker): é o próprio Kafka em execução, como ele é distribuído, pode ser uma ou mais instâncias executando em um ou mais servidores.

Algo interessante de se destacar, é que os tópicos do Kafka, são divididos em partições (Partition) conforme a imagem acima. Essas partitions além de ser replicas dos dados existentes nos tópicos, limita a quantidade de consumers que aquele tópico pode ter, ou seja, se o tópico for configurado com três partições, suportará apenas três consumidores naquele tópico de forma simultânea.
Com os conceitos discutidos, podemos resumir que o Kafka é um plataforma ideal quando se quer transformar e mover grandes quantidades de dados entre sistemas e em tempo real.
Vamos a um exemplo prático!
Partiremos agora para a melhor parte, que é ver o Apache Kafka em ação!
Para fixar os conceitos e fazer algo que depois possa até ser reaproveitado, vamos utilizar o Kafka como forma de trocar mensagens entre uma aplicação (no caso o producer) que colhe dados da rede social Twitter, no caso os tweets, contendo um determinado texto que vamos definir e outra aplicação (agora o consumer) que recebe esses dados do Kafka, e faz uma análise em tempo real
desses tweets. Simples assim!
A aplicação Consumer e Producer se trata de um script escrito em Python. E o ambiente contento o Broker do Kafka, será feito através de container, com a utilização do Docker e do Docker Compose.
Executando o Kafka
Primeiramente vamos ao arquivo Docker Compose (docker-compose.yml) para executar uma instância (Broker) do Kafka.
O arquivo YAML do Kafka tem praticamente duas partes, que são os dois serviços que precisamos. Primeiro será declarado o Zookeeper, que é um projeto da Apache, onde o Kafka se utiliza dele para basicamente guardar e gerenciar configurações.
A parte do Zookeeper é declarada da seguinte forma:
E a segunda parte, é a declaração do próprio Kafka, que é feita da seguinte forma:
O arquivo docker-compose.yml do Kafka completo fica assim:
Conforme configuramos no arquivo do Docker Compose, o Kafka será executado na porta 9092, é por ela que vamos ter acesso e interagir com ele através das nossas aplicações.
Aplicações em Python
Producer
Primeiramente vamos escrever a nossa aplicação que vai coletar dados do Twitter conforme um texto pré definido, e a cada tweet coletado, será produzido uma nova mensagem em um determinado tópico no Kafka.
O código completo do nosso Producer fica assim:
No código acima, importamos algumas bibliotecas que são detalhadas logo abaixo:
- datetime: será utilizada para capturar a data e hora do momento, adicionando essa informação aos nossos dados.
- tweepy: biblioteca responsável por realizar a comunicação entre nossa aplicação e o Twitter. Ela pode ser instalada com o comando: pip install tweepy.
- dumps: biblioteca contida dentro da biblioteca json, vamos utilizar para transformar objetos para o formato JSON.
- KafkaProducer: biblioteca contida dentro da biblioteca kafka, é o módulo responsável por publicar mensagens em um tópico no Kafka. Ela pode ser instalada com o comando: pip install kafka-python.
Após importar todas as bibliotecas que iremos utilizar, o próximo passo é configurar as chaves de acesso a API do Twitter. Essas chaves podem ser adquiridas na plataforma de desenvolvedor do Twitter.
Logo após vamos realizar a configuração do Kafka, indicando qual o servidor e o tópico em que queremos acessar e publicar. Para este exemplo o servidor está local e na porta padrão, que é 9092, montado o link localhost:9092. O tópico terá o nome de artigo-medium. E depois disso podemos instanciar o objeto producer, para produzir as mensagens.
O próximo passo é o processo de configuração e autenticação com o Twitter, é neste passo que usamos as chaves declaradas anteriormente. Neste ponto é importante destacar, que declaramos qual a palavra chave que vamos procurar os tweets, para este exemplo, foi escolhido o termo machine learning, assim vamos realizar um crawler no Twitter e filtrar apenas os que contém esse termo nos tweets.
Por fim, declaramos um laço, que ficará escutando os novos tweets que chegam, e dentro do seu corpo, montamos um objeto JSON com o tweet e a data mais a hora do momento, e assim publicamos a mensagem no tópico do Kafka.
O nosso producer está pronto e funcionando, e ao ser executado, ele começará a fazer o crawler no Twitter e publicar no Kafka conforme o tópico que indicamos.
Consumer
O código do Consumer é mais simples, e o que vamos fazer, é ler as mensagens que chegam no tópico artigo-medium, concatenar com as anteriores e assim gerar uma nuvem de palavras, destacando assim quais foram as principais palavras twittadas sobre o assunto que escolhemos. Essa análise é feita em tempo real, pois estamos escutando o tempo todo e atualizando a nuvem de palavras assim que chega um novo tweet coletado.
O código completo do consumer fica da seguinte forma:
As bibliotecas que foram utilizadas para o consumer são as seguintes:
- WordCloud: é utilizada para gerar a nossa nuvem de palavras. Ela pode ser instalada com o comando: pip install wordcloud.
- pyplot: biblioteca dentro do matplotlib, é utilizada para renderizar gráficos dos mais variados tipos.
- json: vamos utilizar para converter a nossa string recebida pelo Kafka para o formato JSON.
- clear_output: será utilizada para limpar o console, para que possamos imprimir uma nuvem de palavras atualizada.
- KafkaConsumer: módulo da biblioteca kafka, e será utilizada para consumir os dados de um tópico do Kafka.
Depois da importação das bibliotecas, precisamos apenas configurar o Kafka e montar a lógica para que a nossa aplicação fique escutando novas mensagens publicadas e atualize a nuvem de palavras.
O resultado do nosso exemplo será algo parecido com a imagem abaixo. Sendo que será atualizada constantemente conforme as novas palavras dos tweets.

Conclusão
Utilizamos um exemplo simples, porém atingimos o objetivo, que era o de processar e analisar dados por streaming com o Kafka através de aplicações feitas em Python.
O Kafka é uma poderosa ferramenta e tem ganhado destaque no mundo de desenvolvimento de software de forma geral, pois possui funcionalidades interessantes, mas além disso é segura, facilmente escalável e gerenciado.
O código completo do exemplo apresentado neste artigo, pode ser encontrado no meu github.
