Como usar oAWS LambdaCom o Amazon Simple Notification Service

Neste tutorial, você usa uma função do Lambda em uma Conta da AWS para assinar um tópico do Amazon Simple Notification Service (Amazon SNS) em uma Conta da AWS separada. Quando você publica mensagens no seu tópico do Amazon SNS, sua função Lambda lê o conteúdo da mensagem e a envia para o Amazon Logs. CloudWatch Para concluir este tutorial, use o AWS Command Line Interface (AWS CLI).

Para concluir este tutorial, execute as seguintes etapas:

• Na conta A, crie um tópico do Amazon SNS.

• Na conta B, crie uma função do Lambda que leia as mensagens do tópico.

• Na conta B, crie uma assinatura para o tópico.

• Publique mensagens no tópico do Amazon SNS na conta A e confirme se a função Lambda na conta B as envia para Logs. CloudWatch

Ao concluir essas etapas, você aprenderá a configurar um tópico do Amazon SNS para invocar uma função do Lambda. Você também aprenderá como criar uma política do AWS Identity and Access Management (IAM) que dá permissão para um recurso em outra Conta da AWS para invocar o Lambda.

No tutorial, você usa duas Contas da AWS separadas. Os comandos da AWS CLI ilustram isso usando dois perfis nomeados accountA e accountB, cada um configurado para uso com uma Conta da AWS.diferente. Para saber como configurar a AWS CLI para usar perfis diferentes, consulte Configurações de arquivos de configuração e credenciais no AWS Command Line InterfaceGuia do usuário para a versão 2. Certifique-se de configurar o mesmo padrão de Região da AWS para ambos os perfis.

Se os perfis da AWS CLI criados para as duas Contas da AWS usarem nomes diferentes, ou se você usa o perfil padrão e um perfil nomeado, modifique os comandos da AWS CLI nas seguintes etapas, conforme necessário.

Pré-requisitos

Cadastrar-se em uma Conta da AWS

Se você ainda não tiver uma Conta da AWS, siga as etapas a seguir para criar uma.

Como cadastrar-se para uma Conta da AWS

1. Abra https://portal.aws.amazon.com/billing/signup.

2. Siga as instruções on-line.

   Parte do procedimento de cadastramento envolve o recebimento de uma chamada telefônica e a inserção de um código de verificação no teclado do telefone.

   Quando você se cadastra para uma Conta da AWS, um Usuário raiz da conta da AWS é criado. O usuário raiz tem acesso a todos os Serviços da AWS e atributos na conta. Como prática recomendada de segurança, atribua acesso administrativo a um usuário administrativo e utilize somente o usuário raiz para executar as tarefas que exigem acesso do usuário raiz.

A AWS envia um e-mail de confirmação depois que o processo de cadastramento é concluído. A qualquer momento, é possível visualizar as atividades da conta atual e gerenciar sua conta acessando https://aws.amazon.com/ e selecionando Minha conta.

Criar um usuário administrativo

Depois de se inscrever em uma Conta da AWS, proteja seu Usuário raiz da conta da AWS, habilite o AWS IAM Identity Center e crie um usuário administrativo para não usar o usuário raiz em tarefas cotidianas.

Proteção da Usuário raiz da conta da AWS

1. Faça login no AWS Management Console como o proprietário da conta ao escolher a opção Usuário raiz e inserir o endereço de e-mail da Conta da AWS. Na próxima página, insira a senha.

   Para obter ajuda ao fazer login usando o usuário raiz, consulte Fazer login como usuário raiz no Guia do usuário do Início de Sessão da AWS.

2. Ative a autenticação multifator (MFA) para o usuário raiz.c

   Para obter instruções, consulte Ativar um dispositivo MFA virtual para o usuário raiz da Conta da AWS (console) no Guia do usuário do IAM.

Criar um usuário administrativo

1. Habilitar o IAM Identity Center.

   Para obter instruções, consulte Enabling AWS IAM Identity Center no Manual do Usuário do AWS IAM Identity Center.

2. No Centro de Identidade do IAM, conceda acesso administrativo a um usuário administrativo.

   Para ver um tutorial sobre como usar o Diretório do Centro de Identidade do IAM como fonte de identidade, consulte Configure user access with the default Diretório do Centro de Identidade do IAM no Manual do Usuário do AWS IAM Identity Center.

Login como usuário administrativo

• Para fazer login com o usuário do Centro de Identidade do IAM, utilize o URL de login enviado ao seu endereço de e-mail quando você criou o usuário do Centro do Usuário do IAM.

  Para obter ajuda com o login utilizando um usuário do Centro de Identidade do IAM, consulte Fazer login no portal de acesso da AWS, no Guia do usuário do Início de Sessão da AWS.

