# Invocar las funciones de Lambda usando las notificaciones de Amazon SNS
Puede utilizar una función de Lambda para procesar notificaciones de Amazon Simple Notification Service (Amazon SNS). Amazon SNS admite funciones de Lambda como destino para los mensajes enviados a un tema. Puede suscribir la función a temas de la misma cuenta o de otras cuentas de AWS. Para ver un tutorial detallado, consulte [Tutorial: Uso de AWS Lambda con Amazon Simple Notification Service](with-sns-example.md).
Lambda admite desencadenadores de SNS únicamente para temas de SNS estándar. Los temas FIFO no son compatibles.
Lambda procesa los mensajes SNS de forma asíncrona poniendo los mensajes en cola y gestionando los reintentos. Si Amazon SNS no puede conectar con Lambda o se rechaza el mensaje, Amazon SNS lo vuelve a intentar a intervalos cada vez mayores durante varias horas. Para conocer los detalles, consulte [Fiabilidad](https://aws.amazon.com/sns/faqs/#Reliability) en las preguntas frecuentes de Amazon SNS.
**aviso**
Las invocaciones asíncronas de Lambda procesan cada evento al menos una vez; puede producirse un procesamiento duplicado de registros. Para evitar posibles problemas relacionados con la duplicación de eventos, le recomendamos encarecidamente que haga que el código de la función sea idempotente. Para obtener más información, consulte [¿Cómo puedo hacer que mi función de Lambda sea idempotente?](https://repost.aws/knowledge-center/lambda-function-idempotent) en el Centro de conocimientos de AWS.
## Utilidad de idempotencia de Powertools para AWS Lambda
La utilidad de idempotencia de Powertools para AWS Lambda hace que sus funciones de Lambda sean idempotentes. Está disponible para Python, TypeScript, Java y .NET. Para obtener más información, consulte [Utilidad de idempotencia](https://docs.powertools.aws.dev/lambda/python/latest/utilities/idempotency/) en la documentación de *Powertools para Lambda AWS(Python), [Utilidad de idempotencia](https://docs.aws.amazon.com/powertools/typescript/2.1.1/utilities/idempotency/) en la documentación de *Powertools para Lambda AWS(TypeScript), [Utilidad de idempotencia](https://docs.powertools.aws.dev/lambda/java/latest/utilities/idempotency/) en la documentación de *Powertools para Lambda AWS(Java) y [Utilidad de idempotencia](https://docs.powertools.aws.dev/lambda/dotnet/utilities/idempotency/) en la documentación de *Powertools para Lambda AWS(.NET). ****
**Topics**
+ [Utilidad de idempotencia de Powertools para AWS Lambda](#services-sns-powertools-idempotency)
+ [Adición de un desencadenador de temas de Amazon SNS para una función de Lambda mediante la consola](#sns-trigger-console)
+ [Adición manual de un desencadenador de temas de Amazon SNS para una función de Lambda](#sns-trigger-manual)
+ [Ejemplo de forma de evento SNS](#sns-sample-event)
+ [Tutorial: Uso de AWS Lambda con Amazon Simple Notification Service](with-sns-example.md)
## Adición de un desencadenador de temas de Amazon SNS para una función de Lambda mediante la consola
Para agregar un tema de SNS como desencadenador de una función de Lambda, la forma más sencilla es utilizar la consola de Lambda. Al agregar el desencadenador a través de la consola, Lambda configura automáticamente los permisos y suscripciones necesarios para empezar a recibir eventos del tema de SNS.
**Cómo agregar un tema de SNS como desencadenador de una función de Lambda (consola)**
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija el nombre de una función a la que desee agregarle el desencadenador.
1. Elija **Configuración** y, a continuación, seleccione **Desencadenadores**.
1. Elija **Add trigger (Añadir disparador)**.
1. En **Configuración del desencadenador**, seleccione **SNS** de la lista desplegable.
1. Para el **tema de SNS**, elija el tema de SNS al que desee suscribirse.
## Adición manual de un desencadenador de temas de Amazon SNS para una función de Lambda
Para configurar manualmente un desencadenador de SNS para una función de Lambda, debe completar los siguientes pasos:
+ Defina una política basada en recursos para la función de modo que SNS pueda invocarla.
+ Suscriba la función de Lambda al tema de Amazon SNS.
**nota**
Si su tema de SNS y su función de Lambda están en cuentas de AWS diferentes, también debe conceder permisos adicionales para permitir las suscripciones multicuenta al tema de SNS. Para obtener más información, consulte [Conceder permiso entre cuentas para la suscripción a Amazon SNS](with-sns-example.md#with-sns-subscription-grant-permission).
Puede usar el AWS Command Line Interface (AWS CLI) para completar estos dos pasos. En primer lugar, para definir una política basada en recursos para una función de Lambda que permita las invocaciones de SNS, utilice el siguiente comando de la AWS CLI. Asegúrese de sustituir el valor de `--function-name` por el nombre de la función de Lambda y el valor de `--source-arn` por el ARN del tema de SNS.
```
aws lambda add-permission --function-name example-function \
--source-arn arn:aws:sns:us-east-1:123456789012:sns-topic-for-lambda \
--statement-id function-with-sns --action "lambda:InvokeFunction" \
--principal sns.amazonaws.com
```
Utilice el siguiente comando AWS CLI para suscribir la función al tema SNS. Sustituya el valor de `--topic-arn` por el ARN del tema de SNS y el valor de `--notification-endpoint` por el ARN de la función de Lambda.
```
aws sns subscribe --protocol lambda \
--region us-east-1 \
--topic-arn arn:aws:sns:us-east-1:123456789012:sns-topic-for-lambda \
--notification-endpoint arn:aws:lambda:us-east-1:123456789012:function:example-function
```
## Ejemplo de forma de evento SNS
Amazon SNS invoca la función [de forma asíncrona](invocation-async.md) con un evento que contiene un mensaje y metadatos.
**Example Evento de mensajes de Amazon SNS**
```
{
"Records": [
{
"EventVersion": "1.0",
"EventSubscriptionArn": "arn:aws:sns:us-east-1:123456789012:sns-lambda:21be56ed-a058-49f5-8c98-aedd2564c486",
"EventSource": "aws:sns",
"Sns": {
"SignatureVersion": "1",
"Timestamp": "2019-01-02T12:45:07.000Z",
"Signature": "tcc6faL2yUC6dgZdmrwh1Y4cGa/ebXEkAi6RibDsvpi+tE/1+82j...65r==",
"SigningCertURL": "https://sns.us-east-1.amazonaws.com/SimpleNotificationService-ac565b8b1a6c5d002d285f9598aa1d9b.pem",
"MessageId": "95df01b4-ee98-5cb9-9903-4c221d41eb5e",
"Message": "Hello from SNS!",
"MessageAttributes": {
"Test": {
"Type": "String",
"Value": "TestString"
},
"TestBinary": {
"Type": "Binary",
"Value": "TestBinary"
}
},
"Type": "Notification",
"UnsubscribeUrl": "https://sns.us-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-1:123456789012:test-lambda:21be56ed-a058-49f5-8c98-aedd2564c486",
"TopicArn":"arn:aws:sns:us-east-1:123456789012:sns-lambda",
"Subject": "TestInvoke"
}
}
]
}
```
# Tutorial: Uso de AWS Lambda con Amazon Simple Notification Service
En este tutorial, utilizará una función de Lambda en una Cuenta de AWS para suscribirse a un tema de Amazon Simple Notification Service (Amazon SNS) en una Cuenta de AWS independiente. Cuando publica mensajes en su tema de Amazon SNS, la función de Lambda lee el contenido del mensaje y lo envía a Registros de Amazon CloudWatch. Para completar este tutorial, debe usar la AWS Command Line Interface (AWS CLI).
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-sns-tutorial/sns_tut_resources.png)
Para completar este tutorial, lleve a cabo los siguientes pasos:
+ En la **cuenta A**, cree un tema de Amazon SNS.
+ En la **cuenta B**, cree una función de Lambda que lea los mensajes del tema.
+ En la **cuenta B**, cree una suscripción al tema.
+ Publique los mensajes en el tema de Amazon SNS en la **cuenta A** y confirme que la función de Lambda de la **cuenta B** los envíe a Registros de CloudWatch.
Al completar estos pasos, aprenderá a configurar un tema de Amazon SNS para invocar una función de Lambda. También aprenderá a crear una política de AWS Identity and Access Management (IAM) que conceda permiso a un recurso de otra Cuenta de AWS para invocar Lambda.
En el tutorial, utiliza dos Cuentas de AWS independientes. Los comandos de AWS CLI ilustran esto mediante dos perfiles con nombre llamados `accountA` y `accountB`, cada uno configurado para usarse con una Cuenta de AWS diferente. A fin de aprender a configurar AWS CLI para usar diferentes perfiles, consulte [Opciones de los archivos de configuración y credenciales](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) en la *Guía del usuario de la versión 2 de la AWS Command Line Interface*. Asegúrese de configurar la misma Región de AWS predeterminada para ambos perfiles.
Si los perfiles de AWS CLI que crea para las dos Cuentas de AWS utilizan nombres distintos, o si usa el perfil predeterminado y un perfil con nombre, modifique los comandos de AWS CLI en los siguientes pasos según sea necesario.
## Requisitos previos
### Instala la AWS Command Line Interface
Si aún no ha instalado AWS Command Line Interface, siga los pasos que se indican en [Instalación o actualización de la versión más reciente de AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) para instalarlo.
El tutorial requiere un intérprete de comandos o un terminal de línea de comando para ejecutar los comandos. En Linux y macOS, use su administrador de intérprete de comandos y paquetes preferido.
**nota**
En Windows, algunos comandos de la CLI de Bash que se utilizan habitualmente con Lambda (por ejemplo, `zip`) no son compatibles con los terminales integrados del sistema operativo. Para obtener una versión de Ubuntu y Bash integrada con Windows, [instale el subsistema de Windows para Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10).
## Creación de un tema de Amazon SNS (cuenta A)
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_1.png)
**Para crear el tema**
+ En la **cuenta A**, cree un tema estándar de Amazon SNS mediante el siguiente comando de AWS CLI.
```
aws sns create-topic --name sns-topic-for-lambda --profile accountA
```
Debería ver un resultado similar a este.
```
{
"TopicArn": "arn:aws:sns:us-west-2:123456789012:sns-topic-for-lambda"
}
```
Anote el Nombre de recurso de Amazon (ARN) del tema. Lo necesitará más adelante en el tutorial cuando agregue permisos a la función de Lambda para suscribirse al tema.
## Creación de un rol de ejecución de función (cuenta B)
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_2.png)
Un rol de ejecución es un rol de IAM que concede a la función de Lambda permiso para acceder a servicios y recursos de Servicios de AWS. Antes de crear la función en la **cuenta B**, cree un rol que conceda a la función permisos básicos para escribir registros en Registros de CloudWatch. Agregaremos los permisos para leer el tema de Amazon SNS en un paso posterior.
**Para crear un rol de ejecución**
1. En la **cuenta B**, abra la [página de roles](https://console.aws.amazon.com/iam/home#/roles) en la consola de IAM.
1. Seleccione **Crear rol**.
1. En **Tipo de entidad de confianza**, elija **Servicio de AWS**.
1. En **Caso de uso**, elija **Lambda**.
1. Elija **Siguiente**.
1. Siga estos pasos para agregar una política de permisos básicos al rol:
1. En el cuadro de búsqueda **Permisos de selección**, ingrese **AWSLambdaBasicExecutionRole**.
1. Elija **Siguiente**.
1. Siga estos pasos para finalizar la creación del rol:
1. En **Detalles del rol**, escriba **lambda-sns-role** en **Nombre de rol**.
1. Seleccione **Crear rol**.
## Creación de una función de Lambda (cuenta B)
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_3.png)
Cree una función de Lambda que procese los mensajes de Amazon SNS. El código de función registra el contenido de los mensajes de cada entrada en los Registros de Amazon CloudWatch.
En este tutorial, se utiliza el tiempo de ejecución de Node.js 24, pero también hemos proporcionado archivos de código de ejemplo en otros lenguajes de tiempo de ejecución. Puede seleccionar la pestaña del siguiente cuadro para ver el código del tiempo de ejecución que le interesa. El código JavaScript que usará en este paso está en el primer ejemplo que se muestra en la pestaña **JavaScript**.
------
#### [ .NET ]
**SDK para .NET**
Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Uso de un evento de SNS con Lambda mediante .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**
Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Uso de un evento de SNS con Lambda mediante 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**
Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Uso de un evento de SNS con Lambda mediante 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 {
LambdaLogger logger;
@Override
public Boolean handleRequest(SNSEvent event, Context context) {
logger = context.getLogger();
List records = event.getRecords();
if (!records.isEmpty()) {
Iterator 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)**
Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/blob/main/integration-sns-to-lambda).
Uso de un evento de SNS con Lambda mediante 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;
}
}
```
Uso de un evento de SNS con Lambda mediante 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 => {
for (const record of event.Records) {
await processMessageAsync(record);
}
console.info("done");
};
async function processMessageAsync(record: SNSEventRecord): Promise {
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**
Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Uso de un evento de SNS con Lambda mediante PHP
```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
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)**
Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Uso de un evento de SNS con Lambda mediante 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**
Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Uso de un evento de SNS con Lambda mediante 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**
Hay más en GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el repositorio de [ejemplos de tecnología sin servidor](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sns-to-lambda).
Uso de un evento de SNS con Lambda mediante 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) -> 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
}
```
------
**Cómo crear la función**
1. Cree un directorio para el proyecto y, a continuación, cambie a ese directorio.
```
mkdir sns-tutorial
cd sns-tutorial
```
1. Copie el código de muestra de JavaScript en un nuevo archivo con el nombre `index.js`.
1. Cree un paquete de implementación utilizando el siguiente comando `zip`.
```
zip function.zip index.js
```
1. Ejecute el siguiente comando de AWS CLI para crear la función de Lambda en la **cuenta B**.
```
aws lambda create-function --function-name Function-With-SNS \
--zip-file fileb://function.zip --handler index.handler --runtime nodejs24.x \
--role arn:aws:iam:::role/lambda-sns-role \
--timeout 60 --profile accountB
```
Debería ver un resultado similar a este.
```
{
"FunctionName": "Function-With-SNS",
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:Function-With-SNS",
"Runtime": "nodejs24.x",
"Role": "arn:aws:iam::123456789012:role/lambda_basic_role",
"Handler": "index.handler",
...
"RuntimeVersionConfig": {
"RuntimeVersionArn": "arn:aws:lambda:us-west-2::runtime:7d5f06b69c951da8a48b926ce280a9daf2e8bb1a74fc4a2672580c787d608206"
}
}
```
1. Registre el Nombre de recurso de Amazon (ARN) de la función. Lo necesitará más adelante en el tutorial cuando agregue permisos para permitir a Amazon SNS que invoque la función.
## Adición de permisos a la función (cuenta B)
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_4.png)
Para que Amazon SNS invoque la función, debe concederle permiso en una instrucción de una [política basada en recursos](access-control-resource-based.md). Para agregar esta instrucción, utilice el comando `add-permission` de AWS CLI.
**Para conceder permiso a Amazon SNS para invocar la función**
+ En la **cuenta B**, ejecute el siguiente comando de AWS CLI mediante el ARN del tema de Amazon SNS que registró anteriormente.
```
aws lambda add-permission --function-name Function-With-SNS \
--source-arn arn:aws:sns:us-east-1::sns-topic-for-lambda \
--statement-id function-with-sns --action "lambda:InvokeFunction" \
--principal sns.amazonaws.com --profile accountB
```
Debería ver un resultado similar a este.
```
{
"Statement": "{\"Condition\":{\"ArnLike\":{\"AWS:SourceArn\":
\"arn:aws:sns:us-east-1::sns-topic-for-lambda\"}},
\"Action\":[\"lambda:InvokeFunction\"],
\"Resource\":\"arn:aws:lambda:us-east-1::function:Function-With-SNS\",
\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"sns.amazonaws.com\"},
\"Sid\":\"function-with-sns\"}"
}
```
**nota**
Si la cuenta con el tema de Amazon SNS está alojada en una [Región de AWS con suscripción](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-regions.html), debe especificar la región en la entidad principal. Por ejemplo, si trabaja con un tema de Amazon SNS en la región de Asia-Pacífico (Hong Kong), debe especificar `sns.ap-east-1.amazonaws.com` en lugar de `sns.amazonaws.com` para la entidad principal.
## Concesión de permiso entre cuentas para la suscripción a Amazon SNS (cuenta A)
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_5.png)
Para que su función de Lambda de la **cuenta B** se suscriba al tema de Amazon SNS que creó en la **cuenta A**, tiene que conceder permiso a la **cuenta B** para suscribirse al tema. Utilice el comando `add-permission` de AWS CLI para conceder este permiso.
**Para conceder permiso para que la cuenta B se suscriba al tema**
+ En la **cuenta A**, ejecute el siguiente comando de AWS CLI. Utilice el ARN del tema de Amazon SNS que registró anteriormente.
```
aws sns add-permission --label lambda-access --aws-account-id \
--topic-arn arn:aws:sns:us-east-1::sns-topic-for-lambda \
--action-name Subscribe ListSubscriptionsByTopic --profile accountA
```
## Creación de una suscripción (cuenta B)
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_6.png)
En la **cuenta B**, ahora puede suscribir su función de Lambda al tema de Amazon SNS que creó al principio del tutorial en la **cuenta A**. Cuando se envía un mensaje a este tema (`sns-topic-for-lambda`), Amazon SNS invoca su función de Lambda `Function-With-SNS` en la **cuenta B**.
**Para crear una suscripción**
+ En la **cuenta B**, ejecute el siguiente comando de AWS CLI. Use la región predeterminada en la que creó el tema y los ARN del tema y la función de Lambda.
```
aws sns subscribe --protocol lambda \
--region us-east-1 \
--topic-arn arn:aws:sns:us-east-1::sns-topic-for-lambda \
--notification-endpoint arn:aws:lambda:us-east-1::function:Function-With-SNS \
--profile accountB
```
Debería ver un resultado similar a este.
```
{
"SubscriptionArn": "arn:aws:sns:us-east-1::sns-topic-for-lambda:5d906xxxx-7c8x-45dx-a9dx-0484e31c98xx"
}
```
## Publicación de mensajes en el tema (cuenta A y cuenta B)
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/services-sns-tutorial/sns_tut_steps_7.png)
Ahora que su función de Lambda de la **cuenta B** se ha suscrito a su tema de Amazon SNS en la **cuenta A**, es hora de probar la configuración mediante la publicación de mensajes en el tema. Para confirmar que Amazon SNS ha invocado la función de Lambda, utilice Registros de CloudWatch para ver la salida de la función.
**Para publicar un mensaje en el tema y ver la salida de la función**
1. Escriba `Hello World` en un archivo de texto y guárdelo como `message.txt`.
1. Desde el mismo directorio en el que guardó el archivo de texto, ejecute el siguiente comando de AWS CLI en la **cuenta A**. Use el ARN de su propio tema.
```
aws sns publish --message file://message.txt --subject Test \
--topic-arn arn:aws:sns:us-east-1::sns-topic-for-lambda \
--profile accountA
```
Esto devolverá un ID de mensaje con un identificador único que indica que Amazon SNS ha aceptado el mensaje. Posteriormente, Amazon SNS intentará entregar el mensaje a los suscriptores del tema. Para confirmar que Amazon SNS ha invocado la función de Lambda, utilice Registros de CloudWatch para ver la salida de la función:
1. En la **cuenta B**, abra la página [Grupos de registro](https://console.aws.amazon.com/cloudwatch/home#logsV2:log-groups) de la consola de Amazon CloudWatch.
1. Elija el grupo de registro para la función (`/aws/lambda/Function-With-SNS`).
1. Elija el flujo de registros más reciente.
1. Si la función se ha invocado correctamente, verá una salida similar a la siguiente en la que se muestra el contenido del mensaje que publicó en el tema.
```
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
```
## Eliminación de sus recursos
A menos que desee conservar los recursos que creó para este tutorial, puede eliminarlos ahora. Si elimina los recursos de AWS que ya no utiliza, evitará gastos innecesarios en su Cuenta de AWS.
En la **cuenta A**, limpie el tema de Amazon SNS.
**Para eliminar el tema de Amazon SNS**
1. Abra la página [Topics (Temas)](https://console.aws.amazon.com//sns/home#topics:) en la consola de Amazon SNS.
1. Seleccione el tema que creó.
1. Elija **Eliminar**.
1. Introduzca **delete me** en el campo de entrada de texto.
1. Elija **Eliminar**.
En la **cuenta B**, limpie el rol de ejecución, la función de Lambda y la suscripción de Amazon SNS.
**Cómo eliminar el rol de ejecución**
1. Abra la página [Roles](https://console.aws.amazon.com/iam/home#/roles) en la consola de IAM.
1. Seleccione el rol de ejecución que creó.
1. Elija **Eliminar**.
1. Si desea continuar, escriba el nombre del rol en el campo de entrada de texto y elija **Delete** (Eliminar).
**Cómo eliminar la función de Lambda**
1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Seleccione la función que ha creado.
1. Elija **Acciones**, **Eliminar**.
1. Escriba **confirm** en el campo de entrada de texto y elija **Delete** (Eliminar).
**Para eliminar la suscripción a Amazon SNS**
1. Abra la página [Suscriptions (Suscripciones)](https://console.aws.amazon.com//sns/home#subscriptions:) en la consola de Amazon SNS.
1. Seleccione la suscripción que creó.
1. Elija **Delete (Eliminar)**, **Delete (Eliminar)**.