A jornada de desenvolvimento event-driven com Amazon EventBridge

Por Rafael Conceição, Site Reliability Engineer no Itaú

Vamos conversar um pouco sobre arquitetura na tecnologia? Hoje, vamos mergulhar no conceito de desenvolvimento event-driven — ou em português, arquitetura orientada à eventos.

Essa arquitetura utiliza eventos para o acionamento e comunicação entre serviços desacoplados em aplicações modernas criadas, por exemplo, com microsserviços. Nesse caso, um evento caracteriza uma mudança ou atualização no estado, como um item que você adiciona no seu carrinho no momento de compra de um site.

Vale lembrar que as arquiteturas orientadas por eventos têm três componentes: os produtores, os roteadores e os consumidores de eventos. Nessa estrutura, uma característica marcante é que “Produtores” e “Consumidores” devem estar completamente dissociados, ou seja, um produtor não deve saber ou se importar com quem está consumindo seus eventos.

Representação do fluxo de uma arquitetura orientada a eventos. Do lado esquerdo, três retângulos representam os produtores, enquanto no meio um retângulo maior representa o roteador. Na direita, dois retângulos representam os consumidores.

Neste artigo, iremos abordar o conceito em mais detalhes, explorar como a ferramenta Amazon EventBridge se encaixa nesse contexto e apresentar um hands-on para aprender na prática como aplicá-lo.

Amazon EventBridge

O Amazon EventBridge é um serviço que oferece acesso em tempo real às alterações de dados em serviços da AWS, suas aplicações e aplicações de software como serviço (SaaS), sem precisar escrever um código. Para começar, você pode escolher uma origem de eventos no console do EventBridge. Em seguida, pode selecionar um destino entre os serviços da AWS, incluindo o AWS Lambda, o Amazon Simple Notification Service (SNS) e o Amazon Kinesis Data Firehose. O EventBridge entregará automaticamente os eventos quase em tempo real.

Em resumo, com o uso da ferramenta você pode receber, filtrar, transformar, rotear (dos Produtores) e entregar esses eventos a Consumidores. Então, bora trabalhar com ela?

Para exemplificar o uso do Amazon EventBridge, vamos utilizar um exemplo em que gostaríamos que uma AWS Lambda fosse executada para adicionar uma determinada tag à instância toda vez que uma instância de banco de dados do AWS RDS for criada.

Utilizaremos então a seguinte arquitetura:

Como Produtor de eventos, utilizaremos o CloudTrail. Como Roteador, que irá tratar os eventos, utilizaremos o EventBridge. Já como Consumidor desses eventos, utilizaremos a AWS Lambda.

Passo 1: configurando e utilizando o CloudTrail

Pré-requisito: É preciso que a conta possua um Trail configurado no CloudTrail. Saiba como configurar em criar uma trilha para a sua conta da AWS.

O CloudTrail proporciona visibilidade sobre as atividades de usuários por meio do registro das ações executadas na sua conta.

Ele registra informações importantes sobre cada ação, como quem fez a solicitação, quais serviços foram usados, quais ações foram executadas, quais os parâmetros da ação e quais elementos da resposta foram retornados pelo serviço da AWS, além de gerar eventos no formato JSON e possuir integração nativa com o EventBridge. Sendo assim, nosso Produtor de eventos.

Passo 2: configurando regras para monitoração de eventos

Agora, devemos configurar uma regra no EventBridge Rules para monitorar os eventos desejados. Em nosso caso o padrão de evento (event pattern) será a própria AWS, tendo como origem o Cloudtrail — e nele, os eventos relacionados ao rds.amazonaws.com com nome CreateDBInstance. Veja no exemplo:

Agora, veja o exemplo de código Terraform para criação da regra:

###### EVENTBRIDGE RULE - CREATED RDS INSTANCE ######
resource "aws_cloudwatch_event_rule" "rds_event_rule" {
  name          = "rule-rds-created"
  description   = "Triggers Lambda when new RDS instance are created"
  is_enabled    = true
  event_pattern = <<EOF
    {
    "source": ["aws.rds"],
    "detail-type": ["AWS API Call via CloudTrail"],
    "detail": {
        "eventSource" : ["rds.amazonaws.com"],
        "eventName": ["CreateDBInstance"]
    }
    }
  EOF
}

Passo 3: encaminhando nosso evento ao Consumidor