Instalar a AWS Command Line Interface

Se você ainda não instalou a AWS Command Line Interface, siga as etapas em Instalar ou atualizar a versão mais recente da AWS CLI para instalá-la.

O tutorial requer um terminal de linha de comando ou um shell para executar os comandos. No Linux e no macOS, use o gerenciador de pacotes e de shell de sua preferência.

nota

No Windows, alguns comandos da CLI do Bash que você costuma usar com o Lambda (como zip) não são compatíveis com os terminais integrados do sistema operacional. Para obter uma versão do Ubuntu com o Bash integrada no Windows, instale o Subsistema do Windows para Linux.

Criar um tópico do Amazon SNS (conta A)

Para criar um tópico do

• Na conta A, crie um tópico padrão do Amazon SNS usando o comando da AWS CLI a seguir.

  aws sns create-topic --name sns-topic-for-lambda --profile accountA

  Você deve ver saída semelhante ao seguinte:

  {
      "TopicArn": "arn:aws:sns:us-west-2:123456789012:sns-topic-for-lambda"
  }

  Anote o nome do recurso da Amazon (ARN) do seu tópico. Você precisará dele posteriormente no tutorial ao adicionar permissões à sua função do Lambda para assinar o tópico.

Criar uma função de execução da função (conta B)

Uma função de execução é um perfil do IAM que concede a uma função do Lambda permissão para acessar serviços e recursos da AWS. Antes de criar sua função na conta B, você cria um papel que dá à função permissões básicas para gravar registros no CloudWatch Logs. Adicionaremos as permissões para ler seu tópico do Amazon SNS em uma etapa posterior.

Para criar uma função de execução

1. Na conta B, abra a página de perfis no console do IAM.

2. Selecione Criar função.

3. Em Tipo de entidade confiável, escolha Serviços da AWS.

4. Em Caso de uso, escolha Lambda.

5. Escolha Próximo.

6. Adicione uma política de permissões básica para o perfil ao fazer o seguinte:

   1. Na caixa de pesquisa Políticas de permissões, insira AWSLambdaBasicExecutionRole.

   2. Escolha Próximo.

7. Finalize a criação do perfil fazendo o seguinte:

   1. Em Detalhes do perfil, insira lambda-sns-role para Nome do perfil.

   2. Selecione Criar função.

Criar uma função Lambda (conta B)

Criar uma função do Lambda que processe suas mensagens do Amazon SNS. O código da função registra o conteúdo da mensagem de cada registro no Amazon CloudWatch Logs.

Este tutorial usa o runtime do Node.js 18.x, mas também fornecemos exemplos de arquivos em outras linguagens de runtime. Você pode selecionar a guia na caixa a seguir para ver o código do runtime do seu interesse. O JavaScript código que você usará nesta etapa está no primeiro exemplo mostrado na JavaScriptguia.

.NET

AWS SDK for .NET

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos Exemplos sem servidor.

Consumir um evento do SNS com o Lambda usando .NET.

using Amazon.Lambda.Core;
using Amazon.Lambda.SNSEvents;


// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]

namespace SnsIntegration;

public class Function
{
    public async Task FunctionHandler(SNSEvent evnt, ILambdaContext context)
    {
        foreach (var record in evnt.Records)
        {
            await ProcessRecordAsync(record, context);
        }
        context.Logger.LogInformation("done");
    }

    private async Task ProcessRecordAsync(SNSEvent.SNSRecord record, ILambdaContext context)
    {
        try
        {
            context.Logger.LogInformation($"Processed record {record.Sns.Message}");

            // TODO: Do interesting work based on the new message
            await Task.CompletedTask;
        }
        catch (Exception e)
        {
            //You can use Dead Letter Queue to handle failures. By configuring a Lambda DLQ.
            context.Logger.LogError($"An error occurred");
            throw;
        }
    }
}

Go

SDK for Go V2

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos Exemplos sem servidor.

Consumir um evento do SNS com o Lambda usando Go.

package main

import (
	"context"
	"fmt"

	"github.com/aws/aws-lambda-go/events"
	"github.com/aws/aws-lambda-go/lambda"
)

func handler(ctx context.Context, snsEvent events.SNSEvent) {
	for _, record := range snsEvent.Records {
		processMessage(record)
	}
	fmt.Println("done")
}

func processMessage(record events.SNSEventRecord) {
	message := record.SNS.Message
	fmt.Printf("Processed message: %s\n", message)
	// TODO: Process your record here
}

