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.

Cícero Joasyo Mateus de Moura

Written by

Sou Desenvolvedor Full Stack, cursando Especialização em Big Data e Machine Learning, formado como Bacharel em Sistemas de Informação. Entusiasta de IoT e TA.

Welcome to a place where words matter. On Medium, smart voices and original ideas take center stage - with no ads in sight. Watch
Follow all the topics you care about, and we’ll deliver the best stories for you to your homepage and inbox. Explore
Get unlimited access to the best stories on Medium — and support writers while you’re at it. Just $5/month. Upgrade