Arquitetura orientada a eventos com Kafka: implementando o MSK com Terraform e Python

Neste post, vamos explorar a Arquitetura Orientada a Eventos (EDA, do inglês Event-Driven Architecture) usando o Kafka como espinha dorsal do streaming de eventos, com foco no serviço gerenciado de Kafka (MSK) da AWS. Também vamos ver, passo a passo, como configurar o MSK com Terraform e criar uma aplicação simples em Python que interage com o Kafka para produzir e consumir mensagens.

O que é Arquitetura Orientada a Eventos?

A Arquitetura Orientada a Eventos (EDA) é um padrão de design de software em que os componentes do sistema se comunicam por meio de eventos. Em vez de os componentes chamarem uns aos outros diretamente, eles produzem eventos e reagem a eles. Isso desacopla os componentes, permitindo que os sistemas escalem de forma mais eficiente, lidem com dados em tempo real e se tornem mais resilientes a mudanças.

O Kafka é uma das plataformas mais populares para EDA por causa da sua capacidade de streaming distribuído de eventos. Ele permite que aplicações publiquem e assinem eventos (ou mensagens), que ficam armazenados em tópicos. Essas mensagens podem então ser processadas pelos consumidores a qualquer momento.

Por que usar o Kafka?

• Escalabilidade: o Kafka é altamente escalável, o que o torna adequado para aplicações de grande porte.
• Durabilidade: as mensagens no Kafka são duráveis, ou seja, podem ficar armazenadas pelo tempo que for necessário, mesmo que os consumidores estejam fora do ar.
• Desempenho: o Kafka consegue processar milhões de mensagens por segundo com baixa latência.
• Tolerância a falhas: o Kafka foi construído para lidar com falhas, oferecendo replicação e particionamento para garantir alta disponibilidade.

Serviço gerenciado de Kafka (MSK)

O AWS Managed Streaming for Apache Kafka (MSK) é um serviço totalmente gerenciado que facilita construir e executar aplicações que usam Kafka. Com o MSK, a AWS assume o trabalho operacional de gerenciar e escalar os clusters Kafka, e você pode se concentrar em construir aplicações em vez de cuidar de infraestrutura.

Por que usar o MSK?

• Totalmente gerenciado: a AWS cuida do provisionamento, da escalabilidade e da manutenção dos clusters Kafka.
• Integração: o MSK se integra bem a outros serviços da AWS, como S3, Lambda e CloudWatch.
• Segurança: você pode proteger seus clusters Kafka com IAM, VPCs e criptografia.
• Custo-benefício: o MSK é cobrado com base nos recursos que você usa, o que torna o custo mais previsível.

Configurando o MSK com Terraform

O Terraform facilita definir e provisionar clusters MSK. Veja como configurar um cluster MSK usando Terraform:

Passo 1: Definir o cluster MSK no Terraform

Vamos definir nosso cluster Kafka no Terraform, especificando o número de nós broker, os tipos de instância e as configurações de segurança.

provider "aws" {
  region = "us-east-1"
}

resource "aws_msk_cluster" "kafka_cluster" {
  cluster_name           = "my-kafka-cluster"
  kafka_version          = "2.8.1"
  number_of_broker_nodes = 3

  broker_node_group_info {
    instance_type = "kafka.m5.large"
    client_subnets = [
      aws_subnet.my_subnet1.id,
      aws_subnet.my_subnet2.id,
      aws_subnet.my_subnet3.id
    ]
    security_groups = [aws_security_group.kafka_sg.id]
  }

  encryption_info {
    encryption_at_rest_kms_key_arn = aws_kms_key.kafka_kms_key.arn
  }
  
  logging_info {
    broker_logs {
      cloudwatch_logs {
        enabled   = true
        log_group = aws_cloudwatch_log_group.kafka_log_group.name
      }
    }
  }
}

resource "aws_security_group" "kafka_sg" {
  name        = "kafka-security-group"
  description = "Security group for Kafka brokers"

  ingress {
    from_port   = 9092
    to_port     = 9092
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

resource "aws_kms_key" "kafka_kms_key" {
  description = "KMS key for Kafka encryption"
}

resource "aws_cloudwatch_log_group" "kafka_log_group" {
  name = "/aws/msk/my-kafka-cluster"
}

Passo 2: Implantar a infraestrutura

Execute os comandos a seguir para implantar o cluster MSK na AWS:

terraform init
terraform apply

O Terraform vai provisionar o cluster Kafka, os security groups e a infraestrutura de logs.

Construindo uma aplicação Python para usar o Kafka

Agora que temos o cluster MSK configurado, vamos construir uma aplicação Python que produz e consome mensagens de um tópico Kafka.

Passo 1: Instalar as bibliotecas Python do Kafka

Primeiro, você precisa instalar o kafka-python para interagir com o Kafka a partir do seu código Python:

pip install kafka-python

Passo 2: Script do produtor

O produtor envia mensagens para um tópico Kafka específico. Aqui vai um exemplo simples:

from kafka import KafkaProducer
import json
import time

# Create a Kafka producer
producer = KafkaProducer(
    bootstrap_servers=['<MSK_BROKER>'],
    value_serializer=lambda v: json.dumps(v).encode('utf-8')
)

def produce_messages():
    for i in range(10):
        message = {'event_number': i, 'message': f"This is message {i}"}
        producer.send('my-kafka-topic', message)
        print(f"Produced message {message}")
        time.sleep(1)

if __name__ == "__main__":
    produce_messages()

Neste script:

• Substitua <MSK_BROKER> pelo endpoint do broker do seu MSK.
• O script envia 10 mensagens JSON para o tópico Kafka my-kafka-topic.

Passo 3: Script do consumidor

Agora, vamos criar um consumidor para ler as mensagens do mesmo tópico:

from kafka import KafkaConsumer
import json

# Create a Kafka consumer
consumer = KafkaConsumer(
    'my-kafka-topic',
    bootstrap_servers=['<MSK_BROKER>'],
    value_deserializer=lambda v: json.loads(v.decode('utf-8'))
)

def consume_messages():
    for message in consumer:
        print(f"Consumed message: {message.value}")

if __name__ == "__main__":
    consume_messages()

O consumidor fica escutando novas mensagens no tópico my-kafka-topic e as imprime à medida que chegam.

Considerações finais

Neste post, apresentamos a Arquitetura Orientada a Eventos e exploramos como implementar o Kafka usando o AWS MSK. Com o Terraform, conseguimos configurar clusters Kafka rapidamente e, com Python, construir aplicações que produzem e consomem mensagens. O MSK simplifica o gerenciamento de clusters Kafka e se integra ao ecossistema mais amplo da AWS, o que o torna uma ferramenta poderosa para construir aplicações orientadas a eventos em tempo real.

Agora que você tem um cluster MSK e uma aplicação Python funcionando, pode experimentar escalar o sistema, adicionar mais produtores e consumidores e integrar o Kafka a outros serviços da AWS.

Até o próximo post! =)