func main() {
	lambda.Start(handler)
}

Java

SDK para Java 2.x

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos Exemplos sem servidor.

Consumir um evento do SNS com o Lambda usando Java.

package example;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.SNSEvent;
import com.amazonaws.services.lambda.runtime.events.SNSEvent.SNSRecord;


import java.util.Iterator;
import java.util.List;

public class SNSEventHandler implements RequestHandler<SNSEvent, Boolean> {
    LambdaLogger logger;

    @Override
    public Boolean handleRequest(SNSEvent event, Context context) {
        logger = context.getLogger();
        List<SNSRecord> records = event.getRecords();
        if (!records.isEmpty()) {
            Iterator<SNSRecord> recordsIter = records.iterator();
            while (recordsIter.hasNext()) {
                processRecord(recordsIter.next());
            }
        }
        return Boolean.TRUE;
    }

    public void processRecord(SNSRecord record) {
        try {
            String message = record.getSNS().getMessage();
            logger.log("message: " + message);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

}

JavaScript

SDK para JavaScript (v2)

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos Exemplos sem servidor.

Consumindo um evento do SNS com o JavaScript Lambda usando.

exports.handler = async (event, context) => {
  for (const record of event.Records) {
    await processMessageAsync(record);
  }
  console.info("done");
};

async function processMessageAsync(record) {
  try {
    const message = JSON.stringify(record.Sns.Message);
    console.log(`Processed message ${message}`);
    await Promise.resolve(1); //Placeholder for actual async work
  } catch (err) {
    console.error("An error occurred");
    throw err;
  }
}

Consumindo um evento do SNS com o TypeScript Lambda usando.

import { SNSEvent, Context, SNSHandler, SNSEventRecord } from "aws-lambda";

export const functionHandler: SNSHandler = async (
  event: SNSEvent,
  context: Context
): Promise<void> => {
  for (const record of event.Records) {
    await processMessageAsync(record);
  }
  console.info("done");
};

async function processMessageAsync(record: SNSEventRecord): Promise<any> {
  try {
    const message: string = JSON.stringify(record.Sns.Message);
    console.log(`Processed message ${message}`);
    await Promise.resolve(1); //Placeholder for actual async work
  } catch (err) {
    console.error("An error occurred");
    throw err;
  }
}

PHP

SDK para PHP

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos Exemplos sem servidor.

Consumir um evento do SNS com o Lambda usando PHP.

<?php

/* 
Since native PHP support for AWS Lambda is not available, we are utilizing Bref's PHP functions runtime for AWS Lambda.
For more information on Bref's PHP runtime for Lambda, refer to: https://bref.sh/docs/runtimes/function

Another approach would be to create a custom runtime. 
A practical example can be found here: https://aws.amazon.com/blogs/apn/aws-lambda-custom-runtime-for-php-a-practical-example/
*/

// Additional composer packages may be required when using Bref or any other PHP functions runtime.
// require __DIR__ . '/vendor/autoload.php';

return function ($event, $context) {
    foreach ($event["Records"] as $record) {
        processMessage($record);
    }
    echo "Done!" . PHP_EOL;
};

function processMessage($record)
{
    try {
        $message = $record['Sns']['Message'];
        echo "Processed Message: {$message}" . PHP_EOL;
    } catch (Exception $e) {
        echo "Error occured: {$e->getMessage()}" . PHP_EOL;
        throw $e;
    }
}

Python

SDK para Python (Boto3)

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos Exemplos sem servidor.

Consumir um evento do SNS com o Lambda usando Python.

def lambda_handler(event, context):
    for record in event['Records']:
        process_message(record)
    print("done")

def process_message(record):
    try:
        message = record['Sns']['Message']
        print(f"Processed message {message}")
        # TODO; Process your record here
        
    except Exception as e:
        print("An error occurred")
        raise e

Ruby

SDK for Ruby

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos Exemplos sem servidor.

Consumir um evento do SNS com o Lambda usando Ruby.

def lambda_handler(event:, context:)
  event['Records'].map { |record| process_message(record) }
end

def process_message(record)
  message = record['Sns']['Message']
  puts("Processing message: #{message}")
rescue StandardError => e
  puts("Error processing message: #{e}")
  raise
end

Rust

SDK for Rust

nota

Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório dos Exemplos sem servidor.

Consuma um evento do SNS com o Lambda usando Rust.

use aws_lambda_events::event::sns::SnsEvent;
use aws_lambda_events::sns::SnsRecord;
use lambda_runtime::{run, service_fn, Error, LambdaEvent};
use tracing::info;

// Built with the following dependencies:
//  aws_lambda_events = { version = "0.10.0", default-features = false, features = ["sns"] }
//  lambda_runtime = "0.8.1"
//  tokio = { version = "1", features = ["macros"] }
//  tracing = { version = "0.1", features = ["log"] }
//  tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] }

async fn function_handler(event: LambdaEvent<SnsEvent>) -> Result<(), Error> {
    for event in event.payload.records {
        process_record(&event)?;
    }
    
    Ok(())
}

fn process_record(record: &SnsRecord) -> Result<(), Error> {
    info!("Processing SNS Message: {}", record.sns.message);

    // Implement your record handling code here.

    Ok(())
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::INFO)
        .with_target(false)
        .without_time()
        .init();

    run(service_fn(function_handler)).await
}

Para criar a função

1. Crie um diretório para o projeto e depois mude para esse diretório.

