Criando Regras no EventBridge com AWS Lambda em Python [Passo a Passo]

Por

Bem-vindos a este tutorial de AWS, onde vamos ensinar como criar um Rule EventBridge dinâmico utilizando Lambda Python. Este guia passo a passo é perfeito para quem deseja automatizar processos na AWS e aprender a integrar serviços como EventBridge e Lambda. Durante o tutorial, abordaremos cada etapa detalhadamente, desde a configuração inicial na AWS até a criação efetiva de uma Rule no EventBridge com Python.

Este conteúdo é ideal para desenvolvedores AWS, engenheiros de cloud e entusiastas de automação com Python. Embora algum conhecimento prévio em AWS e Python seja útil, ele não é obrigatório, pois explicaremos tudo de forma clara e acessível.

O que é EventBridge e Lambda Python?

O Amazon EventBridge é um serviço da AWS que permite criar regras de eventos para filtrar e encaminhar eventos para diferentes alvos, como funções Lambda, facilitando a automação de workflows na nuvem. Já o AWS Lambda com Python é um serviço de computação sem servidor que permite executar código sem a necessidade de gerenciar infraestrutura.

Vamos à implementação!

Código da lambdaacionadora (Substitua a string “REGIAO” por sua região AWS, e a string “ID_DA_CONTA” pelo id da sua conta AWS):

 import json
 import boto3

def lambda_handler(event, context):
    client = boto3.client('events')
    lambda_client = boto3.client('lambda')
 rulename = "regra-eventbridge-aciona-lambda"
    # Cria a regra no EventBridge
    response = client.put_rule(
        Name=rulename,
        ScheduleExpression='rate(1 minute)',
        State='ENABLED',
        Description="Rule criada via Lambda",
        RoleArn='arn:aws:iam::ID_DA_CONTA:role/rolelambdaexecutora'
    )

    # Captura o ARN da regra criada
    rule_arn = response['RuleArn']
    
    # Define os parâmetros para o alvo da regra
    parameters = {
        "key1": "value1"
    }
    # Define o alvo da regra (lambdaexecutora)
    targets = [
        {
            'Arn': 'arn:aws:lambda:REGIAO:ID_DA_CONTA:function:lambdaexecutora',
            'Id': 'name-extraction',
            'Input': json.dumps(parameters)
        }
    ]
    # Associa o alvo à regra
    response = client.put_targets(
        Rule=rulename,
        Targets=targets
    )
    adicionar_permissao_para_regra(rule_arn, rulename)
    return {
        'statusCode': 200,
        'body': {
            'rule_arn': rule_arn
        }
    }

def adicionar_permissao_para_regra(rule_arn, rulename):
    try:
		lambda_client = boto3.client('lambda')
		 response = lambda_client.add_permission(
		 FunctionName='arn:aws:lambda:REGIAO:ID_DA_CONTA:function:lambdaexecutora',
		 StatementId=rulename,
		 Action='lambda:InvokeFunction',
		 Principal='events.amazonaws.com',
		 SourceArn=rule_arn
		 )
		 print("Permissão adicionada com sucesso!")
		 print(response)
		 except Exception as e:
		 print(f"Erro ao adicionar permissão: {e}")

Código da lambdaexecutora (Código muito simples apenas para testar a chegada dos
parâmetros via event):

import json

def lambda_handler(event, context):
	print(event)
	return {
		'statusCode': 200,
		'body': json.dumps(event)
	}

Para que a lambdaacionadora tenha acesso ao EventBrdige, precisamos criar uma Role/Policy e
associa-la à lambdaacionadora.

Inicialmente, vamos criar a policy, responsável por conter todos os acessos que serão
concedidos a lambdaacionadora.

Crie duas policys com os nomes “policylambdaacionadora” e “policylambdaexecutora” (se não
souber como criar roles/policys, clique aqui para ver o passo a passo). Estas policys serão as responsáveis por prover as permissões necessárias que as lambdas precisarão para execução do processo com sucesso.

