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 em seu tópico do Amazon SNS, sua função do Lambda lê o conteúdo da mensagem e a envia para o Amazon CloudWatch Logs. 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 para o tópico do Amazon SNS na conta A e confirme se a função do Lambda na conta B os envia para o CloudWatch Logs.

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

Cadastre-se em uma Conta da AWS

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

Para cadastrar-se em uma Conta da AWS

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

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

   Parte do procedimento de inscrição envolve receber uma chamada telefônica e digitar um código de verificação no teclado do telefone.

   Quando você se cadastra em 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 recursos na conta. Como prática recomendada de segurança, atribua o acesso administrativo a um usuário e use somente o usuário-raiz para executar tarefas que exigem acesso de usuário-raiz.

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 com acesso administrativo

Depois de se cadastrar 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.

Proteja seu Usuário raiz da conta da AWS

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

   Para obter ajuda ao fazer login usando o usuário raiz, consulte Signing in as the root user (Fazer login como usuário raiz) no Guia do usuárioInício de Sessão da AWS.

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

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

Criar um usuário com acesso administrativo

1. Habilitar o IAM Identity Center.

   Para obter instruções, consulte Habilitar AWS IAM Identity Center no Guia do usuário do AWS IAM Identity Center.

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

   Para obter um tutorial sobre como usar o Diretório do Centro de Identidade do IAM como fonte de identidade, consulte Configurar o acesso dos usuários com o Diretório do Centro de Identidade do IAM padrão no Guia do usuário do AWS IAM Identity Center.

Iniciar sessão como o usuário com acesso administrativo

• Para fazer login com seu usuário IAM Identity Center, use a URL de login enviada ao seu endereço de e-mail quando você criou o usuário IAM Identity Center user.

  Para obter ajuda com o login utilizando um usuário do IAM Identity Center, consulte Fazendo login no portal de acesso da AWS, no Guia do UsuárioInício de Sessão da AWS.

Atribuir acesso a usuários adicionais

1. No Centro de Identidade do IAM, crie um conjunto de permissões que siga as práticas recomendadas de aplicação de permissões com privilégio mínimo.

   Para obter instruções, consulte Create a permission set no Guia do usuário do AWS IAM Identity Center.

2. Atribua usuários a um grupo e, em seguida, atribua o acesso de autenticação única ao grupo.

   Para obter instruções, consulte Add groups no Guia do usuário do AWS IAM Identity Center.

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 perfil que dá à função permissões básicas para gravar logs 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 código JavaScript que você usará nesta etapa é o primeiro exemplo mostrado na guia JavaScript.

.NET

AWS SDK for .NET

nota

Há mais no 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.

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
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 para Go V2

nota

Há mais no 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.

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
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

Há mais no 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.

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
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 (v3)

nota

Há mais no GitHub. Encontre o exemplo completo e saiba como configurar e executar no repositório de Exemplos sem servidor.

Consumir um evento do SNS com o Lambda usando JavaScript.

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
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;
  }
}

Consumir um evento do SNS com o Lambda usando TypeScript.

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
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

Há mais no 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.

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
<?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';

use Bref\Context\Context;
use Bref\Event\Sns\SnsEvent;
use Bref\Event\Sns\SnsHandler;

class Handler extends SnsHandler
{
    public function handleSns(SnsEvent $event, Context $context): void
    {
        foreach ($event->getRecords() as $record) {
            $message = $record->getMessage();

            // TODO: Implement your custom processing logic here
            // Any exception thrown will be logged and the invocation will be marked as failed

            echo "Processed Message: $message" . PHP_EOL;
        }
    }
}

return new Handler();

Python

SDK para Python (Boto3).

nota

Há mais no 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.

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
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 para Ruby

nota

Há mais no 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.

# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
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 para Rust

nota

Há mais no 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.

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
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 código JavaScript de amostra em um novo arquivo denominado index.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 se o Amazon SNS invocou sua função do Lambda, use o CloudWatch Logs para visualizar a saída da 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 se o Amazon SNS invocou sua função do Lambda, use o CloudWatch Logs para visualizar a saída da função:

3. Na conta B, abra a página Grupos de logs do console do Amazon CloudWatch.

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).