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