JSON com as permissões que devem está contidas nesta policy policylambdaacionadora:

{
	"Version": "2012-10-17",
	"Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "events:PutTargets",
                "events:PutRule"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "arn:aws:iam::339713056087:role/rolelambdaexecutora"
        },
        {
            "Effect": "Allow",
            "Action": [
                "lambda:InvokeFunction",
                "lambda:AddPermission"
            ],
            "Resource": "arn:aws:lambda:us-east-1:339713056087:function:lambdaexecutora"
        },
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogGroup",
                "logs:CreateLogStream",
                "logs:PutLogEvents",
                "lambda:AddPermission"
            ],
            "Resource": [
                "arn:aws:logs:*:*:*",
                "arn:aws:lambda:us-east-1:339713056087:function:lambdaexecutora"
            ]
        }
    ]
}

JSON com as permissões que devem está contidas nesta policy policylambdaexecutora:

{
	"Version": "2012-10-17",
	"Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "lambda:InvokeFunction",
                "lambda:AddPermission"
            ],
            "Resource": "arn:aws:lambda:us-east-1:339713056087:function:lambdaexecutora"
        },
        {
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "arn:aws:iam::339713056087:role/rolelambdaexecutora"
        },
        {
            "Effect": "Allow",
            "Action": [
                 "logs:CreateLogGroup",
                 "logs:CreateLogStream",
                 "logs:PutLogEvents"
               ],
               "Resource": "arn:aws:logs:*:*:*"
        }
    ]
}

Após a criação das policys, precisamos criar as roles e associarmos as policys. Para tal, crie duas
roles com os nomes “rolelambdaacionadora” e “rolelambdaexecutora” (se não souber como
criar roles/policys, clique aqui para ver o passo a passo).

JSON do Trust relationship da role rolelambdaacionadora:

 {
	 "Version": "2012-10-17",
	 "Statement": [
		{
			 "Effect": "Allow",
			 "Principal": {
			 "Service": [
				 "events.amazonaws.com",
				 "lambda.amazonaws.com",
				 "scheduler.amazonaws.com"
				]
			 },
			 "Action": "sts:AssumeRole"
		 }
	 ]
 }

JSON do Trust relationship da role rolelambdaexecutora:

 {
	 "Version": "2012-10-17",
	 "Statement": [
		{
			 "Effect": "Allow",
			 "Principal": {
			 "Service": [
				 "events.amazonaws.com",
				 "lambda.amazonaws.com",
				 "scheduler.amazonaws.com"
				]
			 },
			 "Action": "sts:AssumeRole"
		 }
	 ]
 }

Associete a “policylambdaacionadora” à “rolelambdaacionadora”, e a “policylambdaexecutora”
à “rolelambdaexecutora”.

Agora é só executar um teste a partir da “lambdaacionadora”. Se tudo ocorrer bem, será criado
uma rule dentro do eventbridge com alvo para o ARN da lambdaexecutora e parâmetros que
serão enviados para ela. Quando a lambdaexecutora for acionada, o log registrará os
parâmetros que ela recebeu do EventBrdige.

Por que Utilizar EventBridge e Lambda Python?

A combinação de EventBridge e Lambda Python é poderosa para automatizar tarefas na AWS, como processamento de eventos, integração de serviços e execução de workflows complexos. Com este tutorial, você estará preparado para implementar soluções escaláveis e eficientes na nuvem.

Conclusão

Este tutorial de AWS oferece um guia completo para criar um Rule EventBridge dinâmico com Lambda Python. Se você está buscando aprender AWS, automatizar processos na nuvem ou aprofundar seus conhecimentos em Python, este conteúdo é para você. Siga os passos, pratique e domine a integração de EventBridge e Lambda para criar soluções incríveis na AWS.

Deixe um comentário