Ferramentas para Pipelines de Dados em Tempo Real e Streaming com Apache Kafka

Introdução

O que é o Apache Kafka?

O Apache Kafka é uma plataforma distribuída de streaming de eventos usada para criar pipelines de dados em tempo real e sistemas de streaming. Ele é projetado para lidar com grandes volumes de dados, garantindo alta disponibilidade e escalabilidade.

Kafka é amplamente utilizado em aplicações que demancam processamendo de dados em tempo real, como monitoramento de sistemas, análises em tempo real, integração de microserviços e processamento de logs.

Apache Kafka em Linguagem Simples

Imagina que você está organizando um sistema de entrega de mensagens entre pessoas, como um serviço de correio rápido. O Apache kafka funciona como esse serviço: ele pega mensagens (dados), organiza tudo direitinho, e entrega onde for necesário - tudo isso em alta velocidade e sem perder nenhuma informação no caminho.

De forma prática, o kafka é uma ferramenta que ajuda empresas e sistemas a trocar informações em tempo real, como quando você manda um pedido de comida pelo aplicativo e ele precisa informar o restaurante, o entregador e você, tudo ao mesmo tempo.

Ele é ótimo para lidar com muitas informações de uma vez, como:

Monitorar se servidores de um site estão funcionando.
Processar dados enquanto eles estão chegando.
Fazer diferentes sistemas, como aplicativos e bancos de dados, trabalharem juntos sem precisar esperar um pelo outro.

Em suma, o kafka é como um grande organizador de mensagens, garantindo que tudo chegue ao destino certo, na hora certa, mesmo quando há uma enxurrada de informações.

Objetivos deste tutorial

Apresentar os conceitos básicos do Apache Kafka.
Demonstrar como configurar e usar kafka para pipelines de dados em tempo real.
Exemplificar casos de uso com código prático.

Pré-requisitos

Conhecimentos básicos de fluxos de dados
Conhecimento de Python
Docker

Conceitos Básicos do Apache Kafka

Principais Componentes

Produtores (Producers): Enviam mensagens para tópicos no Kafka
Consumidores (Consumers): Lêem mensagens dos tópicos.
Tópicos (Topics): Estruturas de armazenamento onde as mensagens são organizadas.
Brokers: Nós que armazenam e gerenciam os dados no cluster.
Zookeeper: Coordena o cluster

Fluxo de Dados no Kafka

O produtor publica mensagens em um tópico.
O kafka distribui essas mensagens para os brokers.
O consumidor consome as mensagens em tempo real ou conforme necessário.

Instalando o Apache Kafka usando Docker

Para configurar rapidamente o kafka, podemos usar o Docker Compose.

Crie um arquivo docker-compose.yml

services:
    zookeeper:
      image: zookeeper
      ports:
        - "2181:2181"

    kafka:
      image: wurstmeister/kafka:2.12-2.5.0
      ports:
        - "9092:9092"
      depends_on:
        - zookeeper
      environment:
        KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
        KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: INSIDE:PLAINTEXT,OUTSIDE:PLAINTEXT
        KAFKA_LISTENERS: INSIDE://0.0.0.0:9092,OUTSIDE://0.0.0.0:29092
        KAFKA_ADVERTISED_LISTENERS: INSIDE://kafka:9092,OUTSIDE://localhost:29092
        KAFKA_INTER_BROKER_LISTENER_NAME: INSIDE
    
    kafka-web:
      image: tchiotludo/akhq
      ports:
        - "8081:8080"
      environment:
        AKHQ_CONFIGURATION: |
          akhq:
            connections:
              docker-kafka-server:
                properties:
                  bootstrap.servers: "kafka:9092"
      depends_on:
        - kafka

2. Inicie os serviços:

Observe que, ao iniciar os serviços, três componentes principais serão configurados:

Zookeeper: Responsável por coordenar e gerenciar a configuração e o funcionamento dos tópicos e do cluster Kafka.
Servidor Kafka: O núcleo da plataforma, que gerencia o envio, armazenamento e consumo de mensagens entre produtores e consumidores.
Kafka UI: Uma interface gráfica intuitiva que facilita a visualização, monitoramento e gerenciamento de tópicos, mensagens e consumidores no Kafka.

Esses três serviços servirão em conjunto para oferecer um ambiente acessível para o prosseguimento dessa tutorial.

Para isso, rode o comando:

docker compose up -d

Após isso, verifique se o kafka está funcionando ao listar os serviços em execução:

docker ps

Exemplo Prático: Produção e Consumo de Mensagens

Produzindo Mensagens com Kafka

Usaremos a CLI do kafka para criar tópicos e produzir mensagens.

Criar um tópico:

docker exec -it kafka /opt/kafka/bin/kafka-topics.sh --create --topic meu-primeiro-topico --bootstrap-server localhost:29092 --partitions 1 --replication-factor 1

Produzir nensagens:

docker exec -it kafka-kafka-1 /opt/kafka/bin/kafka-console-producer.sh --topic meu-primeiro-topico --bootstrap-server localhost:29092

Consumir mensagens

docker exec -it kafka /opt/kafka/bin/kafka-console-consumer.sh --topic meu-topico --bootstrap-server localhost:29092 --from-beginning

Integração com Linguagens de Programação

Exemplo em Python

Vamos usar a biblioteca confluent-kafka para interagir com o kafka.

Instale a biblioteca
```
pip install confluent-kafka
```

Produtor em Python

from confluent_kafka import Producer

producer_conf = {
    'bootstrap.servers': 'localhost:29092'
}

producer = Producer(producer_conf)

def produce_message():

    topic = "Meu-segundo-topico"

    def delivery_report(err, msg):
        if err is not None:
            print(f"Erro ao enviar mensagem: {err}")
        else:
            print(f"Mensagem enviada para {msg.topic()} [{msg.partition()}]")

    for i in range(10):
        producer.produce(topic,
                        key=None,
                        value=f'mensagem {i}'.encode('utf-8'),
                        callback=delivery_report
                        )
        producer.flush()


produce_message()

Consumidor em Python

from confluent_kafka import Consumer

consumer_conf = {
    'bootstrap.servers': 'localhost:29092',
    'group.id': "kafka-consumer",
    'auto.offset.reset': 'earliest'
}

consumer = Consumer(consumer_conf)

def consume_messages():
    print("Consumidor iniciado...")
    topic = "Meu-segundo-topico"
    consumer.subscribe([topic])

    while True:
        msg = consumer.poll(1.0)  # Espera 1 segundo por uma mensagem
        if msg is None:
            continue
        if msg.error():
            print(f"Erro ao consumir mensagem: {msg.error()}")
            continue

        # Decodifica a mensagem como string
        print(f"Mensagem recebida: {msg.value().decode('utf-8')}")

consume_messages()

Casos de Uso do Apache Kafka

Processamento de Logs: Centralizar e processar logs de sistemas em tempo real.
Integração de Microserviços: Comunicação assíncrona entre serviços.
Análise em Tempo Real: Construção de pipelines com kafka Streams ou integrações com Spark.

Conclusão

O Apache Kafka é uma ferramenta poderosa para pipelines de dados em tempo real e streaming.

Espero que esse tutorial ajude você a entender e quem sabe começar a usar o kafka em seus projetos.

Explore mais funcionalidades como kafka Connect, Kafka Streams e integrações com sistemas de Big Data.