   mkdir sns-tutorial
   cd sns-tutorial

2. Copie o JavaScript código de amostra em um novo arquivo chamadoindex.js.

3. Crie um pacote de implantação usando o comando zip a seguir.

   zip function.zip index.js

4. Execute o comando da AWS CLI a seguir para criar sua função do Lambda na conta B.

   aws lambda create-function --function-name Function-With-SNS \
   --zip-file fileb://function.zip --handler index.handler --runtime nodejs18.x \
   --role arn:aws:iam::<AccountB_ID>:role/lambda-sns-role  \
   --timeout 60 --profile accountB

   Você deve ver saída semelhante ao seguinte:

   {
       "FunctionName": "Function-With-SNS",
       "FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:Function-With-SNS",
       "Runtime": "nodejs18.x",
       "Role": "arn:aws:iam::123456789012:role/lambda_basic_role",
       "Handler": "index.handler",
       ...
       "RuntimeVersionConfig": {
           "RuntimeVersionArn": "arn:aws:lambda:us-west-2::runtime:7d5f06b69c951da8a48b926ce280a9daf2e8bb1a74fc4a2672580c787d608206"
       }
   }

5. O nome do recurso da Amazon (ARN) da sua função. Você precisará dele posteriormente no tutorial ao adicionar permissões para permitir que o Amazon SNS invoque sua função.

Adicionar permissões à função (conta B)

Para que o Amazon SNS invoque a sua função, você precisa conceder permissão em uma declaração de uma política baseada em recursos. Você adiciona essa declaração usando o comando add-permission da AWS CLI.

Para conceder permissão ao Amazon SNS para invocar sua função

• Na conta B, execute o seguinte comando da AWS CLI usando o ARN para o tópico do Amazon SNS que você gravou anteriormente.

  aws lambda add-permission --function-name Function-With-SNS \
  --source-arn arn:aws:sns:us-east-1:<AccountA_ID>:sns-topic-for-lambda \
  --statement-id function-with-sns --action "lambda:InvokeFunction" \
  --principal sns.amazonaws.com --profile accountB

  Você deve ver saída semelhante ao seguinte:

  {
      "Statement": "{\"Condition\":{\"ArnLike\":{\"AWS:SourceArn\":
        \"arn:aws:sns:us-east-1:<AccountA_ID>:sns-topic-for-lambda\"}},
        \"Action\":[\"lambda:InvokeFunction\"],
        \"Resource\":\"arn:aws:lambda:us-east-1:<AccountB_ID>:function:Function-With-SNS\",
        \"Effect\":\"Allow\",\"Principal\":{\"Service\":\"sns.amazonaws.com\"},
        \"Sid\":\"function-with-sns\"}"
  }

nota

Se a conta com o tópico do Amazon SNS estiver hospedada em uma Região da AWS de aceitação, será necessário especificar a região na entidade principal. Por exemplo, se você estiver trabalhando com um tópico do Amazon SNS na região Ásia-Pacífico (Hong Kong), será necessário especificar sns.ap-east-1.amazonaws.com em vez de sns.amazonaws.com para a entidade principal.

Conceder permissão entre contas para assinatura do Amazon SNS (conta A)

Para que a sua função do Lambda na conta B assine o tópico do Amazon SNS criado na conta A, você precisa conceder permissão para que a conta B assine seu tópico. Você concede essa permissão usando o comando add-permission da AWS CLI.

Para conceder permissão para a conta B assinar o tópico

• Na conta A, execute o comando da AWS CLI a seguir. Use o ARN para o tópico do Amazon SNS que você gravou anteriormente.