Agora precisamos encaminhar nosso evento para o Consumidor (Alvo), que será uma Lambda. Lembrando que a definição de um Alvo é ser recurso ou endpoint que a EventBridge envia um evento, quando esse evento corresponde ao padrão definido em uma regra. Essa regra processa os dados do evento e envia as informações pertinentes ao Alvo.

Podemos encaminhar esse mesmo evento para até cinco Alvos, como quando enviamos um e-mail através do AWS SNS informando que uma instancia RDS foi criada, além de executar a Lambda que adiciona a tag. Podemos, inclusive, enviar o evento originalmente como foi gerado, ou enviar somente uma parte do evento, ou fazer alguma edição no evento antes de enviar e enviar um json de evento fixo. Confira no exemplo:

Exemplo de código Terraform para criação do Target:

###### EVENTBRIDGE TARGET - CREATED RDS INSTANCE ######
resource "aws_cloudwatch_event_target" "lambda_rule_rds" {
  depends_on = [aws_lambda_function.autotag]
  rule       = aws_cloudwatch_event_rule.rds_event_rule.name
  target_id  = "SendToLambda"
  arn        = aws_lambda_function.autotag.arn
}

Passo 4: conectando a arquitetura com o Consumidor

Chegamos ao passo final que é termos o nosso Consumidor. Para nosso cenário criamos um script Python e uma Lambda para adicionar a Tag a instancia de RDS criada.

Script em Python que cria a tag:

"""Add tags on RDS and Aurora."""
import logging
import os
import boto3
from botocore.exceptions import ClientError

# Config Logging.
log = logging.getLogger()
log.setLevel(logging.INFO)

def lambda_handler(event, context):
    """Add tags on RDS and Aurora"""

    # Define the tags to add to the RDS instance
    tag_key = os.environ.get('TAG_KEY')
    tag_value = os.environ.get('TAG_VALUE')
    tags = [
        {
            'Key': tag_key,
            'Value': tag_value
        }
    ]

    # Connect to RDS service
    rds = boto3.client('rds')
    event_name = event.get("detail").get("eventName")

    if event_name == "CreateDBCluster":
        aurora_arn = event.get("detail").get("responseElements").get("dBClusterArn")
    # Add tags to the Regional Cluster
        try:
            rds.add_tags_to_resource(
                ResourceName=aurora_arn,
                Tags=tags
            )
            log.info('Tag adicionada com sucesso ao Cluster Aurora: %s', aurora_arn)
        except ClientError as error:
            log.exception(error)

    else:
    # Add tags to the RDS instance
        rds_arn = event.get("detail").get("responseElements").get("dBInstanceArn")
        try:
            rds.add_tags_to_resource(
                ResourceName=rds_arn,
                Tags=tags
            )
            log.info('Tag adicionada com sucesso ao RDS: %s', rds_arn)
        except ClientError as error:
            log.exception(error)

Exemplo de código Terraform para criação Lambda:

###### GENERATE PACKAGE LAMBDA ###### 
data "archive_file" "lambda_autotag" {
  type        = "zip"
  source_dir  = "${path.module}/code/src"
  output_path = "${path.module}/code/lambda_package.zip"
}

###### LAMBDA FUNCTION ######
resource "aws_lambda_function" "autotag" {
  function_name    = var.autotag_function_name
  role             = aws_iam_role.lambda_exec_role.arn
  filename         = data.archive_file.lambda_autotag.output_path
  source_code_hash = data.archive_file.lambda_autotag.output_base64sha256
  description      = var.autotag_description
  publish          = true

  runtime       = "python3.8"
  handler       = "main.lambda_handler"
  timeout       = 300
  memory_size   = 128
  architectures = ["arm64"]

  environment {
    variables = {
      TAG_KEY   = var.lambda_tag_key
      TAG_VALUE = var.lambda_tag_value
    }
  }
}

Obs: é necessário ter uma IAM Role que permita adição de tags na instância RDS.

Conclusão

Chegamos ao fim deste artigo e espero que você já consiga entender tanto os benefícios de uma arquitetura orientada por eventos quanto como ela pode ser aplicada na prática com o uso do Amazon EventBridge. A aplicação oferece múltiplas possibilidades simples e consistentes de ingerir, filtrar, transformar e entregar eventos para que você possa criar aplicações rapidamente.

Compartilhe sua experiência no uso da ferramenta nos comentários abaixo e fique sempre atento as novidades por aqui!