  aws sns add-permission --label lambda-access --aws-account-id <AccountB_ID> \
  --topic-arn arn:aws:sns:us-east-1:<AccountA_ID>:sns-topic-for-lambda \  
  --action-name Subscribe ListSubscriptionsByTopic --profile accountA

Criar uma assinatura (conta B)

Na conta B, agora você assina a sua função do Lambda no tópico do Amazon SNS criado no início do tutorial na conta A. Quando uma mensagem é enviada para esse tópico (sns-topic-for-lambda), o Amazon SNS invoca sua função do Lambda Function-With-SNS na conta B.

Criar uma assinatura

• Na conta B, execute o comando da AWS CLI a seguir. Use sua região padrão na qual você criou seu tópico e os ARNs para seu tópico e função do Lambda.

  aws sns subscribe --protocol lambda \
  --region us-east-1 \
  --topic-arn arn:aws:sns:us-east-1:<AccountA_ID>:sns-topic-for-lambda \
  --notification-endpoint arn:aws:lambda:us-east-1:<AccountB_ID>:function:Function-With-SNS \
  --profile accountB

  Você deve ver saída semelhante ao seguinte:

  {
      "SubscriptionArn": "arn:aws:sns:us-east-1:<AccountA_ID>:sns-topic-for-lambda:5d906xxxx-7c8x-45dx-a9dx-0484e31c98xx"
  }

Publicar mensagens no tópico (conta A e conta B)

Agora que a sua função do Lambda na conta B está assinada em seu tópico do Amazon SNS na conta A, é hora de testar sua configuração publicando mensagens em seu tópico. Para confirmar que o Amazon SNS invocou sua função Lambda, você usa CloudWatch Logs para visualizar a saída da sua função.

Para publicar uma mensagem em seu tópico e ver a saída da sua função

1. Insira Hello World em um arquivo de texto e salve-o como message.txt.

2. No mesmo diretório em que você salvou seu arquivo de texto, execute o comando da AWS CLI a seguir na conta A. Use o ARN para seu próprio tópico.

   aws sns publish --message file://message.txt --subject Test \
   --topic-arn arn:aws:sns:us-east-1:<AccountA_ID>:sns-topic-for-lambda \
   --profile accountA

   Isso retornará um ID de mensagem com um identificador exclusivo, indicando que a mensagem foi aceita pelo Amazon SNS. Depois, o Amazon SNS tenta enviar a mensagem aos assinantes do tópico. Para confirmar que o Amazon SNS invocou sua função Lambda, use CloudWatch Logs para visualizar a saída da sua função:

3. Na conta B, abra a página de grupos de registros do CloudWatch console da Amazon.

4. Escolha o nome do grupo de logs para sua função (/aws/lambda/Function-With-SNS).

5. Escolha o stream de logs mais recente.

6. Se sua função foi invocada corretamente, você verá uma saída semelhante à seguinte, mostrando o conteúdo da mensagem que você publicou no seu tópico.

   2023-07-31T21:42:51.250Z c1cba6b8-ade9-4380-aa32-d1a225da0e48 INFO Processed message Hello World
   2023-07-31T21:42:51.250Z c1cba6b8-ade9-4380-aa32-d1a225da0e48 INFO done

Limpe os recursos

Agora você pode excluir os recursos criados para este tutorial, a menos que queira mantê-los. Excluindo os recursos da AWS que você não está mais usando, você evita cobranças desnecessárias em sua conta da AWS.

Em Account A (Conta A), limpe o tópico do Amazon SNS.

Para excluir o tópico do Amazon SNS

1. Abra a página Topics (Tópicos) no console do Amazon SNS.

2. Selecione o tópico que você criou.

3. Escolha Excluir.

4. Digite delete me no campo de entrada de texto.

5. Escolha Excluir.

Em Account B (Conta B), limpe sua função de execução, a função Lambda e a assinatura do Amazon SNS.

Para excluir a função de execução

1. Abra a página Roles (Funções) no console do IAM.

2. Selecione a função de execução que você criou.

3. Escolha Excluir.

4. Insira o nome do perfil no campo de entrada de texto e escolha Delete (Excluir).

Como excluir a função do Lambda

1. Abra a página Functions (Funções) no console do Lambda.

2. Selecione a função que você criou.

3. Escolha Ações, Excluir.

4. Digite delete no campo de entrada de texto e escolha Delete (Excluir).

Para excluir a inscrição do Amazon SNS

1. Abrir oPágina AssinaturasNo console do Amazon SNS.

2. Selecione a assinatura que você criou.

3. Escolha Delete (Excluir), Yes, Delete (Sim, excluir).