Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Uso de Amazon SNS para la mensajería application-to-application
Amazon SNS simplifica la mensajería application-to-application (A2A) al separar a los editores de los suscriptores, lo que admite microservicios, sistemas distribuidos y aplicaciones sin servidor. Los mensajes se envían a los temas de Amazon SNS, donde se pueden filtrar y entregar a suscriptores como Lambda, Amazon SQS o puntos de conexión HTTP. Si se produce un error en la entrega, los mensajes se almacenan en una cola de mensajes fallidos para su posterior análisis o para volverlos a procesar.
![\[Amazon SNS facilita la application-to-application mensajería al separar a los editores de los suscriptores mediante temas. Los mensajes de los sistemas o servicios se redirigen a través de un tema de Amazon SNS, donde se pueden filtrar y distribuir a suscriptores como Lambda, Amazon SQS o sistemas de correo electrónico. Si se produce un error en la entrega, los mensajes se almacenan en una cola de mensajes fallidos para su posterior análisis o para volverlos a procesar.\]](http://docs.aws.amazon.com/es_es/sns/latest/dg/images/sns-a2a-overview.png)
# Distribución ramificada a los flujos de entrega de Firehose
Puede suscribir los [flujos de entrega](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html) a temas de Amazon SNS, lo que le permite enviar notificaciones a otros puntos de conexión de almacenamiento y análisis. Los mensajes publicados en un tema de Amazon SNS se envían al flujo de entrega de Firehose suscrito y se entregan al destino tal y como están configurados en Firehose. El propietario de una suscripción puede suscribir hasta cinco flujos de entrega de Firehose a un tema de Amazon SNS. Cada flujo de entrega de Firehose tiene una [cuota predeterminada](https://docs.aws.amazon.com/firehose/latest/dev/limits.html) para solicitudes y rendimiento por segundo. Este límite podría dar lugar a más mensajes publicados (tráfico entrante) que entregados (tráfico saliente). Cuando hay más tráfico entrante que saliente, la suscripción puede acumular una gran cantidad de mensajes atrasados, lo que provoca una latencia de entrega de mensajes elevada. Puede solicitar un [aumento de cuota](https://support.console.aws.amazon.com/support/home#/case/create?issueType=service-limit-increase) en función de la tasa de publicación para evitar un impacto adverso en la carga de trabajo.
A través de las transmisiones de entrega de Firehose, puede distribuir las notificaciones de Amazon SNS a Amazon Simple Storage Service (Amazon S3), Amazon Redshift, Amazon Service (OpenSearch Service) y a proveedores de servicios de terceros, OpenSearch como Datadog, New Relic, MongoDB y Splunk.
Por ejemplo, puede utilizar esta funcionalidad para almacenar de forma permanente los mensajes enviados a un tema en un bucket de Amazon S3 con fines de conformidad, archivado u otros. Para ello, cree un flujo de entrega de Firehose con un destino de bucket de Amazon S3 y suscríbalo al tema de Amazon SNS. Como otro ejemplo, para analizar los mensajes enviados a un tema de Amazon SNS, cree una transmisión de entrega con un destino de índice de OpenSearch servicios. A continuación, puede suscribir el flujo de entrega de Firehose al tema de Amazon SNS.
Amazon SNS también admite el registro de estado de entrega de mensajes para las notificaciones enviadas a los puntos de conexión de Firehose. Para obtener más información, consulte [Estado de entrega de mensajes de Amazon SNS](sns-topic-attributes.md).
# Requisitos previos para suscribir flujos de entrega de Firehose a temas de Amazon SNS
Para suscribir una transmisión de entrega a un tema de SNS, Cuenta de AWS debes tener:
+ Un tema de SNS estándar. Para obtener más información, consulte [Creación de un tema de Amazon SNS](sns-create-topic.md).
+ Un flujo de entrega de Firehose. Para obtener más información, consulte [Creación de un flujo de entrega](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html) y [Concesión a una aplicación de acceso a los recursos de Firehose](https://docs.aws.amazon.com/firehose/latest/dev/controlling-access.html#access-to-firehose) en la *Guía para desarrolladores de Amazon Data Firehose*.
+ Un rol AWS Identity and Access Management (IAM) que confía en el director del servicio Amazon SNS y tiene permiso para escribir en el flujo de entrega. Ingresará el nombre de recurso de Amazon (ARN) de este rol como `SubscriptionRoleARN` cuando cree la suscripción. Amazon SNS asume este rol y, gracias a esto, Amazon SNS puede colocar registros en el flujo de entrega de Firehose.
En el siguiente ejemplo de política, se muestran los permisos recomendados:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"firehose:DescribeDeliveryStream",
"firehose:ListDeliveryStreams",
"firehose:ListTagsForDeliveryStream",
"firehose:PutRecord",
"firehose:PutRecordBatch"
],
"Resource": [
"arn:aws:firehose:us-east-1:111111111111:deliverystream/firehose-sns-delivery-stream"
],
"Effect": "Allow"
}
]
}
```
------
Para conceder todos los permisos necesarios para usar Firehose, también puedes usar la política AWS gestionada. `AmazonKinesisFirehoseFullAccess` O bien, para proporcionar permisos más estrictos para usar Firehose, puede crear su propia política. Como mínimo, en la política se debe proporcionar permiso para ejecutar la operación `PutRecord` en un flujo de entrega específico.
En todos los casos, también debe editar la relación de confianza para incluir el principal de servicio de Amazon SNS. Por ejemplo:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "sns.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Para obtener más información sobre la creación de funciones, consulte [Crear una función para delegar permisos a un AWS servicio](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) en la Guía del *usuario de IAM*.
Una vez que haya completado estos requisitos, puede [suscribir el flujo de entrega al tema de SNS](firehose-endpoints-subscribe.md).
# Suscripción de un flujo de entrega de Firehose a un tema de Amazon SNS
Para entregar notificaciones de Amazon SNS a los [flujos de entrega](sns-firehose-as-subscriber.md), primero asegúrese de haber cumplido todos los [requisitos previos](prereqs-kinesis-data-firehose.md). Para obtener una lista de puntos de conexión admitidos, consulte [puntos de conexión y cuotas](https://docs.aws.amazon.com/general/latest/gr/fh.html) en la *Referencia general de Amazon Web Services*.
**Suscripción de un flujo de entrega de Firehose a un tema**
1. Inicie sesión en la [consola de Amazon SNS](https://console.aws.amazon.com/sns/home).
1. En el panel de navegación, seleccione **Suscripciones**.
1. En la página **Subscriptions (Suscripciones)**, elija **Create subscription (Crear suscripción)**.
1. En la página **Crear suscripción**, en la sección **Detalles**, haga lo siguiente:
1. En **ARN de tema**, elija el nombre de recurso de Amazon (ARN) de un tema estándar.
1. En **Protocolo**, elija **Firehose**.
1. En **Punto de conexión**, elija el ARN de un flujo de entrega de Firehose en el que se puedan recibir notificaciones de Amazon SNS.
1. En **ARN del rol de suscripción**, especifique el ARN rol de AWS Identity and Access Management (IAM) que creó para escribir en flujos de entrega de Firehose. Para obtener más información, consulte [Requisitos previos para suscribir flujos de entrega de Firehose a temas de Amazon SNS](prereqs-kinesis-data-firehose.md).
1. (Opcional) Para eliminar cualquier metadato de Amazon SNS de los mensajes publicados, elija **Habilitar la entrega de mensajes**. Para obtener más información, consulte [Entrega de mensajes sin procesar de Amazon SNS](sns-large-payload-raw-message-delivery.md).
1. (Opcional) Para configurar una política de filtro, expanda la sección **Política de filtro de suscripción**. Para obtener más información, consulte [Políticas de filtro de suscripciones de Amazon SNS](sns-subscription-filter-policies.md).
1. (Opcional) Para configurar una cola de mensajes fallidos en la suscripción, expanda la sección **Política de reconducción (cola de mensajes fallidos)**. Para obtener más información, consulte [Colas de mensajes fallidos de Amazon SNS](sns-dead-letter-queues.md).
1. Seleccione **Crear subscripción**.
En la consola se crea la suscripción y se abre la página **Detalles** de la suscripción.
# Administración de mensajes de Amazon SNS en varios destinos de flujo de entrega
los [flujos de entrega](sns-firehose-as-subscriber.md) le permiten gestionar los mensajes de Amazon SNS en varios destinos, lo que permite la integración con Amazon S3, Amazon OpenSearch Service, Amazon Redshift y los puntos de enlace HTTP para el almacenamiento, la indexación y el análisis. Al configurar correctamente el formato y la entrega de los mensajes, puede almacenar las notificaciones de Amazon SNS en Amazon S3 para su posterior procesamiento, analizar los datos estructurados de los mensajes con Amazon Athena, indexar los mensajes para buscarlos y visualizarlos OpenSearch en tiempo real y estructurar los archivos en Amazon Redshift para realizar consultas avanzadas.
# Almacenamiento y análisis de mensajes de Amazon SNS en destinos de Amazon S3
En este tema se explica cómo los flujos de entrega publican los datos en Amazon Simple Storage Service (Amazon S3).
![\[La integración y el flujo de trabajo de los servicios de Amazon para el tratamiento de mensajes. Muestra cómo un publicador envía mensajes a un tema de Amazon SNS y, a continuación, distribuye mediante ramificación los mensajes entre varias colas de Amazon SQS y un flujo de entrega de Data Firehose. Una vez allí, los mensajes pueden procesarse mediante funciones de Lambda o almacenarse de forma persistente en un bucket de Amazon S3.\]](http://docs.aws.amazon.com/es_es/sns/latest/dg/images/firehose-architecture-s3.png)
**Topics**
+ [Formato de las notificaciones para su almacenamiento en destinos de Amazon S3](firehose-archived-message-format-S3.md)
+ [Análisis de los mensajes almacenados en Amazon S3 con Athena](firehose-message-analysis-s3.md)
# Formato de las notificaciones de Amazon SNS para su almacenamiento en destinos de Amazon S3
En el siguiente ejemplo, se muestra una notificación de Amazon SNS enviada a un bucket de Amazon Simple Storage Service (Amazon S3), con sangrías para facilitar la lectura.
**nota**
En este ejemplo, se desactivó la entrega de mensajes sin formato en el mensaje publicado. Si se desactiva la entrega de mensajes sin formato, Amazon SNS agrega metadatos JSON al mensaje, incluidas las siguientes propiedades:
`Type`
`MessageId`
`TopicArn`
`Subject`
`Timestamp`
`UnsubscribeURL`
`MessageAttributes`
Para obtener más información acerca de la entrega sin procesar, consulte [Entrega de mensajes sin procesar de Amazon SNS](sns-large-payload-raw-message-delivery.md).
```
{
"Type": "Notification",
"MessageId": "719a6bbf-f51b-5320-920f-3385b5e9aa56",
"TopicArn": "arn:aws:sns:us-east-1:333333333333:my-kinesis-test-topic",
"Subject": "My 1st subject",
"Message": "My 1st body",
"Timestamp": "2020-11-26T23:48:02.032Z",
"UnsubscribeURL": "https://sns.us-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-1:333333333333:my-kinesis-test-topic:0b410f3c-ee5e-49d8-b59b-3b4aa6d8fcf5",
"MessageAttributes": {
"myKey1": {
"Type": "String",
"Value": "myValue1"
},
"myKey2": {
"Type": "String",
"Value": "myValue2"
}
}
}
```
En el siguiente ejemplo, se muestran tres mensajes de SNS enviados a través de un flujo de entrega al mismo bucket de Amazon S3. Se aplica almacenamiento en búfer y los saltos de línea separan cada mensaje.
```
{"Type":"Notification","MessageId":"d7d2513e-6126-5d77-bbe2-09042bd0a03a","TopicArn":"arn:aws:sns:us-east-1:333333333333:my-kinesis-test-topic","Subject":"My 1st subject","Message":"My 1st body","Timestamp":"2020-11-27T00:30:46.100Z","UnsubscribeURL":"https://sns.us-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-1:313276652360:my-kinesis-test-topic:0b410f3c-ee5e-49d8-b59b-3b4aa6d8fcf5","MessageAttributes":{"myKey1":{"Type":"String","Value":"myValue1"},"myKey2":{"Type":"String","Value":"myValue2"}}}
{"Type":"Notification","MessageId":"0c0696ab-7733-5bfb-b6db-ce913c294d56","TopicArn":"arn:aws:sns:us-east-1:333333333333:my-kinesis-test-topic","Subject":"My 2nd subject","Message":"My 2nd body","Timestamp":"2020-11-27T00:31:22.151Z","UnsubscribeURL":"https://sns.us-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-1:313276652360:my-kinesis-test-topic:0b410f3c-ee5e-49d8-b59b-3b4aa6d8fcf5","MessageAttributes":{"myKey1":{"Type":"String","Value":"myValue1"}}}
{"Type":"Notification","MessageId":"816cd54d-8cfa-58ad-91c9-8d77c7d173aa","TopicArn":"arn:aws:sns:us-east-1:333333333333:my-kinesis-test-topic","Subject":"My 3rd subject","Message":"My 3rd body","Timestamp":"2020-11-27T00:31:39.755Z","UnsubscribeURL":"https://sns.us-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-1:313276652360:my-kinesis-test-topic:0b410f3c-ee5e-49d8-b59b-3b4aa6d8fcf5"}
```
# Análisis de los mensajes de Amazon SNS almacenados en Amazon S3 con Athena
En esta página se explica cómo analizar los mensajes de Amazon SNS enviados a través de flujos de entrega a destinos de Amazon Simple Storage Service (Amazon S3).
**Análisis de mensajes SNS enviados a través de flujos de entrega de Firehose a destinos de Amazon S3**
1. Configure sus recursos de Amazon S3. Para recibir instrucciones, consulte [Creación de un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) en la *Guía del usuario de Amazon Simple Storage Service* y [Trabajar con buckets de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingBucket.html) en la *Guía del usuario de Amazon Simple Storage Service*.
1. Configure el flujo de entrega. Para obtener más información, consulte [Choose Amazon S3 for Your Destination](https://docs.aws.amazon.com/firehose/latest/dev/create-destination.html#create-destination-s3) en la *Guía para desarrolladores de Amazon Data Firehose*.
1. Utilice [Amazon Athena](https://console.aws.amazon.com/athena) para consultar los objetos de Amazon S3 mediante SQL estándar. Para obtener más información, consulte [Introducción](https://docs.aws.amazon.com/athena/latest/ug/getting-started.html) en la *Guía del usuario de Amazon Athena*.
## Consulta de ejemplo
En esta consulta, suponga lo siguiente:
+ Los mensajes se almacenan en la tabla `notifications` del esquema `default`.
+ En la tabla `notifications`, se incluye una columna `timestamp` con un tipo de `string`.
Con la siguiente consulta, se devuelven todos los mensajes SNS recibidos en el intervalo de fechas especificado:
```
SELECT *
FROM default.notifications
WHERE from_iso8601_timestamp(timestamp) BETWEEN TIMESTAMP '2020-12-01 00:00:00' AND TIMESTAMP '2020-12-02 00:00:00';
```
# Integración de los mensajes de Amazon SNS con los destinos de Amazon Service OpenSearch
En esta sección se explica cómo las transmisiones de entrega publican los datos en Amazon OpenSearch Service (OpenSearch Servicio).
![\[Un publicador envía mensajes a un tema de Amazon SNS que luego distribuye estos mensajes a varias colas de Amazon SNS. Los mensajes de estas colas se pueden procesar mediante funciones de Lambda o se pueden enviar a través de un flujo de entrega de Data Firehose a un servicio de OpenSearch Amazon, lo que crea un índice de mensajes con capacidad de búsqueda. Esta configuración muestra el uso de un escenario avanzado de enrutamiento y procesamiento de mensajes mediante Servicios de AWS.\]](http://docs.aws.amazon.com/es_es/sns/latest/dg/images/firehose-architecture-es.png)
**Topics**
+ [Formato de mensajes archivados](firehose-archived-message-format-elasticsearch.md)
+ [Análisis de mensajes](firehose-message-analysis-elasticsearch.md)
# Almacenamiento y formato de las notificaciones de Amazon SNS en OpenSearch índices de servicios
En el siguiente ejemplo se muestra una notificación de Amazon SNS enviada a un índice de Amazon OpenSearch Service (OpenSearch Service) llamado. `my-index` Este índice tiene un campo de filtro de tiempo en el campo `Timestamp`. La notificación SNS se coloca en la propiedad `_source` de la carga.
**nota**
En este ejemplo, se desactivó la entrega de mensajes sin formato en el mensaje publicado. Si se desactiva la entrega de mensajes sin formato, Amazon SNS agrega metadatos JSON al mensaje, incluidas las siguientes propiedades:
`Type`
`MessageId`
`TopicArn`
`Subject`
`Timestamp`
`UnsubscribeURL`
`MessageAttributes`
Para obtener más información acerca de la entrega sin procesar, consulte [Entrega de mensajes sin procesar de Amazon SNS](sns-large-payload-raw-message-delivery.md).
```
{
"_index": "my-index",
"_type": "_doc",
"_id": "49613100963111323203250405402193283794773886550985932802.0",
"_version": 1,
"_score": null,
"_source": {
"Type": "Notification",
"MessageId": "bf32e294-46e3-5dd5-a6b3-bad65162e136",
"TopicArn": "arn:aws:sns:us-east-1:111111111111:my-topic",
"Subject": "Sample subject",
"Message": "Sample message",
"Timestamp": "2020-12-02T22:29:21.189Z",
"UnsubscribeURL": "https://sns.us-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-1:111111111111:my-topic:b5aa9bc1-9c3d-452b-b402-aca2cefc63c9",
"MessageAttributes": {
"my_attribute": {
"Type": "String",
"Value": "my_value"
}
}
},
"fields": {
"Timestamp": [
"2020-12-02T22:29:21.189Z"
]
},
"sort": [
1606948161189
]
}
```
# Análisis de los mensajes de Amazon SNS para OpenSearch los destinos del servicio
En este tema se explica cómo analizar los mensajes de Amazon SNS enviados a través de flujos de entrega a los destinos de Amazon OpenSearch Service (OpenSearch Servicio).
**Para analizar los mensajes SNS enviados a través de los flujos OpenSearch de entrega de Firehose a los destinos del servicio**
1. Configure sus recursos de OpenSearch servicio. Para obtener instrucciones, consulta [Cómo empezar a usar Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/es-gsg.html) en la *Guía para desarrolladores OpenSearch de Amazon Service*.
1. Configure el flujo de entrega. Para obtener instrucciones, consulte [Choose OpenSearch Service for Your Destination](https://docs.aws.amazon.com/firehose/latest/dev/create-destination.html#create-destination-elasticsearch) en la Guía para *desarrolladores de Amazon Data Firehose*.
1. Ejecute una consulta con OpenSearch Service Queries y Kibana. Para obtener más información, consulta el [Paso 3: Buscar documentos en un dominio de OpenSearch servicio](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/es-gsg-search.html) y [Kibana](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/es-kibana.html) en la *Guía para desarrolladores de Amazon OpenSearch Service*.
## Consulta de ejemplo
En el siguiente ejemplo, se consulta el índice `my-index` de todos los mensajes SNS recibidos en el intervalo de fechas especificado:
```
POST https://search-my-domain.us-east-1.es.amazonaws.com/my-index/_search
{
"query": {
"bool": {
"filter": [
{
"range": {
"Timestamp": {
"gte": "2020-12-08T00:00:00.000Z",
"lte": "2020-12-09T00:00:00.000Z",
"format": "strict_date_optional_time"
}
}
}
]
}
}
}
```
# Configuración de la entrega y el análisis de mensajes de Amazon SNS en destinos de Amazon Redshift
En este tema se explica cómo distribuir las notificaciones de Amazon SNS a un flujo de entrega, que a su vez publique los datos en Amazon Redshift. Con esta configuración, puede conectarse a la base de datos de Amazon Redshift y utilizar una herramienta de consulta SQL para recuperar mensajes de SNS que cumplan determinados criterios.
![\[Los mensajes publicados por un remitente en un tema de Amazon SNS se distribuyen en varias colas de Amazon SQS para que las funciones de Lambda los procesen, y también se envían a través de un flujo de entrega de Data Firehose a un clúster de Amazon Redshift para su almacenamiento y análisis en un almacén de datos de mensajes. Esta configuración muestra una arquitectura robusta de tratamiento de mensajes y almacenamiento de datos que usa Servicios de AWS.\]](http://docs.aws.amazon.com/es_es/sns/latest/dg/images/firehose-architecture-rs.png)
**Topics**
+ [Estructuración de los archivos de mensajes en tablas de Amazon Redshift](firehose-archive-table-structure-redshift.md)
+ [Análisis de los mensajes almacenados en destinos de Amazon Redshift](firehose-message-analysis-redshift.md)
# Estructuración de los archivos de mensajes de Amazon SNS en tablas de Amazon Redshift
En los puntos de conexión de Amazon Redshift, los mensajes de Amazon SNS se archivan como filas en una tabla. A continuación, se muestra un ejemplo de cómo se almacenan los datos:
**nota**
En este ejemplo, se desactivó la entrega de mensajes sin formato en el mensaje publicado. Si se desactiva la entrega de mensajes sin formato, Amazon SNS agrega metadatos JSON al mensaje, incluidas las siguientes propiedades:
`Type`
`MessageId`
`TopicArn`
`Subject`
`Message`
`Timestamp`
`UnsubscribeURL`
`MessageAttributes`
Para obtener más información acerca de la entrega sin procesar, consulte [Entrega de mensajes sin procesar de Amazon SNS](sns-large-payload-raw-message-delivery.md).
Si bien Amazon SNS agrega propiedades al mensaje con las mayúsculas que se muestran en esta lista, los nombres de columna de las tablas de Amazon Redshift aparecen en minúsculas. Para transformar los metadatos JSON en el punto de enlace de Amazon Redshift, puede utilizar el comando `COPY` SQL. Para obtener más información, consulte los [ejemplos Copiar desde JSON](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY_command_examples.html#r_COPY_command_examples-copy-from-json) y [Cargar desde datos JSON con la opción 'auto ignorecase'](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY_command_examples.html#copy-from-json-examples-using-auto-ignorecase) en la *Guía para desarrolladores de bases de datos de Amazon Redshift*.
| type | messageId | topicarn | subject | message | timestamp | unsubscribeurl | messageattributes |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Notificación | ea544832-a0d8-581d-9275-108243c46103 | arn:aws:sns:us-east-1:111111111111:my-topic | Asunto de muestra | Mensaje de muestra | 2020-12-02T00:33:32.272Z | https://sns.us-east-1.amazonaws.com/? Action=Darse de baja y =arn:aws:sns:us-east- 1:1111:my-topic:326deeeb-cbf4-45da-b92b-ca77a247813b SubscriptionArn | \$1\$1"my\$1attribute\$1":\$1\$1"Type\$1":\$1"String\$1",\$1"Value\$1":\$1"my\$1value\$1"\$1\$1 |
| Notificación | ab124832-a0d8-581d-9275-108243c46114 | arn:aws:sns:us-east-1:111111111111:my-topic | Asunto de muestra 2 | Mensaje de muestra 2 | 2020-12-03T00:18:11.129Z | https://sns.us-east-1.amazonaws.com/? Action=Darse de baja y =arn:aws:sns:us-east- 1:1111:my-topic:326deeeb-cbf4-45da-b92b-ca77a247813b SubscriptionArn | \$1\$1"my\$1attribute2\$1":\$1\$1"Type\$1":\$1"String\$1",\$1"Value\$1":\$1"my\$1value\$1"\$1\$1 |
| Notificación | ce644832-a0d8-581d-9275-108243c46125 | arn:aws:sns:us-east-1:111111111111:my-topic | Asunto de muestra 3 | Mensaje de muestra 3 | 2020-12-09T00:08:44.405Z | https://sns.us-east-1.amazonaws.com/? Action=Darse de baja y =arn:aws:sns:us-east- 1:1111:my-topic:326deeeb-cbf4-45da-b92b-ca77a247813b SubscriptionArn | \$1\$1"my\$1attribute3\$1":\$1\$1"Type\$1":\$1"String\$1",\$1"Value\$1":\$1"my\$1value\$1"\$1\$1 |
Para obtener más información sobre la distribución de notificaciones a los puntos de enlace de Amazon Redshift, consulte [Configuración de la entrega y el análisis de mensajes de Amazon SNS en destinos de Amazon Redshift](firehose-redshift-destinations.md).
# Análisis de los mensajes de Amazon SNS almacenados en destinos de Amazon Redshift
En este tema se describe cómo analizar los mensajes de Amazon SNS enviados a través de flujos de entrega a destinos de Amazon Redshift.
**Análisis de los mensajes SNS enviados a través de flujos de entrega de a destinos de Amazon Redshift**
1. Configure sus recursos de Amazon Redshift. Para obtener instrucciones, consulte [Introducción a Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/getting-started.html) en la *Guía de introducción a Amazon Redshift*.
1. Configure el flujo de entrega. Para obtener más información, consulte [Choose Amazon Redshift for Your Destination](https://docs.aws.amazon.com/firehose/latest/dev/create-destination.html#create-destination-redshift) en la *Guía para desarrolladores de Amazon Data Firehose*.
1. Ejecute una consulta. Para obtener más información, consulte [Consulta de una base de datos mediante el editor de consultas](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor.html) en la *Guía de administración de Amazon Redshift*.
## Consulta de ejemplo
En esta consulta, suponga lo siguiente:
+ Los mensajes se almacenan en la tabla `notifications` del esquema `public` predeterminado.
+ La propiedad `Timestamp` del mensaje SNS se almacena en la columna `timestamp` de la tabla con un tipo de datos de columna de `timestamptz`.
**nota**
Para transformar los metadatos JSON en el punto de enlace de Amazon Redshift, puede utilizar el comando `COPY` SQL. Para obtener más información, consulte los [ejemplos Copiar desde JSON](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY_command_examples.html#r_COPY_command_examples-copy-from-json) y [Cargar desde datos JSON con la opción 'auto ignorecase'](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY_command_examples.html#copy-from-json-examples-using-auto-ignorecase) en la *Guía para desarrolladores de bases de datos de Amazon Redshift*.
Con la siguiente consulta, se devuelven todos los mensajes SNS recibidos en el intervalo de fechas especificado:
```
SELECT *
FROM public.notifications
WHERE timestamp > '2020-12-01T09:00:00.000Z' AND timestamp < '2020-12-02T09:00:00.000Z';
```
# Configuración de la entrega de mensajes de Amazon SNS a destinos HTTP
En este tema se explica cómo los flujos de entrega publican datos en los puntos de conexión HTTP.
![\[Un publicador de un tema de Amazon SNS, que luego distribuye estos mensajes a varias colas de Amazon SQS. Estos mensajes los procesan las funciones de Lambda y también se envían a través de un flujo de entrega de Data Firehose a un punto de conexión HTTP. Esta configuración muestra cómo los Servicios de AWS funcionan juntos para facilitar el tratamiento de los mensajes y la integración con servicios HTTP externos.\]](http://docs.aws.amazon.com/es_es/sns/latest/dg/images/firehose-architecture-http.png)
**Topics**
+ [Formato de notificaciones para su entrega a destinos HTTP](firehose-delivered-message-format-http.md)
# Formato de notificaciones de Amazon SNS para su entrega a destinos HTTP
A continuación, se muestra un ejemplo de un cuerpo de solicitud HTTP POST de Amazon SNS, enviado a través de un flujo de entrega a un punto de conexión HTTP. La notificación de Amazon SNS se codifica como una carga útil base64 en la propiedad de registros.
**nota**
En este ejemplo, se desactivó la entrega de mensajes sin formato en el mensaje publicado. Para obtener más información acerca de la entrega sin procesar, consulte [Entrega de mensajes sin procesar de Amazon SNS](sns-large-payload-raw-message-delivery.md).
```
"body": {
"requestId": "ebc9e8b2-fce3-4aef-a8f1-71698bf8175f",
"timestamp": 1606255960435,
"records": [
{
"data": "eyJUeXBlIjoiTm90aWZpY2F0aW9uIiwiTWVzc2FnZUlkIjoiMjFkMmUzOGQtMmNhYi01ZjYxLTliYTItYmJiYWFhYzg0MGY2IiwiVG9waWNBcm4iOiJhcm46YXdzOnNuczp1cy1lYXN0LTE6MTExMTExMTExMTExOm15LXRvcGljIiwiTWVzc2FnZSI6IlNhbXBsZSBtZXNzYWdlIGZvciBBbWF6b24gS2luZXNpcyBEYXRhIEZpcmVob3NlIGVuZHBvaW50cyIsIlRpbWVzdGFtcCI6IjIwMjAtMTEtMjRUMjI6MDc6MzEuNjY3WiIsIlVuc3Vic2NyaWJlVVJMIjoiaHR0cHM6Ly9zbnMudXMtZWFzdC0xLmFtYXpvbmF3cy5jb20vP0FjdGlvbj1VbnN1YnNjcmliZSZTdWJzY3JpcHRpb25Bcm49YXJuOmF3czpzbnM6MTExMTExMTExMTExOm15LXRvcGljOjAxYjY5MTJjLTAwNzAtNGQ4Yi04YjEzLTU1NWJmYjc2ZTdkNCJ9"
}
]
}
```
# Archivo y análisis de mensajes de Amazon SNS: un caso de uso de ejemplo para las plataformas de venta de billetes de avión
En este tema se proporciona un tutorial sobre un caso de uso común para archivar y analizar mensajes de Amazon SNS.
La configuración de este caso de uso es una plataforma de emisión de billetes de avión que opera en un entorno regulado.
1. La plataforma está sujeta a un marco de conformidad que exige que la empresa archive todas las ventas de entradas durante un mínimo de cinco años.
1. Para cumplir el objetivo de conformidad en materia de retención de datos, la empresa suscribe un flujo de entrega a un tema de Amazon SNS existente.
1. El destino del flujo de entrega es un bucket de Amazon Simple Storage Service (Amazon S3). Con esta configuración, todos los eventos publicados en el tema de SNS se archivan en el bucket de Amazon S3.
En el siguiente diagrama, se ilustra la arquitectura de esta configuración.
![\[Una AWS arquitectura para una plataforma de venta de billetes de avión, que ilustra cómo se procesan y archivan los datos de venta de billetes. Muestra el flujo de datos de una función de Lambda a través de un tema de Amazon SNS, que luego distribuye los mensajes a las colas de Amazon SQS para el procesamiento de pagos y la detección de fraudes, gestionados por las funciones de Lambda correspondientes. Los datos también se transmiten a través de Data Firehose a un bucket de Amazon S3 para su archivo a largo plazo, lo que contribuye al cumplimiento de los requisitos de retención de datos. Esta configuración permite a la plataforma ejecutar análisis detallados de los datos de venta de entradas mediante herramientas como Amazon Athena.\]](http://docs.aws.amazon.com/es_es/sns/latest/dg/images/sns-archiving-use-case.png)
Para ejecutar análisis y obtener información sobre la venta de entradas, la empresa ejecuta consultas SQL con Amazon Athena. Por ejemplo, la empresa puede consultar para conocer los destinos más populares y los viajeros más frecuentes.
Para crear los AWS recursos para este caso de uso, puede utilizar la plantilla Consola de administración de AWS o una plantilla. CloudFormation
**Topics**
+ [Configuración de los recursos iniciales para el archivado y el análisis de mensajes AWS](firehose-example-initial-resources.md)
+ [Configuración de un flujo de Firehose para el archivo de mensajes](firehose-example-create-delivery-stream.md)
+ [Suscripción del flujo de entrega al tema](firehose-example-subscribe-delivery-stream-to-topic.md)
+ [Pruebas y consulta de una configuración para una administración de datos eficaz](firehose-example-test-and-query.md)
+ [Automatizar el archivado de mensajes con una plantilla CloudFormation](firehose-example-cfn.md)
# Configuración de los AWS recursos iniciales para el archivado y el análisis de mensajes de Amazon SNS
En este tema se describe cómo crear los recursos necesarios para el [caso de uso de ejemplo de análisis y archivado de mensajes](firehose-example-use-case.md):
+ Un bucket de Amazon Simple Storage Service (Amazon S3)
+ Dos colas de Amazon Simple Queue Service (Amazon SQS)
+ Un tema de Amazon SNS
+ Dos suscripciones de Amazon SQS al tema de Amazon SNS
**Para crear los recursos iniciales, siga estos pasos:**
1. Cree un bucket de Amazon S3:
1. Abra la [consola de Amazon S3](https://console.aws.amazon.com/s3/home).
1. Elija **Crear bucket**.
1. En **Nombre del bucket**, ingrese un nombre único. Mantenga los otros campos como valores predeterminados.
1. Elija **Crear bucket**.
Para obtener más información sobre los buckets de Amazon S3, consulte [Creación de un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) en la *Guía del usuario de Amazon Simple Storage Service* y [Trabajar con buckets de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingBucket.html) en la *Guía del usuario de Amazon Simple Storage Service*.
1. Cree las dos colas de Amazon SQS:
1. Abra la [consola de Amazon SQS](https://console.aws.amazon.com/sqs/home).
1. Elige **Crear cola**.
1. En **Tipo**, seleccione **Estándar**.
1. En **Nombre**, escriba **ticketPaymentQueue**.
1. En **Política de acceso**, en **Elegir método**, elija **Avanzado**.
1. En el cuadro Política de JSON, pegue la siguiente política:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "sns.amazonaws.com"
},
"Action": "sqs:SendMessage",
"Resource": "*",
"Condition": {
"ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-east-1:123456789012:ticketTopic"
}
}
}
]
}
```
------
En esta política de acceso, sustituya el Cuenta de AWS número (*123456789012*) por el suyo y cambie la AWS región (*us-east-1*) en consecuencia.
1. Elige **Crear cola**.
1. Repita estos pasos para crear una segunda cola SQS llamada **ticketFraudQueue**.
Para obtener más información sobre la creación de colas SQS, consulte [Creación de una cola de Amazon SQS (consola)](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-configure-create-queue.html) en la *Guía para desarrolladores de Amazon Simple Queue Service*.
1. Cree el tema de SNS:
1. Abra la página [Topics (Temas)](https://console.aws.amazon.com/sns/home#/topics) en la consola de Amazon SNS.
1. Seleccione **Crear tema**.
1. En **Detalles**, en **Tipo**, elija **Estándar**.
1. En **Nombre**, escriba **ticketTopic**.
1. Seleccione **Crear tema**.
Para obtener más información sobre la creación de temas de SNS, consulte [Creación de un tema de Amazon SNS](sns-create-topic.md).
1. Suscriba las colas de SQS al tema de SNS:
1. En la [consola de Amazon SNS](https://console.aws.amazon.com/sns/home#/topics), en la página de detalles del tema **TicketTopic**, elija **Crear suscripción**.
1. En **Detalles**, en **Protocolo**, elija **Amazon SQS**.
1. Para **Endpoint**, elija el nombre de recurso de Amazon (ARN) de la **ticketPaymentQueue**cola.
1. Seleccione **Crear subscripción**.
1. Repita estos pasos para crear una segunda suscripción con el ARN de la **ticketFraudQueue**cola.
Para obtener más información sobre la suscripción a los temas de SNS, consulte [Creación de una suscripción a un tema de Amazon SNS](sns-create-subscribe-endpoint-to-topic.md). También puede suscribir colas de SQS a temas de SNS desde la consola de Amazon SQS. Para obtener más información, consulte [Suscripción de una cola de Amazon SQS a un tema de Amazon SNS (consola)](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-configure-subscribe-queue-sns-topic.html) en la *Guía para desarrolladores de Amazon Simple Queue Service*.
Ha creado los recursos iniciales para este caso de uso de ejemplo. Para continuar, consulte [Configuración de un flujo de entrega de Amazon Data Firehose para el archivo de mensajes de Amazon SNS](firehose-example-create-delivery-stream.md).
# Configuración de un flujo de entrega de Amazon Data Firehose para el archivo de mensajes de Amazon SNS
En este tema se explica cómo crear el flujo de entrega de Amazon Data Firehose para el [caso de uso de ejemplo de archivo y análisis de mensajes](firehose-example-use-case.md).
**Cómo crear el flujo de entrega de Amazon Data Firehose**
1. Abra la [consola de servicios de Amazon Data Firehose](https://console.aws.amazon.com/kinesis/home).
1. Seleccione **Firehose** y, a continuación, elija **Crear un flujo de entrega**.
1. En la página **Nuevo flujo de entrega**, en **Nombre del flujo de entrega**, ingrese **ticketUploadStream** y, a continuación, elija **Siguiente**.
1. En la página **Procesar registros**, elija **Siguiente**.
1. En la página **Elegir un destino**, haga lo siguiente:
1. En **Destino**, elija **Amazon S3**.
1. En **Destino S3**, en **bucket de S3**, elija el bucket de S3 que [creó en un principio](firehose-example-initial-resources.md).
1. Elija **Siguiente**.
1. En la página **Ajustar configuración**, en **Condiciones del búfer S3**, realice una de las siguientes operaciones:
+ En **Tamaño del búfer**, ingrese **1**.
+ En **Intervalo del búfer**, ingrese **60**.
Con el uso de estos valores para el búfer de Amazon S3, puede probar con rapidez la configuración. La primera condición que se cumple desencadena la entrega de datos al bucket de S3.
1. En la página **Configurar ajustes**, en **Permisos**, elija crear un rol AWS Identity and Access Management (IAM) con los permisos necesarios asignados automáticamente. A continuación, elija **Siguiente**.
1. En la página **Revisar**, elija **Crear un flujo de entrega**.
1. En la **página de transmisiones de entrega de Amazon Data Firehose,** selecciona la transmisión de entrega que acabas de crear () **ticketUploadStream**. En la pestaña **Detalles**, anote el nombre de recurso de Amazon (ARN) del flujo para después.
Para obtener más información sobre la creación de flujos de entrega, consulte [Creación de un flujo de entrega de Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html) en la *Guía para desarrolladores de Amazon Data Firehose*. Para obtener más información sobre la creación de funciones de IAM, consulte [Creación de una función para delegar permisos a un AWS servicio](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) en la Guía del usuario de *IAM*.
Ha creado el flujo de entrega de Firehose con los permisos necesarios. Para continuar, consulte [Suscripción del flujo de entrega de Firehose al tema de Amazon SNS](firehose-example-subscribe-delivery-stream-to-topic.md).
# Suscripción del flujo de entrega de Firehose al tema de Amazon SNS
En este tema se explica cómo crear los siguientes recursos para el [caso de uso de ejemplo de análisis y archivado de mensajes](firehose-example-use-case.md):
+ La función AWS Identity and Access Management (IAM) que permite a la suscripción a Amazon SNS colocar registros en el flujo de entrega.
+ La suscripción del flujo de entrega de Firehose al tema de Amazon SNS.
**Con el fin de crear el rol de IAM para la suscripción a Amazon SNS, siga estos pasos:**
1. Abra la [página Roles](https://console.aws.amazon.com/iam/home?#/roles) en la consola de IAM.
1. Elija **Create role**.
1. En **Seleccionar el tipo de entidad de confianza**, elija **Servicio de AWS **.
1. En **Elegir un caso de uso**, elija **SNS**. A continuación, elija **Siguiente: Permisos)**.
1. Elija **Siguiente: Etiquetas**.
1. Elija **Siguiente: Revisar**.
1. En la página **Revisión**, en **Nombre del rol**, ingrese **ticketUploadStreamSubscriptionRole**. A continuación, elija **Crear rol**.
1. Cuando se cree el rol, elija su nombre () **ticketUploadStreamSubscriptionRole**.
1. En la página **Resumen**, elija **Agregar política en línea**.
1. En la página **Crear política**, elija la pestaña **JSON** y, a continuación, pegue la siguiente política en el cuadro:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"firehose:DescribeDeliveryStream",
"firehose:ListDeliveryStreams",
"firehose:ListTagsForDeliveryStream",
"firehose:PutRecord",
"firehose:PutRecordBatch"
],
"Resource": [
"arn:aws:firehose:us-east-1:123456789012:deliverystream/ticketUploadStream"
],
"Effect": "Allow"
}
]
}
```
------
En esta política, sustituya el Cuenta de AWS número (*123456789012*) por el suyo propio y cambie la AWS región (*us-east-1*) en consecuencia.
1. Elija **Revisar política**.
1. En la página **Crear política**, en **Nombre**, ingrese **FirehoseSnsPolicy**. A continuación, seleccione **Create policy** (Crear política).
1. En la página **Resumen** del rol, tenga en cuenta el **ARN de rol** para después.
Para obtener más información sobre la creación de funciones de IAM, consulte [Creación de una función para delegar permisos a un AWS servicio](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) en la Guía del *usuario de IAM*.
**Suscripción del flujo de entrega de Firehose al tema de SNS**
1. Abra la página [Topics (Temas)](https://console.aws.amazon.com/sns/home#/topics) en la consola de Amazon SNS.
1. En la pestaña **Suscripciones**, elija **Crear suscripción**.
1. En **Detalles**, para **Protocolo**, elija ****.
1. Para **Endpoint**, introduzca el nombre de recurso de Amazon (ARN) de la transmisión de **ticketUploadStream**entrega que creó anteriormente. Por ejemplo, escriba **arn:aws:firehose:us-east-1:123456789012:deliverystream/ticketUploadStream**.
1. **En el ARN del rol de suscripción**, introduzca el ARN del rol de **ticketUploadStreamSubscriptionRole**IAM que creó anteriormente. Por ejemplo, escriba **arn:aws:iam::123456789012:role/ticketUploadStreamSubscriptionRole**.
1. Seleccione el cuadro de verificación **Habilitar la entrega de mensajes sin procesar**.
1. Seleccione **Crear subscripción**.
Ha creado el rol de IAM y la suscripción al tema de SNS. Para continuar, consulte [Pruebas y consulta de una configuración de Amazon SNS para una administración de datos eficaz](firehose-example-test-and-query.md).
# Pruebas y consulta de una configuración de Amazon SNS para una administración de datos eficaz
En este tema se explica cómo probar el [caso de uso de ejemplo de archivado y análisis de mensajes](firehose-example-use-case.md) mediante la publicación de un mensaje en el tema de Amazon SNS. Entre las instrucciones se incluye una consulta de ejemplo que puede ejecutar y adaptar a sus propias necesidades.
**Para probar la configuración**
1. Abra la página [Topics (Temas)](https://console.aws.amazon.com/sns/home#/topics) en la consola de Amazon SNS.
1. Elija el tema **ticketTopic**.
1. Elija **Publish message (Publicar mensaje)**.
1. En la página **Publicar mensaje en tema**, ingrese lo siguiente en el cuerpo del mensaje. Agregue un carácter de nueva línea al final del mensaje.
```
{"BookingDate":"2020-12-15","BookingTime":"2020-12-15 04:15:05","Destination":"Miami","FlyingFrom":"Vancouver","TicketNumber":"abcd1234"}
```
Mantenga todas las demás opciones en sus valores predeterminados.
1. Elija **Publish message (Publicar mensaje)**.
Para obtener más información sobre la publicación de mensajes, consulte [Publicación de un mensaje de Amazon SNS](sns-publishing.md).
1. Después del intervalo de flujo de entrega de 60 segundos, abra la [consola de Amazon Simple Storage Service (Amazon S3)](https://console.aws.amazon.com/s3/home) y elija el bucket de Amazon S3 que [creó en un principio](firehose-example-initial-resources.md).
El mensaje publicado aparece en el bucket.
**Para consultar los datos, siga estos pasos:**
1. Abra la [consola de Amazon Athena](https://console.aws.amazon.com/athena/home).
1. Ejecute una consulta.
Por ejemplo, supongamos que en la tabla `notifications` del esquema `default` se incluyen los siguientes datos:
```
{"BookingDate":"2020-12-15","BookingTime":"2020-12-15 04:15:05","Destination":"Miami","FlyingFrom":"Vancouver","TicketNumber":"abcd1234"}
{"BookingDate":"2020-12-15","BookingTime":"2020-12-15 11:30:15","Destination":"Miami","FlyingFrom":"Omaha","TicketNumber":"efgh5678"}
{"BookingDate":"2020-12-15","BookingTime":"2020-12-15 3:30:10","Destination":"Miami","FlyingFrom":"NewYork","TicketNumber":"ijkl9012"}
{"BookingDate":"2020-12-15","BookingTime":"2020-12-15 12:30:05","Destination":"Delhi","FlyingFrom":"Omaha","TicketNumber":"mnop3456"}
```
Para buscar el destino principal, ejecute la siguiente consulta:
```
SELECT destination
FROM default.notifications
GROUP BY destination
ORDER BY count(*) desc
LIMIT 1;
```
Para consultar los tickets vendidos durante un intervalo de fecha y hora específico, ejecute una consulta como la siguiente:
```
SELECT *
FROM default.notifications
WHERE bookingtime
BETWEEN TIMESTAMP '2020-12-15 10:00:00'
AND TIMESTAMP '2020-12-15 12:00:00';
```
Puede adaptar ambas consultas de muestra según sus propias necesidades. Si desea obtener más información sobre el uso de Athena para ejecutar consultas, consulte [Introducción](https://docs.aws.amazon.com/athena/latest/ug/getting-started.html) en la *Guía del usuario de Amazon Athena*.
## Limpieza
Para evitar incurrir en cargos de uso después de haber terminado la prueba, elimine los siguientes recursos que creó durante el tutorial:
+ Suscripciones a Amazon SNS
+ Tema de Amazon SNS
+ Colas de Amazon Simple Queue Service (Amazon SQS)
+ Bucket de Amazon S3
+ flujo de entrega
+ AWS Identity and Access Management Funciones y políticas (IAM)
# Automatizar el archivado de mensajes de Amazon SNS con una plantilla CloudFormation
Para automatizar la implementación de [caso de uso de ejemplo de archivado y análisis de mensajes](firehose-example-use-case.md) de Amazon SNS, puede usar la siguiente plantilla YAML:
```
---
AWSTemplateFormatVersion: '2010-09-09'
Description: Template for creating an SNS archiving use case
Resources:
ticketUploadStream:
DependsOn:
- ticketUploadStreamRolePolicy
Type: AWS::KinesisFirehose::DeliveryStream
Properties:
S3DestinationConfiguration:
BucketARN: !Sub 'arn:${AWS::Partition}:s3:::${ticketArchiveBucket}'
BufferingHints:
IntervalInSeconds: 60
SizeInMBs: 1
CompressionFormat: UNCOMPRESSED
RoleARN: !GetAtt ticketUploadStreamRole.Arn
ticketArchiveBucket:
Type: AWS::S3::Bucket
ticketTopic:
Type: AWS::SNS::Topic
ticketPaymentQueue:
Type: AWS::SQS::Queue
ticketFraudQueue:
Type: AWS::SQS::Queue
ticketQueuePolicy:
Type: AWS::SQS::QueuePolicy
Properties:
PolicyDocument:
Statement:
Effect: Allow
Principal:
Service: sns.amazonaws.com
Action:
- sqs:SendMessage
Resource: '*'
Condition:
ArnEquals:
aws:SourceArn: !Ref ticketTopic
Queues:
- !Ref ticketPaymentQueue
- !Ref ticketFraudQueue
ticketUploadStreamSubscription:
Type: AWS::SNS::Subscription
Properties:
TopicArn: !Ref ticketTopic
Endpoint: !GetAtt ticketUploadStream.Arn
Protocol: firehose
SubscriptionRoleArn: !GetAtt ticketUploadStreamSubscriptionRole.Arn
ticketPaymentQueueSubscription:
Type: AWS::SNS::Subscription
Properties:
TopicArn: !Ref ticketTopic
Endpoint: !GetAtt ticketPaymentQueue.Arn
Protocol: sqs
ticketFraudQueueSubscription:
Type: AWS::SNS::Subscription
Properties:
TopicArn: !Ref ticketTopic
Endpoint: !GetAtt ticketFraudQueue.Arn
Protocol: sqs
ticketUploadStreamRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17 '
Statement:
- Sid: ''
Effect: Allow
Principal:
Service: firehose.amazonaws.com
Action: sts:AssumeRole
ticketUploadStreamRolePolicy:
Type: AWS::IAM::Policy
Properties:
PolicyName: FirehoseticketUploadStreamRolePolicy
PolicyDocument:
Version: '2012-10-17 '
Statement:
- Effect: Allow
Action:
- s3:AbortMultipartUpload
- s3:GetBucketLocation
- s3:GetObject
- s3:ListBucket
- s3:ListBucketMultipartUploads
- s3:PutObject
Resource:
- !Sub 'arn:aws:s3:::${ticketArchiveBucket}'
- !Sub 'arn:aws:s3:::${ticketArchiveBucket}/*'
Roles:
- !Ref ticketUploadStreamRole
ticketUploadStreamSubscriptionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17 '
Statement:
- Effect: Allow
Principal:
Service:
- sns.amazonaws.com
Action:
- sts:AssumeRole
Policies:
- PolicyName: SNSKinesisFirehoseAccessPolicy
PolicyDocument:
Version: '2012-10-17 '
Statement:
- Action:
- firehose:DescribeDeliveryStream
- firehose:ListDeliveryStreams
- firehose:ListTagsForDeliveryStream
- firehose:PutRecord
- firehose:PutRecordBatch
Effect: Allow
Resource:
- !GetAtt ticketUploadStream.Arn
```
# Distribución ramificada de las notificaciones de Amazon SNS a las funciones de Lambda para su procesamiento automatizado
Amazon SNS se integra con AWS Lambda, lo que le permite activar funciones de Lambda en respuesta a las notificaciones de Amazon SNS. Cuando se publica un mensaje en un tema de SNS que tiene una función de Lambda suscrita, la función de Lambda se invoca con la carga útil del mensaje publicado. La función Lambda recibe la carga útil del mensaje como parámetro de entrada y puede manipular la información del mensaje, publicar el mensaje en otros temas de SNS o enviar el mensaje a otros servicios. AWS
Además, Amazon SNS también admite los atributos de estado de entrega de los mensajes para las notificaciones enviadas a los puntos de conexión de Lambda. Para obtener más información, consulte [Estado de entrega de mensajes de Amazon SNS](sns-topic-attributes.md).
**Topics**
+ [Requisitos previos](lambda-prereq.md)
+ [Suscripción de una función a un tema](lambda-console.md)
# Requisitos previos para integrar Amazon SNS con las funciones de Lambda en las distintas regiones
Para invocar funciones de Lambda mediante notificaciones de Amazon SNS, necesita lo siguiente:
+ Una función de Lambda
+ Un tema de Amazon SNS
Para obtener información acerca de cómo crear una función de Lambda para utilizarla con Amazon SNS, consulte [Uso de Lambda con Amazon SNS](https://docs.aws.amazon.com/lambda/latest/dg/with-sns-example.html). Para obtener más información acerca de la creación de un tema de Amazon SNS, consulte [Crear un tema](https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html).
Cuando se utiliza Amazon SNS para enviar mensajes desde regiones registradas a regiones habilitadas de forma predeterminada, debe modificar la política creada en la función de AWS Lambda reemplazando la entidad principal `sns.amazonaws.com` por `sns..amazonaws.com`.
Por ejemplo, si desea suscribir una función de Lambda en EE. UU. Este (Norte de Virginia) a un tema de SNS en Asia-Pacífico (Hong Kong), cambie la entidad principal en la política de funciones de AWS Lambda a `sns.ap-east-1.amazonaws.com`. Las regiones registradas incluyen cualquier región lanzada después del 20 de marzo de 2019, que incluye Asia-Pacífico (Hong Kong), Oriente Medio (Baréin), UE (Milán) y África (Ciudad del Cabo). Las regiones lanzadas antes del 20 de marzo de 2019 están habilitadas de forma predeterminada.
**nota**
AWS no admite la entrega entre regiones a Lambda desde una región que esté habilitada de forma predeterminada a una región de suscripción voluntaria. Además, no se admite el reenvío entre regiones de mensajes SNS desde regiones registradas a otras regiones registradas.
# Suscripción de una función de Lambda a un tema de Amazon SNS
En este tema se explica cómo suscribir una función de Lambda a un tema de Amazon SNS, lo que permite que los mensajes publicados activen la función.
1. Inicie sesión en la [consola de Amazon SNS](https://console.aws.amazon.com/sns/home).
1. En el panel de navegación, elija **Temas**.
1. Elija un tema en la página **Temas**.
1. En la sección **Suscripciones**, elija **Crear suscripción**.
1. En la página **Crear suscripción**, en la sección **Detalles**, haga lo siguiente:
1. Compruebe el **ARN de tema** elegido.
1. **En Protocolo, elija.** AWS Lambda
1. En **Punto de conexión**, escriba el ARN de una función.
1. Elija **Crear suscripción**.
Cuando se publica un mensaje en un tema de SNS que tiene una función de Lambda suscrita, la función de Lambda se invoca con la carga útil del mensaje publicado. Para obtener información sobre cómo usarlo AWS Lambda con Amazon SNS, incluido un tutorial, consulte [Uso AWS Lambda con Amazon SNS.](https://docs.aws.amazon.com/lambda/latest/dg/with-sns.html)
# Distribución ramificada de notificaciones de Amazon SNS a colas de Amazon SQS para su procesamiento asíncrono
[Amazon SNS](https://aws.amazon.com/sns/) funciona conjuntamente con Amazon Simple Queue Service (Amazon SQS). Estos servicios ofrecen a los desarrolladores diferentes beneficios. Con Amazon SNS, las aplicaciones pueden enviar mensajes en los que el tiempo es esencial a varios suscriptores a través del mecanismo “push”, lo que elimina la necesidad de comprobar o “sondear” de forma periódica en busca de actualizaciones. Amazon SQS es un servicio de cola de mensajes que emplean las aplicaciones distribuidas para intercambiar mensajes mediante un modelo de sondeo, y puede utilizarse para desacoplar los componentes de envío y los de recepción, sin necesitar que cada componente esté disponible de forma simultánea. Al utilizar Amazon SNS y Amazon SQS de forma conjunta, los mensajes pueden entregarse a aquellas aplicaciones que requieran la notificación inmediata de un evento y también pueden conservarse en una cola de Amazon SQS para que otras aplicaciones los procesen posteriormente.
Cuando suscribe una cola de Amazon SQS a un tema de Amazon SNS, puede publicar un mensaje en el tema y Amazon SNS envía un mensaje Amazon SQS a la cola suscrita. En el mensaje de Amazon SQS se incluye el tema y el mensaje que se publicaron en el tema junto con los metadatos del mensaje en un documento JSON. El mensaje de Amazon SQS tendrá un aspecto similar al documento JSON siguiente.
```
{
"Type" : "Notification",
"MessageId" : "63a3f6b6-d533-4a47-aef9-fcf5cf758c76",
"TopicArn" : "arn:aws:sns:us-west-2:123456789012:MyTopic",
"Subject" : "Testing publish to subscribed queues",
"Message" : "Hello world!",
"Timestamp" : "2012-03-29T05:12:16.901Z",
"SignatureVersion" : "1",
"Signature" : "EXAMPLEnTrFPa3...",
"SigningCertURL" : "https://sns.us-west-2.amazonaws.com/SimpleNotificationService-f3ecfb7224c7233fe7bb5f59f96de52f.pem",
"UnsubscribeURL" : "https://sns.us-west-2.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-west-2:123456789012:MyTopic:c7fe3a54-ab0e-4ec2-88e0-db410a0f2bee"
}
```
# Suscripción de una cola de Amazon SQS a un tema de Amazon SNS
Para habilitar un tema de Amazon SNS de modo que envíe mensajes a una cola de Amazon SQS, elija uno de estos procedimientos:
+ Utilice la [consola de Amazon SQS](https://console.aws.amazon.com/sqs/), lo que simplifica el proceso. Para obtener más información, consulte [Suscripción de una cola de Amazon SQS a un tema de Amazon SNS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-configure-subscribe-queue-sns-topic.html) en la *Guía para desarrolladores de Amazon Simple Queue Service*.
+ Utilice los siguientes pasos:
1. [Obtenga el nombre de recurso de Amazon (ARN) de la cola a la que desea enviar mensajes y del tema al que desea suscribir la cola.](#SendMessageToSQS.arn)
1. [Conceda el permiso `sqs:SendMessage` al tema de Amazon SNS para que pueda enviar mensajes a la cola.](#SendMessageToSQS.sqs.permissions)
1. [Suscriba la cola al tema de Amazon SNS.](#SendMessageToSQS.subscribe)
1. [Conceda a los usuarios de IAM o a Cuentas de AWS los permisos adecuados para publicar en el tema de Amazon SNS y leer los mensajes de la cola de Amazon SQS.](#SendMessageToSQS.iam.permissions)
1. [Pruebe el procedimiento publicando un mensaje en el tema y leyendo el mensaje de la cola.](#SendMessageToSQS.test)
Si desea saber cómo configurar un tema para enviar mensajes a una cola que está en otra cuenta de AWS, consulte [Envío de mensajes de Amazon SNS a una cola de Amazon SQS de otra cuenta](sns-send-message-to-sqs-cross-account.md).
Para ver una CloudFormation plantilla que crea un tema que envía mensajes a dos colas, consulte[Automatice la mensajería de Amazon SNS a Amazon SQS con AWS CloudFormation](SendMessageToSQS.cloudformation.md).
## Paso 1: obtener el ARN de la cola y el del tema
Cuando suscriba una cola a un tema, necesitará una copia del ARN de la cola. Del mismo modo, cuando conceda permiso para que el tema envíe mensajes a la cola, necesitará una copia del ARN del tema.
Para obtener el ARN de la cola, puede utilizar la consola Amazon SQS o la acción de la API. [GetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/Query_QueryGetQueueAttributes.html)
**Para obtener el ARN de la cola de la consola de Amazon SQS, siga estos pasos:**
1. Inicie sesión en la consola de Amazon SQS Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/sqs/](https://console.aws.amazon.com/sqs/)
1. Seleccione la casilla de la cola cuyo ARN quiere obtener.
1. En la sección **Detalles**, copie el valor del ARN de forma que pueda utilizarlo para suscribirse al tema de Amazon SNS.
Para obtener el ARN del tema, puede utilizar la consola de Amazon SNS, el comando `[sns-get-topic-attributes](https://docs.aws.amazon.com/cli/latest/reference/sns/get-topic-attributes.html)` o la acción `[GetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/Query_QueryGetQueueAttributes.html)` de la API.
**Para obtener el ARN del tema desde la consola de Amazon SNS, siga estos pasos:**
1. Inicie sesión en la [consola de Amazon SNS](https://console.aws.amazon.com/sns/home).
1. En el panel de navegación, seleccione el tema cuyo ARN desea obtener.
1. En la sección **Detalles**, copie el valor **ARN** del tema de forma que pueda utilizarlo para conceder permiso al tema de Amazon SNS y enviar mensajes a la cola.
## Paso 2: conceder permiso al tema de Amazon SNS y enviar mensajes a la cola de Amazon SQS
Para que un tema de Amazon SNS pueda enviar mensajes a una cola, debe establecer una política en la cola que permita que el tema de Amazon SNS pueda ejecutar la acción `sqs:SendMessage`.
Antes de suscribir una cola a un tema, necesita un tema y una cola. Si aún no ha creado un tema o una cola, créelos ahora. Para obtener más información, consulte [Creación de un tema](sns-create-topic.md) y [Creación de una cola](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/step-create-queue.html) en la *Guía para desarrolladores de Amazon Simple Queue Service*.
Para establecer una política en una cola, puede utilizar la consola Amazon SQS o la acción de [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/Query_QuerySetQueueAttributes.html)la API. Antes de comenzar, asegúrese de que dispone del ARN del tema al que desea conceder permiso para enviar mensajes a la cola. Si está suscrito a una cola para varios temas, la política debe contener un elemento `Statement` para cada tema.
**Para establecer una SendMessage política en una cola mediante la consola Amazon SQS**
1. Inicie sesión en la consola de Amazon SQS Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/sqs/](https://console.aws.amazon.com/sqs/)
1. Seleccione la casilla de la cola cuya política desea establecer, elija la pestaña **Política de acceso** y, a continuación, elija **Editar**.
1. En la sección **Política de acceso**, defina quién puede acceder a la cola.
+ Añada una condición que permita la acción para el tema.
+ Establezca `Principal` para que sea el servicio de Amazon SNS, como se muestra en el ejemplo siguiente.
+ Utilice las claves de condición global [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) o [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) para protegerse del escenario de [suplente confuso](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html). Para usar estas claves de condición, establezca el valor en el ARN de su tema. Si su cola está suscrita a varios temas, puede utilizar `aws:SourceAccount` en su lugar.
Por ejemplo, la siguiente política permite MyTopic enviar mensajes a MyQueue.
```
{
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "sns.amazonaws.com"
},
"Action": "sqs:SendMessage",
"Resource": "arn:aws:sqs:us-east-2:123456789012:MyQueue",
"Condition": {
"ArnEquals": {
"aws:SourceArn": "arn:aws:sns:us-east-2:123456789012:MyTopic"
}
}
}
]
}
```
## Paso 3: suscribir la cola al tema de Amazon SNS
Para enviar mensajes a una cola a través de un tema, debe suscribir la cola al tema de Amazon SNS. La cola se especifica con el ARN. Para suscribirse a un tema, puede utilizar la consola de Amazon SNS, el comando `[sns-subscribe](https://docs.aws.amazon.com/cli/latest/reference/sns/subscribe.html)` de la CLI o la acción de API `[Subscribe](https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html)`. Antes de comenzar, asegúrese de que tiene el ARN de la cola que desea suscribir.
1. Inicie sesión en la [consola de Amazon SNS](https://console.aws.amazon.com/sns/home).
1. En el panel de navegación, elija **Temas**.
1. Elija un tema en la página **Temas**.
1. En la ***MyTopic*** página, en la página **Suscripciones**, selecciona **Crear** suscripción.
1. En la página **Crear suscripción**, en la sección **Detalles**, haga lo siguiente:
1. Verifique el **ARN del tema**.
1. En **Protocolo**, elija **Amazon SQS**.
1. En **Punto de conexión**, indique el ARN de una cola de Amazon SQS.
1. Elija **Crear suscripción**.
Cuando se confirme la suscripción, el campo **ID de suscripción** de la nueva suscripción mostrará su ID de suscripción. Si el propietario de la cola crea la suscripción, esta se confirmará de forma automática y se activará casi de inmediato.
Normalmente, suscribirá su propia cola a su propio tema en su propia cuenta. Sin embargo, también puede suscribir una cola de otra cuenta a su tema. Si el usuario que crea la suscripción no es el propietario de la cola (por ejemplo, si un usuario de una cuenta A suscribe una cola de una cuenta B a un tema de la cuenta A), la suscripción deberá confirmarse. Para obtener más información sobre cómo suscribir una cola desde otra cuenta y confirmar la suscripción, consulte [Envío de mensajes de Amazon SNS a una cola de Amazon SQS de otra cuenta](sns-send-message-to-sqs-cross-account.md).
## Paso 4: conceder a los usuarios permisos para las acciones adecuadas del tema y la cola
Debe usar AWS Identity and Access Management (IAM) para permitir que solo los usuarios adecuados publiquen en el tema de Amazon SNS y en los mensajes de la read/delete cola de Amazon SQS. Para obtener más información sobre el control de las acciones que pueden realizar los usuarios de IAM en los temas y las colas, consulte [Uso de políticas basadas en identidades con Amazon SNS](sns-using-identity-based-policies.md) e [Identity and Access Management en Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/UsingIAM.html) en la Guía para desarrolladores de Amazon Simple Queue Service.
Hay dos formas de controlar el acceso a un tema o una cola:
+ [Añada una política a un usuario o un grupo de IAM](#SendMessageToSQS.iam.permissions.user). La forma más sencilla de conceder a los usuarios permisos para temas o colas consiste en crear un grupo, añadir la política adecuada al grupo y, a continuación, añadir usuarios a dicho grupo. Es mucho más fácil añadir y eliminar usuarios de un grupo que mantener un seguimiento de las políticas que se han configurado para los distintos usuarios.
+ [Añada una política a un tema o una cola](#SendMessageToSQS.iam.permissions.resource). Si quiere conceder permisos sobre un tema o una cola a otra AWS cuenta, la única forma de hacerlo es añadiendo una política que tenga como principal la parte a la que Cuenta de AWS desea conceder permisos.
Debe utilizar el primer método para la mayoría de los casos (aplicar políticas a grupos y administrar los permisos de los usuarios añadiendo o eliminando los usuarios a los grupos). Si necesita conceder permisos a un usuario de otra cuenta, debe utilizar el segundo método.
### Cómo añadir una política a un usuario o un grupo de IAM
Si ha añadido la siguiente política a un usuario o grupo de IAM, debería conceder a ese usuario o a los miembros de ese grupo permiso para realizar la `sns:Publish` acción sobre el tema MyTopic.
```
{
"Statement": [
{
"Effect": "Allow",
"Action": "sns:Publish",
"Resource": "arn:aws:sns:us-east-2:123456789012:MyTopic"
}
]
}
```
Si añadiera la siguiente política a un usuario o grupo de IAM, le daría permiso a ese usuario o a los miembros de ese grupo para realizar las `sqs:DeleteMessage` acciones `sqs:ReceiveMessage` y acciones de las colas MyQueue 1 y 2. MyQueue
```
{
"Statement": [
{
"Effect": "Allow",
"Action": [
"sqs:ReceiveMessage",
"sqs:DeleteMessage"
],
"Resource": [
"arn:aws:sqs:us-east-2:123456789012:MyQueue1",
"arn:aws:sqs:us-east-2:123456789012:MyQueue2"
]
}
]
}
```
### Cómo añadir una política a un tema o una cola
Las siguientes políticas de ejemplo muestran cómo conceder a otra cuenta permisos sobre un tema y una cola.
**nota**
Cuando concedes a otra persona el Cuenta de AWS acceso a un recurso de tu cuenta, también concedes permisos a ese recurso a los usuarios de IAM que tienen acceso de nivel de administrador (acceso comodín). Al resto de los usuarios de IAM de la otra cuenta se les deniega de manera automática el acceso al recurso. Si desea conceder a usuarios específicos de IAM en esa Cuenta de AWS acceso a su recurso, la cuenta o el usuario de IAM con acceso de nivel de administrador debe delegar permisos para el recurso a esos usuarios de IAM. Para obtener más información acerca de la delegación entre cuentas, consulte [Cómo habilitar el acceso entre cuentas](https://docs.aws.amazon.com/IAM/latest/UserGuide/Delegation.html) en la *Guía del usuario de IAM*.
Si agregas la siguiente política a un tema MyTopic de la cuenta 123456789012, darías permiso a la cuenta 111122223333 para realizar la acción en ese tema. `sns:Publish`
```
{
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "111122223333"
},
"Action": "sns:Publish",
"Resource": "arn:aws:sns:us-east-2:123456789012:MyTopic"
}
]
}
```
Si agregas la siguiente política a una cola MyQueue en la cuenta 123456789012, darías permiso a la cuenta 111122223333 para realizar las acciones y acciones de esa cola. `sqs:ReceiveMessage` `sqs:DeleteMessage`
```
{
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "111122223333"
},
"Action": [
"sqs:DeleteMessage",
"sqs:ReceiveMessage"
],
"Resource": [
"arn:aws:sqs:us-east-2:123456789012:MyQueue"
]
}
]
}
```
## Paso 5: probar las suscripciones de un tema a una cola
Puede probar las suscripciones de un tema a una cola publicando en el tema y viendo el mensaje que el tema envía a la cola.
**Para publicar en un tema mediante la consola de Amazon SNS, siga estos pasos:**
1. Con las credenciales del usuario de IAM Cuenta de AWS o del usuario de IAM con permiso para publicar en el tema, inicie sesión en la consola de Amazon SNS Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/sns/](https://console.aws.amazon.com/sns/home)
1. En el panel de navegación, seleccione el tema y elija **Publicar en tema**.
1. En el cuadro **Asunto**, escriba un asunto (por ejemplo, **Testing publish to queue**), en el cuadro **Mensaje**, introduzca algún texto (por ejemplo, **Hello world\$1**) y, por último, elija **Publicar mensaje**. Aparecerá el siguiente mensaje: Your message has been successfully published.
**Para ver el mensaje del tema mediante la consola de Amazon SQS, siga estos pasos:**
1. Con las credenciales del usuario de IAM Cuenta de AWS o del usuario de IAM con permiso para ver los mensajes de la cola, inicie sesión en la consola de Amazon SQS Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/sqs/](https://console.aws.amazon.com/sqs/)
1. Elija una **cola** que esté suscrita al tema.
1. Elija **Enviar y recibir mensajes** y, a continuación, elija **Sondeo de mensajes**. Aparecerá un mensaje con el tipo **Notificación**.
1. En la columna **Cuerpo**, elija **Más detalles**. El cuadro **Detalles del mensaje** contiene un documento JSON con el tema y el mensaje que ha publicado en el tema. El mensaje tiene un aspecto similar al documento JSON siguiente.
```
{
"Type" : "Notification",
"MessageId" : "63a3f6b6-d533-4a47-aef9-fcf5cf758c76",
"TopicArn" : "arn:aws:sns:us-west-2:123456789012:MyTopic",
"Subject" : "Testing publish to subscribed queues",
"Message" : "Hello world!",
"Timestamp" : "2012-03-29T05:12:16.901Z",
"SignatureVersion" : "1",
"Signature" : "EXAMPLEnTrFPa3...",
"SigningCertURL" : "https://sns.us-west-2.amazonaws.com/SimpleNotificationService-f3ecfb7224c7233fe7bb5f59f96de52f.pem",
"UnsubscribeURL" : "https://sns.us-west-2.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-west-2:123456789012:MyTopic:c7fe3a54-ab0e-4ec2-88e0-db410a0f2bee"
}
```
1. Elija **Cerrar**. Ha publicado correctamente en un tema que envía mensajes de notificación a una cola.
# Automatice la mensajería de Amazon SNS a Amazon SQS con AWS CloudFormation
CloudFormation permite utilizar un archivo de plantilla para crear y configurar un conjunto de AWS recursos juntos como una sola unidad. Esta sección tiene una plantilla de ejemplo que facilita la implementación de temas que publiquen en colas. Las plantillas se hacen cargo de los pasos de configuración en su lugar, creando dos colas y un tema con suscripciones a las colas, añadiendo una política a las colas, de modo que el tema pueda enviar mensajes a las colas y creando usuarios y grupos de IAM para controlar el acceso a dichos recursos.
Para obtener más información sobre la implementación de AWS recursos mediante una CloudFormation plantilla, consulte [Primeros pasos](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/GettingStarted.Walkthrough.html) en la *Guía del CloudFormation usuario*.
## Uso de una CloudFormation plantilla para configurar temas y colas dentro de un Cuenta de AWS
Con la plantilla de ejemplo, se crea un tema de Amazon SNS con el que se puede enviar mensajes a dos colas de Amazon SQS con los permisos adecuados para que los miembros de un grupo de IAM puedan publicar en el tema y los de otro leer mensajes de las colas. Además, con la plantilla, se crean usuarios de IAM que se agregan a cada grupo.
Copie el contenido de la plantilla en un archivo. También puede descargar la plantilla desde la [página de AWS CloudFormation plantillas](https://aws.amazon.com/cloudformation/aws-cloudformation-templates/). En la página de plantillas, selecciona **Buscar plantillas de muestra por AWS servicio** y, a continuación, elige **Amazon Simple Queue Service**.
My SNSTopic está configurado para publicar en dos puntos de enlace suscritos, que son dos colas de Amazon SQS MyQueue (1 y 2). MyQueue MyPublishTopicGroup [es un grupo de IAM cuyos miembros tienen permiso para publicar en My SNSTopic mediante la acción Publish API o el comando [sns-publish](https://docs.aws.amazon.com/sns/latest/api/API_Publish.html).](https://docs.aws.amazon.com/cli/latest/reference/sns/publish.html) La plantilla crea los usuarios de IAM y les proporciona los perfiles de inicio de sesión MyPublishUser MyQueueUser y las claves de acceso. El usuario que crea una pila con esta plantilla especifica las contraseñas para los perfiles de inicio de sesión como parámetros de entrada. La plantilla crea claves de acceso para los dos usuarios de IAM con MyPublishUserKey y. MyQueueUserKey AddUserToMyPublishTopicGroup se agrega MyPublishUser a la MyPublishTopicGroup para que el usuario tenga los permisos asignados al grupo.
My RDMessage QueueGroup es un grupo de IAM cuyos miembros tienen permiso para leer y eliminar mensajes de las dos colas de Amazon SQS mediante [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/Query_QueryReceiveMessage.html)las [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/Query_QueryDeleteMessage.html)acciones y API. AddUserToMyQueueGroup se agrega MyQueueUser a My RDMessage QueueGroup para que el usuario tenga los permisos asignados al grupo. MyQueuePolicy asigna permiso SNSTopic a My para publicar sus notificaciones en las dos colas.
En la siguiente lista se muestra el contenido de la CloudFormation plantilla.
```
{
"AWSTemplateFormatVersion" : "2010-09-09",
"Description" : "AWS CloudFormation Sample Template SNSToSQS: This Template creates an SNS topic that can send messages to
two SQS queues with appropriate permissions for one IAM user to publish to the topic and another to read messages from the queues.
MySNSTopic is set up to publish to two subscribed endpoints, which are two SQS queues (MyQueue1 and MyQueue2). MyPublishUser is an IAM user
that can publish to MySNSTopic using the Publish API. MyTopicPolicy assigns that permission to MyPublishUser. MyQueueUser is an IAM user
that can read messages from the two SQS queues. MyQueuePolicy assigns those permissions to MyQueueUser. It also assigns permission for
MySNSTopic to publish its notifications to the two queues. The template creates access keys for the two IAM users with MyPublishUserKey
and MyQueueUserKey. ***Warning*** you will be billed for the AWS resources used if you create a stack from this template.",
"Parameters": {
"MyPublishUserPassword": {
"NoEcho": "true",
"Type": "String",
"Description": "Password for the IAM user MyPublishUser",
"MinLength": "1",
"MaxLength": "41",
"AllowedPattern": "[a-zA-Z0-9]*",
"ConstraintDescription": "must contain only alphanumeric characters."
},
"MyQueueUserPassword": {
"NoEcho": "true",
"Type": "String",
"Description": "Password for the IAM user MyQueueUser",
"MinLength": "1",
"MaxLength": "41",
"AllowedPattern": "[a-zA-Z0-9]*",
"ConstraintDescription": "must contain only alphanumeric characters."
}
},
"Resources": {
"MySNSTopic": {
"Type": "AWS::SNS::Topic",
"Properties": {
"Subscription": [{
"Endpoint": {
"Fn::GetAtt": ["MyQueue1", "Arn"]
},
"Protocol": "sqs"
},
{
"Endpoint": {
"Fn::GetAtt": ["MyQueue2", "Arn"]
},
"Protocol": "sqs"
}
]
}
},
"MyQueue1": {
"Type": "AWS::SQS::Queue"
},
"MyQueue2": {
"Type": "AWS::SQS::Queue"
},
"MyPublishUser": {
"Type": "AWS::IAM::User",
"Properties": {
"LoginProfile": {
"Password": {
"Ref": "MyPublishUserPassword"
}
}
}
},
"MyPublishUserKey": {
"Type": "AWS::IAM::AccessKey",
"Properties": {
"UserName": {
"Ref": "MyPublishUser"
}
}
},
"MyPublishTopicGroup": {
"Type": "AWS::IAM::Group",
"Properties": {
"Policies": [{
"PolicyName": "MyTopicGroupPolicy",
"PolicyDocument": {
"Statement": [{
"Effect": "Allow",
"Action": [
"sns:Publish"
],
"Resource": {
"Ref": "MySNSTopic"
}
}]
}
}]
}
},
"AddUserToMyPublishTopicGroup": {
"Type": "AWS::IAM::UserToGroupAddition",
"Properties": {
"GroupName": {
"Ref": "MyPublishTopicGroup"
},
"Users": [{
"Ref": "MyPublishUser"
}]
}
},
"MyQueueUser": {
"Type": "AWS::IAM::User",
"Properties": {
"LoginProfile": {
"Password": {
"Ref": "MyQueueUserPassword"
}
}
}
},
"MyQueueUserKey": {
"Type": "AWS::IAM::AccessKey",
"Properties": {
"UserName": {
"Ref": "MyQueueUser"
}
}
},
"MyRDMessageQueueGroup": {
"Type": "AWS::IAM::Group",
"Properties": {
"Policies": [{
"PolicyName": "MyQueueGroupPolicy",
"PolicyDocument": {
"Statement": [{
"Effect": "Allow",
"Action": [
"sqs:DeleteMessage",
"sqs:ReceiveMessage"
],
"Resource": [{
"Fn::GetAtt": ["MyQueue1", "Arn"]
},
{
"Fn::GetAtt": ["MyQueue2", "Arn"]
}
]
}]
}
}]
}
},
"AddUserToMyQueueGroup": {
"Type": "AWS::IAM::UserToGroupAddition",
"Properties": {
"GroupName": {
"Ref": "MyRDMessageQueueGroup"
},
"Users": [{
"Ref": "MyQueueUser"
}]
}
},
"MyQueuePolicy": {
"Type": "AWS::SQS::QueuePolicy",
"Properties": {
"PolicyDocument": {
"Statement": [{
"Effect": "Allow",
"Principal": {
"Service": "sns.amazonaws.com"
},
"Action": ["sqs:SendMessage"],
"Resource": "*",
"Condition": {
"ArnEquals": {
"aws:SourceArn": {
"Ref": "MySNSTopic"
}
}
}
}]
},
"Queues": [{
"Ref": "MyQueue1"
}, {
"Ref": "MyQueue2"
}]
}
}
},
"Outputs": {
"MySNSTopicTopicARN": {
"Value": {
"Ref": "MySNSTopic"
}
},
"MyQueue1Info": {
"Value": {
"Fn::Join": [
" ",
[
"ARN:",
{
"Fn::GetAtt": ["MyQueue1", "Arn"]
},
"URL:",
{
"Ref": "MyQueue1"
}
]
]
}
},
"MyQueue2Info": {
"Value": {
"Fn::Join": [
" ",
[
"ARN:",
{
"Fn::GetAtt": ["MyQueue2", "Arn"]
},
"URL:",
{
"Ref": "MyQueue2"
}
]
]
}
},
"MyPublishUserInfo": {
"Value": {
"Fn::Join": [
" ",
[
"ARN:",
{
"Fn::GetAtt": ["MyPublishUser", "Arn"]
},
"Access Key:",
{
"Ref": "MyPublishUserKey"
},
"Secret Key:",
{
"Fn::GetAtt": ["MyPublishUserKey", "SecretAccessKey"]
}
]
]
}
},
"MyQueueUserInfo": {
"Value": {
"Fn::Join": [
" ",
[
"ARN:",
{
"Fn::GetAtt": ["MyQueueUser", "Arn"]
},
"Access Key:",
{
"Ref": "MyQueueUserKey"
},
"Secret Key:",
{
"Fn::GetAtt": ["MyQueueUserKey", "SecretAccessKey"]
}
]
]
}
}
}
}
```
# Distribución ramificada de notificaciones de Amazon SNS a puntos de conexión HTTPS
Puede utilizar Amazon SNS para enviar mensajes de notificación a uno o varios puntos de conexión HTTP o HTTPS. Cuando suscribe un punto de conexión a un tema, puede publicar una notificación en el tema y Amazon SNS enviará una solicitud HTTP POST al entregar el contenido de la notificación al punto de conexión suscrito. Cuando suscribe el punto de conexión, indica si Amazon SNS utiliza HTTP o HTTPS para enviar la solicitud POST al punto de conexión. Si utiliza HTTPS, puede aprovechar la compatibilidad con Amazon SNS para lo siguiente:
+ **Indicación de nombre de servidor (SNI)**: esto permite que Amazon SNS admita puntos de conexión HTTPS que requieren SNI, como un servidor que solicita varios certificados para alojar varios dominios. Para obtener más información sobre SNI, consulte [Server Name Indication](http://en.wikipedia.org/wiki/Server_Name_Indication).
+ **Autenticación de acceso básica y abreviada**: esto permite especificar un nombre de usuario y contraseña en la URL HTTPS para la solicitud HTTP POST, como `https://user:password@domain.com` o `https://user@domain.com`. El nombre de usuario y la contraseña se cifran a través de la conexión SSL establecida al utilizar HTTPS. Solo el nombre de dominio se envía en texto sin cifrar. Para obtener más información sobre la autenticación de acceso básica y abreviada, consulte [RFC-2617](http://www.rfc-editor.org/info/rfc2617).
**importante**
Amazon SNS no admite actualmente puntos de conexión HTTP(S) privados.
URLs Los HTTPS solo se pueden recuperar de la acción de la API de Amazon `GetSubscriptionAttributes` SNS para los directores a los que haya concedido acceso a la API.
**nota**
El servicio cliente debe admitir el encabezado de respuesta `HTTP/1.1 401 Unauthorized`
La solicitud contiene el asunto y el mensaje que se publicaron en el tema junto con los metadatos de la notificación en un documento JSON. La solicitud tendrá un aspecto similar a la siguiente solicitud HTTP POST. Para obtener más información sobre el encabezado HTTP y el formato JSON del cuerpo de la solicitud, consulte [Encabezados de HTTP/HTTPS](http-header.md) y [Formato JSON de notificación HTTP/HTTPS](http-notification-json.md).
**nota**
Amazon SNS considera que se pueden reintentar todos los errores 5XX y 429 (se han enviado demasiadas solicitudes). Estos errores están sujetos a la política de entrega. Todos los demás errores se consideran errores permanentes y no volverán a intentarse.
```
POST / HTTP/1.1
x-amz-sns-message-type: Notification
x-amz-sns-message-id: da41e39f-ea4d-435a-b922-c6aae3915ebe
x-amz-sns-topic-arn: arn:aws:sns:us-west-2:123456789012:MyTopic
x-amz-sns-subscription-arn: arn:aws:sns:us-west-2:123456789012:MyTopic:2bcfbf39-05c3-41de-beaa-fcfcc21c8f55
Content-Length: 761
Content-Type: text/plain; charset=UTF-8
Host: ec2-50-17-44-49.compute-1.amazonaws.com
Connection: Keep-Alive
User-Agent: Amazon Simple Notification Service Agent
{
"Type" : "Notification",
"MessageId" : "da41e39f-ea4d-435a-b922-c6aae3915ebe",
"TopicArn" : "arn:aws:sns:us-west-2:123456789012:MyTopic",
"Subject" : "test",
"Message" : "test message",
"Timestamp" : "2012-04-25T21:49:25.719Z",
"SignatureVersion" : "1",
"Signature" : "EXAMPLElDMXvB8r9R83tGoNn0ecwd5UjllzsvSvbItzfaMpN2nk5HVSw7XnOn/49IkxDKz8YrlH2qJXj2iZB0Zo2O71c4qQk1fMUDi3LGpij7RCW7AW9vYYsSqIKRnFS94ilu7NFhUzLiieYr4BKHpdTmdD6c0esKEYBpabxDSc=",
"SigningCertURL" : "https://sns.us-west-2.amazonaws.com/SimpleNotificationService-f3ecfb7224c7233fe7bb5f59f96de52f.pem",
"UnsubscribeURL" : "https://sns.us-west-2.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-west-2:123456789012:MyTopic:2bcfbf39-05c3-41de-beaa-fcfcc21c8f55"
}
```
# Suscripción de un punto de conexión HTTP/S en un tema de Amazon SNS
En este tema se explica cómo suscribir HTTP/S puntos de enlace a los temas de Amazon SNS.
**Topics**
+ [Paso 1: Asegúrese de que el punto de enlace está listo para procesar mensajes de Amazon SNS.](SendMessageToHttp.prepare.md)
+ [Paso 2: Suscribir el HTTP/HTTPS punto final al tema Amazon SNS](SendMessageToHttp.subscribe.md)
+ [Paso 3: confirme la suscripción de Amazon SNS](SendMessageToHttp.confirm.md)
+ [Paso 4: defina la política de entrega para la suscripción de Amazon SNS (opcional)](SendMessageToHttp.retry.md)
+ [Paso 5: conceda a los usuarios permisos para publicar en el tema de Amazon SNS (opcional)](SendMessageToHttp.iam.permissions.md)
+ [Paso 6: Enviar mensajes de Amazon SNS al punto final HTTP/HTTPS](SendMessageToHttp.publish.md)
# Paso 1: Asegúrese de que el punto de enlace está listo para procesar mensajes de Amazon SNS.
Antes de suscribir su punto de enlace HTTP o HTTPS a un tema, debe asegurarse de que el punto de enlace HTTP o HTTPS tiene la capacidad de administrar las solicitudes HTTP POST que Amazon SNS utiliza para enviar la confirmación de suscripción y los mensajes de notificación. Por lo general, esto implica crear e implementar una aplicación web (por ejemplo, un servlet Java si el host del punto de enlace ejecuta Linux con Apache y Tomcat) que procese las solicitudes HTTP de Amazon SNS. Cuando suscribe un punto de enlace HTTP, Amazon SNS envía una solicitud de confirmación de la suscripción. El punto de enlace debe estar preparado para recibir y procesar esta solicitud cuando cree la suscripción, porque Amazon SNS envía esta solicitud en ese momento. Amazon SNS no enviará notificaciones al punto de enlace hasta que se confirme la suscripción. Una vez confirmada la suscripción, Amazon SNS enviará notificaciones al punto de enlace cuando se ejecute una acción de publicación en el tema suscrito.
**Para configurar el punto de enlace para que procese los mensajes de confirmación de la suscripción y de notificación**
1. El código debe leer los encabezados HTTP de las solicitudes HTTP POST que Amazon SNS envía a su punto de enlace. El código debe examinar el campo de encabezado `x-amz-sns-message-type`, en el que se indica el tipo de mensaje que Amazon SNS ha enviado. En este encabezado, puede determinar el tipo de mensaje sin tener que analizar el cuerpo de la solicitud HTTP. Hay dos tipos que debe administrar: `SubscriptionConfirmation` y `Notification`. El mensaje `UnsubscribeConfirmation` se utiliza únicamente cuando la suscripción se elimina del tema.
Para obtener información detallada sobre el encabezado HTTP, consulte [Encabezados de HTTP/HTTPS](http-header.md). La siguiente solicitud HTTP POST es un ejemplo de un mensaje de confirmación de la suscripción.
```
POST / HTTP/1.1
x-amz-sns-message-type: SubscriptionConfirmation
x-amz-sns-message-id: 165545c9-2a5c-472c-8df2-7ff2be2b3b1b
x-amz-sns-topic-arn: arn:aws:sns:us-west-2:123456789012:MyTopic
Content-Length: 1336
Content-Type: text/plain; charset=UTF-8
Host: example.com
Connection: Keep-Alive
User-Agent: Amazon Simple Notification Service Agent
{
"Type" : "SubscriptionConfirmation",
"MessageId" : "165545c9-2a5c-472c-8df2-7ff2be2b3b1b",
"Token" : "2336412f37f...",
"TopicArn" : "arn:aws:sns:us-west-2:123456789012:MyTopic",
"Message" : "You have chosen to subscribe to the topic arn:aws:sns:us-west-2:123456789012:MyTopic.\nTo confirm the subscription, visit the SubscribeURL included in this message.",
"SubscribeURL" : "https://sns.us-west-2.amazonaws.com/?Action=ConfirmSubscription&TopicArn=arn:aws:sns:us-west-2:123456789012:MyTopic&Token=2336412f37...",
"Timestamp" : "2012-04-26T20:45:04.751Z",
"SignatureVersion" : "1",
"Signature" : "EXAMPLEpH+...",
"SigningCertURL" : "https://sns.us-west-2.amazonaws.com/SimpleNotificationService-f3ecfb7224c7233fe7bb5f59f96de52f.pem"
}
```
1. El código debe analizar el documento JSON del cuerpo de la solicitud HTTP POST y el tipo de contenido text/plain para leer los pares nombre-valor que componen el mensaje de Amazon SNS. Utilice un analizador JSON que se encargue de convertir la representación en forma de secuencias de escape de los caracteres de control en sus valores de caracteres ASCII (por ejemplo, convertir \$1n en un carácter de nueva línea). Puede utilizar un analizador JSON existente como [Jackson JSON Processor](https://github.com/FasterXML/jackson) o crear el suyo propio. Para poder enviar el texto del asunto y los campos de los mensajes en formato JSON válido, Amazon SNS debe convertir algunos caracteres de control en secuencias de escape que se puedan incluir en el documento JSON. Cuando reciba el documento JSON en el cuerpo de la solicitud POST enviada a su punto de enlace, debe convertir los caracteres incluidos en secuencias de escape en sus valores de caracteres originales si desea una representación exacta del asunto original y de los mensajes publicados en el tema. Esto es fundamental si desea verificar la firma de una notificación, porque la firma utiliza el mensaje y el asunto en sus formatos originales como parte de la cadena para firmar.
1. El código debe verificar la autenticidad de una notificación, la confirmación de la suscripción o la cancelación del mensaje de confirmación enviado por Amazon SNS. Mediante la información incluida en el mensaje de Amazon SNS, el punto de enlace puede volver a crear la firma para que se pueda verificar el contenido del mensaje cotejando la firma propia con la firma que Amazon SNS envió con el mensaje. Para obtener más información acerca de la verificación de la firma de un mensaje, consulte [Verificación de la firmas de mensajes de Amazon SNS](sns-verify-signature-of-message.md).
1. Según el tipo especificado por el campo de encabezado `x-amz-sns-message-type`, el código debe leer el documento JSON incluido en el cuerpo de la solicitud HTTP y procesar el mensaje. Estas son las directrices para administrar los dos tipos principales de mensajes:
**SubscriptionConfirmation**
Lea el valor de `SubscribeURL` y visite esa URL. Para confirmar la suscripción y empezar a recibir notificaciones en el punto de enlace, debe visitar la URL `SubscribeURL` (por ejemplo, enviando una solicitud HTTP GET a la URL). Consulte el ejemplo de la solicitud HTTP del paso anterior para ver cómo es esa URL `SubscribeURL`. Para obtener más información sobre el formato del mensaje `SubscriptionConfirmation`, consulte [Formato JSON de confirmación de suscripción HTTP/HTTPS](http-subscription-confirmation-json.md). Cuando visite la dirección URL, recibirá una respuesta similar al siguiente documento XML. El documento devuelve el ARN de suscripción del punto de enlace en el elemento `ConfirmSubscriptionResult`.
```
arn:aws:sns:us-west-2:123456789012:MyTopic:2bcfbf39-05c3-41de-beaa-fcfcc21c8f55
075ecce8-8dac-11e1-bf80-f781d96e9307
```
Como alternativa a visitar el`SubscribeURL`, puede confirmar la suscripción mediante la [ConfirmSubscription](https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html)acción cuyo valor correspondiente en el `Token` mensaje esté establecido. `SubscriptionConfirmation` Si desea permitir únicamente al propietario del tema y al propietario de la suscripción que cancelen la suscripción del punto de enlace, puede llamar a la acción `ConfirmSubscription` con una firma de AWS .
**Notificación**
Lea los valores de `Subject` y `Message` para obtener la información de la notificación que se publicó en el tema.
Para obtener más información sobre el formato del mensaje `Notification`, consulte [Encabezados de HTTP/HTTPS](http-header.md). La siguiente solicitud HTTP POST es un ejemplo de un mensaje de notificación enviado al punto de enlace example.com.
```
POST / HTTP/1.1
x-amz-sns-message-type: Notification
x-amz-sns-message-id: 22b80b92-fdea-4c2c-8f9d-bdfb0c7bf324
x-amz-sns-topic-arn: arn:aws:sns:us-west-2:123456789012:MyTopic
x-amz-sns-subscription-arn: arn:aws:sns:us-west-2:123456789012:MyTopic:c9135db0-26c4-47ec-8998-413945fb5a96
Content-Length: 773
Content-Type: text/plain; charset=UTF-8
Host: example.com
Connection: Keep-Alive
User-Agent: Amazon Simple Notification Service Agent
{
"Type" : "Notification",
"MessageId" : "22b80b92-fdea-4c2c-8f9d-bdfb0c7bf324",
"TopicArn" : "arn:aws:sns:us-west-2:123456789012:MyTopic",
"Subject" : "My First Message",
"Message" : "Hello world!",
"Timestamp" : "2012-05-02T00:54:06.655Z",
"SignatureVersion" : "1",
"Signature" : "EXAMPLEw6JRN...",
"SigningCertURL" : "https://sns.us-west-2.amazonaws.com/SimpleNotificationService-f3ecfb7224c7233fe7bb5f59f96de52f.pem",
"UnsubscribeURL" : "https://sns.us-west-2.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-west-2:123456789012:MyTopic:c9135db0-26c4-47ec-8998-413945fb5a96"
}
```
1. Asegúrese de que su punto de enlace responde al mensaje HTTP POST de Amazon SNS con el código de estado adecuado. El tiempo de espera de la conexión se agotará en 15 segundos aproximadamente. Si el punto de conexión no responde antes de que se agote el tiempo de espera de la conexión, o si devuelve un código de estado fuera del intervalo 200-4*xx*, Amazon SNS considerará la entrega del mensaje un intento fallido.
1. Asegúrese de que el código puede administrar los reintentos de entrega de mensajes de Amazon SNS. Si Amazon SNS no recibe una respuesta correcta del punto de enlace, intenta entregar de nuevo el mensaje. Esto se aplica a todos los mensajes, incluido el mensaje de confirmación de la suscripción. De forma predeterminada, si la entrega inicial del mensaje da un error, Amazon SNS realiza tres reintentos con un intervalo entre los intentos fallidos establecido en 20 segundos.
**nota**
El tiempo de espera de la solicitud de mensajes se agota tras 15 segundos aproximadamente. Esto significa que si no se pudo entregar el mensaje porque se agotó el tiempo de espera, Amazon SNS lo volverá a intentar aproximadamente 35 segundos después del intento de entrega anterior. Puede establecer una política de entrega diferente para el punto de enlace.
Amazon SNS usa el campo de encabezado `x-amz-sns-message-id` para identificar de forma única cada mensaje publicado en un tema de Amazon SNS. Al comparar IDs los mensajes que ha procesado con los mensajes entrantes, puede determinar si se trata de un intento de reintento.
1. Si suscribe un punto de enlace HTTPS, asegúrese de que el punto de enlace tiene un certificado de servidor de una entidad de certificación (CA) de confianza. Amazon SNS solo enviará mensajes a puntos de enlace HTTPS que tengan un certificado de servidor de una CA en la que confíe Amazon SNS.
1. Implemente el código que ha creado para recibir mensajes de Amazon SNS. Cuando suscriba el punto de enlace, este debe estar preparado para recibir al menos el mensaje de confirmación de la suscripción.
# Paso 2: Suscribir el HTTP/HTTPS punto final al tema Amazon SNS
Para enviar mensajes a un punto de enlace HTTP o HTTPS a través de un tema, debe suscribir el punto de enlace al tema de Amazon SNS. El punto de enlace se especifica por medio de su URL. Para suscribir a un tema, puede utilizar la consola de Amazon SNS, el comando [sns-subscribe](https://docs.aws.amazon.com/cli/latest/reference/sns/subscribe.html) o la acción de API [Suscribir](https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html). Antes de empezar, asegúrese de que tiene la dirección URL del punto de enlace que desea suscribir y de que el punto de enlace está preparado para recibir los mensajes de configuración y notificación, tal como se describe en el paso 1.
**Para suscribir un punto de enlace HTTP o HTTPS a un tema mediante la consola de Amazon SNS, siga estos pasos:**
1. Inicie sesión en la [consola de Amazon SNS](https://console.aws.amazon.com/sns/home).
1. En el panel de navegación, seleccione **Subscriptions (Suscripciones)**.
1. Elija **Create subscription (Crear suscripción)**.
1. En la lista desplegable **Protocol (Protocolo)**, seleccione **HTTP** o **HTTPS**.
1. En el cuadro **Endpoint (Punto de enlace)**, pegue la dirección URL del punto de enlace al que desea que el tema envíe los mensajes y, a continuación, elija **Create subscription (Crear suscripción)**.
1. Se muestra el mensaje de confirmación. Seleccione **Cerrar**.
Aparece el **identificador de suscripción** de tu nueva suscripción PendingConfirmation. Cuando confirme la suscripción, **Subscription ID (ID de suscripción)** mostrará el ID de suscripción.
# Paso 3: confirme la suscripción de Amazon SNS
Para confirmar la suscripción de Amazon SNS, siga estos pasos para asegurarse de que el punto de conexión pueda recibir correctamente los mensajes. Este proceso implica configurar el punto de conexión para que gestione los mensajes de confirmación entrantes, recuperar la URL de confirmación y confirmar la suscripción. Puede confirmar la suscripción de forma automática o manual, en función de la configuración.
1. Tras suscribirse a un tema de Amazon SNS, Amazon SNS envía un mensaje de confirmación al punto de conexión. Este mensaje contiene una `SubscribeURL` que debe utilizar para confirmar la suscripción.
1. El punto de conexión debe estar configurado para escuchar los mensajes entrantes de Amazon SNS. Cuando llegue el mensaje de confirmación, extraiga la **`SubscribeURL`** del mensaje.
1. Una vez que tenga la `SubscribeURL`, puede confirmar la suscripción de dos maneras:
+ **Confirmación automática**: su punto de conexión puede confirmar automáticamente la suscripción enviando una **solicitud HTTP GET** a la `SubscribeURL`.
Este método no requiere intervención manual.
+ **Confirmación manual**: si la confirmación automática no está configurada, **copie** la **`SubscribeURL`** del mensaje de confirmación y **péguela** en la barra de direcciones del navegador.
Esto confirmará la suscripción manualmente.
1. También puede verificar el **estado de la suscripción** mediante la consola de Amazon SNS:
1. Inicie sesión en la [consola de Amazon SNS](https://console.aws.amazon.com/sns/home).
1. En el panel de navegación, seleccione **Suscripciones**.
1. Busque la **suscripción** en la lista.
+ Si se confirma, se mostrará el `SubscriptionArn`.
+ Si sigue sin confirmarse, se mostrará como `PendingConfirmation`.
# Paso 4: defina la política de entrega para la suscripción de Amazon SNS (opcional)
De forma predeterminada, si la entrega inicial del mensaje da un error, Amazon SNS realiza tres reintentos con un intervalo entre los intentos fallidos establecido en 20 segundos. Como se ha explicado en el [paso 1](SendMessageToHttp.prepare.md), el punto de enlace debe tener código que pueda administrar los reintentos de entrega de mensajes. Mediante la configuración de la política de entrega en un tema o suscripción, puede controlar la frecuencia y el intervalo con los que Amazon SNS intenta entregar de nuevo los mensajes fallidos. También puedes especificar el tipo de contenido para tus HTTP/S notificaciones. `DeliveryPolicy` Para obtener más información, consulte [Crear una política HTTP/S de entrega](sns-message-delivery-retries.md#creating-delivery-policy).
# Paso 5: conceda a los usuarios permisos para publicar en el tema de Amazon SNS (opcional)
De forma predeterminada, el propietario del tema tiene permisos para publicar en el tema. Para permitir que otros usuarios o aplicaciones publiquen en el tema, debe usar AWS Identity and Access Management (IAM) para conceder permisos de publicación al tema. Si desea obtener más información sobre cómo conceder permisos para las acciones de Amazon SNS a los usuarios de IAM, consulte [Uso de políticas basadas en identidades con Amazon SNS](sns-using-identity-based-policies.md).
Hay dos formas de controlar el acceso a un tema:
+ Agregue una política a un usuario o un grupo de IAM. La forma más sencilla de conceder a los usuarios permisos para temas consiste en crear un grupo, añadir la política adecuada al grupo y, a continuación, añadir usuarios a dicho grupo. Es mucho más fácil añadir y eliminar usuarios de un grupo que mantener un seguimiento de las políticas que se han configurado para los distintos usuarios.
+ Añadiendo una política al tema. Si desea conceder permisos para un tema a otra cuenta de AWS , el único modo de hacerlo es agregando una política que tenga como entidad principal la Cuenta de AWS a la que desee conceder los permisos.
Debe utilizar el primer método para la mayoría de los casos (aplicar políticas a grupos y administrar los permisos de los usuarios añadiendo o eliminando los usuarios a los grupos). Si necesita conceder permisos a un usuario de otra cuenta, utilice el segundo método.
Si agregas la siguiente política a un usuario o grupo de IAM, le darías permiso a ese usuario o miembros de ese grupo para realizar la `sns:Publish` acción en el tema. MyTopic
```
{
"Statement":[{
"Sid":"AllowPublishToMyTopic",
"Effect":"Allow",
"Action":"sns:Publish",
"Resource":"arn:aws:sns:us-east-2:123456789012:MyTopic"
}]
}
```
La siguiente política de ejemplo muestra cómo conceder a otra cuenta permisos sobre un tema.
**nota**
Cuando concedes a otra persona el Cuenta de AWS acceso a un recurso de tu cuenta, también concedes permisos a ese recurso a los usuarios de IAM que tienen acceso de nivel de administrador (acceso comodín). Al resto de los usuarios de IAM de la otra cuenta se les deniega de manera automática el acceso al recurso. Si quieres conceder a usuarios de IAM específicos de ese tipo Cuenta de AWS acceso a tu recurso, la cuenta o un usuario de IAM con acceso de nivel de administrador debe delegar los permisos del recurso a esos usuarios de IAM. Para obtener más información acerca de la delegación entre cuentas, consulte [Cómo habilitar el acceso entre cuentas](https://docs.aws.amazon.com/IAM/latest/UserGuide/Delegation.html) en la *Guía del usuario de IAM*.
Si agregaste la siguiente política a un tema MyTopic de la cuenta 123456789012, darías permiso a la cuenta 111122223333 para realizar la acción sobre ese tema. `sns:Publish`
```
{
"Statement":[{
"Sid":"Allow-publish-to-topic",
"Effect":"Allow",
"Principal":{
"AWS":"111122223333"
},
"Action":"sns:Publish",
"Resource":"arn:aws:sns:us-east-2:123456789012:MyTopic"
}]
}
```
# Paso 6: Enviar mensajes de Amazon SNS al punto final HTTP/HTTPS
Puede enviar un mensaje a las suscripciones de un tema mediante su publicación en el tema. Para publicar en un tema, puede utilizar la consola de Amazon SNS, el comando `[sns-publish](https://docs.aws.amazon.com/cli/latest/reference/sns/publish.html)` de la CLI o la API `[Publish](https://docs.aws.amazon.com/sns/latest/api/API_Publish.html)`.
Si ha seguido el [paso 1](SendMessageToHttp.prepare.md), el código que ha implementado en el punto de enlace debería procesar la notificación.
**Para publicar en un tema mediante la consola de Amazon SNS, siga estos pasos:**
1. Con las credenciales del usuario de IAM Cuenta de AWS o del usuario de IAM con permiso para publicar en el tema, inicie sesión en la consola de Amazon SNS Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/sns/](https://console.aws.amazon.com/sns/home)
1. En el panel de navegación izquierdo, elija **Topics (Temas)** y, a continuación, seleccione un tema.
1. Seleccione el botón **Publish message (Publicar mensaje)**.
1. En el cuadro **Subject (Asunto)**, introduzca el asunto (por ejemplo, **Testing publish to my endpoint**).
1. En el cuadro **Message (Mensaje)**, introduzca algún texto (por ejemplo, **Hello world\$1**) y elija **Publish message (Publicar mensaje)**.
Aparecerá el siguiente mensaje: Your message has been successfully published.
# Verificación de la firmas de mensajes de Amazon SNS
Amazon SNS utiliza las firmas de los mensajes para confirmar la autenticidad de los mensajes que se envían a su punto de conexión HTTP. Para garantizar la integridad de los mensajes y evitar la suplantación de identidad, **debe** verificar la firma antes de procesar cualquier mensaje de Amazon SNS.
**¿Cuándo se deben verificar las firmas de Amazon SNS?**
Debe verificar las firmas de los mensajes de Amazon SNS en los siguientes escenarios:
+ Cuando Amazon SNS envía un mensaje de notificación a su punto de conexión HTTP(S).
+ Cuando Amazon SNS envía un mensaje de confirmación a su punto de conexión tras una llamada a la API [https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html](https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html) o [https://docs.aws.amazon.com/sns/latest/api/API_Unsubscribe.html](https://docs.aws.amazon.com/sns/latest/api/API_Unsubscribe.html).
**Amazon SNS admite dos versiones de firmas:**
+ SignatureVersion1 — Utiliza un SHA1 hash del mensaje.
+ SignatureVersion2 — Utiliza un SHA256 hash del mensaje. Esto proporciona una mayor seguridad y es la opción recomendada.
**Para verificar correctamente las firmas de los mensajes de SNS, siga estas prácticas recomendadas:**
+ Recupere siempre el certificado de firma mediante HTTPs para evitar ataques de interceptación no autorizados.
+ Compruebe que el certificado lo ha emitido Amazon SNS.
+ Confirme que la cadena de confianza del certificado sea válida.
+ El certificado debe proceder de una URL firmada por SNS.
+ No confíe en ningún certificado proporcionado en el mensaje sin validación.
+ Rechace cualquier mensaje con un `TopicArn` inesperado para evitar la suplantación de identidad.
+ Los AWS SDKs para Amazon SNS incluyen una lógica de validación integrada, lo que reduce el riesgo de errores de implementación.
# Configuración de la versión de la firma de mensajes en los temas de Amazon SNS
Al configurar la versión de firma del mensaje en el tema de Amazon SNS permite mejorar la seguridad y la compatibilidad del proceso de verificación de mensajes.
Seleccione entre `SignatureVersion` **1** (SHA1) y `SignatureVersion` **2** (SHA256) para controlar el algoritmo de hash utilizado para firmar los mensajes. Los temas de Amazon SNS utilizan `SignatureVersion`**1** de forma predeterminada. Puede configurar este ajuste mediante la acción de la API [https://docs.aws.amazon.com/sns/latest/api/API_SetTopicAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetTopicAttributes.html).
Utilice el siguiente ejemplo para establecer el atributo de tema `SignatureVersion` con la AWS CLI:
```
aws sns set-topic-attributes \
--topic-arn arn:aws:sns:us-east-2:123456789012:MyTopic \
--attribute-name SignatureVersion \
--attribute-value 2
```
# Verificación de la firma de un mensaje de Amazon SNS cuando se utilizan solicitudes basadas en consultas HTTP
Al verificar la firma de un mensaje de Amazon SNS cuando se utilizan solicitudes basadas en consultas HTTP se garantiza la autenticidad y la integridad del mensaje. Este proceso confirma que el mensaje proviene de Amazon SNS y no se ha manipulado durante el tránsito. Al analizar el mensaje, construir la cadena correcta para firmarlo y validar la firma con una clave pública de confianza, se protege el sistema contra la suplantación de identidad y las alteraciones no autorizadas de los mensajes.
1. Extraiga los **pares de clave-valor** del documento JSON en el cuerpo de la solicitud HTTP POST que envía Amazon SNS. Estos campos son necesarios para construir la **cadena que se va a firmar**.
+ `Message`
+ `Subject` (si está presente)
+ `MessageId`
+ `Timestamp`
+ `TopicArn`
+ `Type`
Por ejemplo:
```
MESSAGE_FILE="message.json"
FIELDS=("Message" "MessageId" "Subject" "Timestamp" "TopicArn" "Type")
```
**nota**
Si algún campo contiene caracteres de escape (por ejemplo,`\n`), conviértalos a su **formato original** para garantizar una coincidencia exacta.
1. Localice el campo `SigningCertURL` en el mensaje de Amazon SNS. Este certificado contiene la clave pública necesaria para verificar la firma del mensaje. Por ejemplo:
```
SIGNING_CERT_URL=$(jq -r '.SigningCertURL' "$MESSAGE_FILE")
```
1. Asegúrese de que `SigningCertURL` sea de un AWS dominio de confianza (por ejemplo,https://sns.us-east-1.amazonaws.com). Rechaza cualquier ** AWS dominio URLs externo** por motivos de seguridad.
1. Descargue el **certificado X.509 **desde la URL proporcionada. Por ejemplo:
```
curl -s "$SIGNING_CERT_URL" -o signing_cert.pem
```
1. Extraiga la **clave pública** del certificado X.509 descargado. La clave pública le permite descifrar la firma del mensaje y comprobar su integridad. Por ejemplo:
```
openssl x509 -pubkey -noout -in signing_cert.pem > public_key.pem
```
1. Los diferentes tipos de mensajes requieren diferentes pares de clave-valor en la cadena para firmarlos. Identifique el **tipo de mensaje** (campo `Type` en el mensaje de Amazon SNS) para determinar qué **pares de clave-valor** incluir:
+ **Mensaje de notificación**: incluye `Message`, `MessageId`, `Subject` (si está presente), `Timestamp`, `TopicArn` y `Type`.
+ **SubscriptionConfirmation**o **UnsubscribeConfirmation mensaje**: incluye `Message``MessageId`,`SubscribeURL`, `Timestamp``Token`,`TopicArn`, y`Type`.
1. Amazon SNS requiere que la cadena se firme para seguir un orden de campos estricto y fijo para la verificación. **Solo se deben incluir los campos explícitamente obligatorios**; no se pueden añadir campos adicionales. Los campos opcionales, como `Subject`, deben incluirse solo si están presentes en el mensaje y deben aparecer en la posición exacta definida por el orden de los campos obligatorios. Por ejemplo:
```
KeyNameOne\nValueOne\nKeyNameTwo\nValueTwo
```
**importante**
No agregue un carácter de nueva línea al final de la cadena.
1. Organice los **pares de clave-valor** en orden de clasificación de bytes (alfabéticamente por nombre de clave).
1. Construya la **cadena para firmarla **con el siguiente ejemplo de formato:
```
STRING_TO_SIGN=""
for FIELD in "${FIELDS[@]}"; do
VALUE=$(jq -r --arg field "$FIELD" '.[$field]' "$MESSAGE_FILE")
STRING_TO_SIGN+="$FIELD\n$VALUE"
# Append a newline after each field except the last one
if [[ "$FIELD" != "Type" ]]; then
STRING_TO_SIGN+="\n"
fi
done
```
**Ejemplo de mensaje de notificación:**
```
Message
My Test Message
MessageId
4d4dc071-ddbf-465d-bba8-08f81c89da64
Subject
My subject
Timestamp
2019-01-31T04:37:04.321Z
TopicArn
arn:aws:sns:us-east-2:123456789012:s4-MySNSTopic-1G1WEFCOXTC0P
Type
Notification
```
**SubscriptionConfirmation ejemplo:**
```
Message
Please confirm your subscription
MessageId
3d891288-136d-417f-bc05-901c108273ee
SubscribeURL
https://sns.us-east-2.amazonaws.com/...
Timestamp
2024-01-01T00:00:00.000Z
Token
abc123...
TopicArn
arn:aws:sns:us-east-2:123456789012:MyTopic
Type
SubscriptionConfirmation
```
1. El campo `Signature` del mensaje está codificado en Base64. Debe **descodificarlo** para comparar su **formato binario sin procesar** con el **hash derivado**. Por ejemplo:
```
SIGNATURE=$(jq -r '.Signature' "$MESSAGE_FILE")
echo "$SIGNATURE" | base64 -d > signature.bin
```
1. Use el campo `SignatureVersion` para seleccionar el algoritmo de hash:
+ Para `SignatureVersion` **1**, utilice **SHA1**(por ejemplo,`-sha1`).
+ Para `SignatureVersion` **2**, utilice **SHA256**(por ejemplo,`-sha256`).
1. Para confirmar la autenticidad del mensaje de Amazon SNS, genere un **hash** de la cadena construida y verifique la firma con la **clave pública**.
```
openssl dgst -sha256 -verify public_key.pem -signature signature.bin <<< "$STRING_TO_SIGN"
```
Si la firma es válida, el resultado es `Verified OK`. En cualquier otro caso, el resultado es`Verification Failure`.
## Script de ejemplo con gestión de errores
El siguiente script de ejemplo automatiza el proceso de verificación:
```
#!/bin/bash
# Path to the local message file
MESSAGE_FILE="message.json"
# Extract the SigningCertURL and Signature from the message
SIGNING_CERT_URL=$(jq -r '.SigningCertURL' "$MESSAGE_FILE")
SIGNATURE=$(jq -r '.Signature' "$MESSAGE_FILE")
# Fetch the X.509 certificate
curl -s "$SIGNING_CERT_URL" -o signing_cert.pem
# Extract the public key from the certificate
openssl x509 -pubkey -noout -in signing_cert.pem > public_key.pem
# Define the fields to include in the string to sign
FIELDS=("Message" "MessageId" "Subject" "Timestamp" "TopicArn" "Type")
# Initialize the string to sign
STRING_TO_SIGN=""
# Iterate over the fields to construct the string to sign
for FIELD in "${FIELDS[@]}"; do
VALUE=$(jq -r --arg field "$FIELD" '.[$field]' "$MESSAGE_FILE")
STRING_TO_SIGN+="$FIELD\n$VALUE"
# Append a newline after each field except the last one
if [[ "$FIELD" != "Type" ]]; then
STRING_TO_SIGN+="\n"
fi
done
# Verify the signature
echo -e "$STRING_TO_SIGN" | openssl dgst -sha256 -verify public_key.pem -signature <(echo "$SIGNATURE" | base64 -d)
```
# Análisis de los formatos de mensajes de Amazon SNS
Cuando Amazon SNS envía mensajes a los HTTP/HTTPS puntos de enlace, estos contienen encabezados HTTP y un cuerpo de mensaje JSON. Estos mensajes siguen un formato estructurado que incluye metadatos como el tipo de mensaje, el ARN del tema, las marcas de tiempo y las firmas digitales. Al analizar correctamente los mensajes de Amazon SNS, puede determinar si un mensaje es una confirmación de suscripción, una notificación o una confirmación de cancelación de suscripción, extraer los datos relevantes y verificar la autenticidad mediante la validación de firmas.
# Encabezados de HTTP/HTTPS
Cuando Amazon SNS envía un mensaje de confirmación de suscripción, notificación o confirmación de cancelación de la suscripción a los HTTP/HTTPS puntos de conexión, envía un mensaje POST con varios valores de encabezado específicos de Amazon SNS. Puede utilizar los valores del encabezado para tareas como identificar el tipo de mensaje sin tener que analizar el cuerpo del mensaje JSON para leer el valor de `Type`. De forma predeterminada, Amazon SNS envía todas las notificaciones a puntos de conexión HTTP/S con `Content-Type` establecido a `text/plain; charset=UTF-8`. Para elegir `Content-Type` otro que no sea text/plain (predeterminado), consulte en. `headerContentType` [Crear una política HTTP/S de entrega](sns-message-delivery-retries.md#creating-delivery-policy)
**`x-amz-sns-message-type`**
Tipo de mensaje. Los valores posibles son `SubscriptionConfirmation`, `Notification` y `UnsubscribeConfirmation`.
**`x-amz-sns-message-id`**
Un identificador único universal (UUID), único para cada mensaje publicado. En las notificaciones que Amazon SNS reenvía durante un reintento, se usa el ID de mensaje original.
**`x-amz-sns-topic-arn`**
Nombre de recurso de Amazon (ARN) del tema en el que se publicó el mensaje.
**`x-amz-sns-subscription-arn`**
ARN de la suscripción a este punto de enlace.
El siguiente encabezado HTTP POST es un ejemplo de encabezado para un mensaje `Notification` a un punto de conexión HTTP.
```
POST / HTTP/1.1
x-amz-sns-message-type: Notification
x-amz-sns-message-id: 165545c9-2a5c-472c-8df2-7ff2be2b3b1b
x-amz-sns-topic-arn: arn:aws:sns:us-west-2:123456789012:MyTopic
x-amz-sns-subscription-arn: arn:aws:sns:us-west-2:123456789012:MyTopic:2bcfbf39-05c3-41de-beaa-fcfcc21c8f55
Content-Length: 1336
Content-Type: text/plain; charset=UTF-8
Host: myhost.example.com
Connection: Keep-Alive
User-Agent: Amazon Simple Notification Service Agent
```
# Formato JSON de confirmación de suscripción HTTP/HTTPS
Tras suscribir un HTTP/HTTPS punto de conexión, Amazon SNS envía un mensaje de confirmación de suscripción al HTTP/HTTPS punto de conexión. Este mensaje contiene un valor `SubscribeURL` que debe visitar para confirmar la suscripción (o bien, puede utilizar el valor `Token` con [https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html](https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html)).
**nota**
Amazon SNS no envía notificaciones a este punto de conexión hasta que se confirma la suscripción
El mensaje de confirmación de la suscripción es un mensaje POST con un cuerpo que contiene un documento JSON con los siguientes pares de nombre-valor.
**`Type`**
Tipo de mensaje. Para obtener una confirmación de suscripción, el tipo es `SubscriptionConfirmation`.
**`MessageId`**
Un identificador único universal (UUID), único para cada mensaje publicado. En los mensajes que Amazon SNS reenvía durante un reintento, se usa el ID de mensaje original.
**`Token`**
Un valor que puede utilizar con la acción [https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html](https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html) para confirmar la suscripción. También puede visitar simplemente `SubscribeURL`.
**`TopicArn`**
Nombre de recurso de Amazon (ARN) del tema al que está suscrito este punto de enlace.
**`Message`**
Cadena que describe el mensaje. Para la confirmación de suscripción, esta cadena tiene el aspecto siguiente:
```
You have chosen to subscribe to the topic arn:aws:sns:us-east-2:123456789012:MyTopic.\nTo confirm the subscription, visit the SubscribeURL included in this message.
```
**`SubscribeURL`**
Dirección URL que debe visitar para confirmar la suscripción. O bien, puede utilizar `Token` con la acción [https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html](https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html) para confirmar la suscripción.
**`Timestamp`**
Hora (GMT) de envío de la confirmación de suscripción.
**`SignatureVersion`**
Versión de la firma de Amazon SNS utilizada.
+ Si `SignatureVersion` es **1**, `Signature` es una firma `SHA1withRSA` codificada en Base64 de los valores `Message`, `MessageId`, `Type`, `Timestamp` y `TopicArn`.
+ Si `SignatureVersion` es **2**, `Signature` es una firma `SHA256withRSA` codificada en Base64 de los valores `Message`, `MessageId`, `Type`, `Timestamp` y `TopicArn`.
**`Signature`**
Firma de `SHA1withRSA` o `SHA256withRSA` codificada en Base64 de los valores `Message`, `MessageId`, `Type`, `Timestamp` y `TopicArn`.
**`SigningCertURL`**
Dirección URL del certificado que se utilizó para firmar el mensaje.
El mensaje HTTP POST siguiente es un ejemplo de un mensaje de `SubscriptionConfirmation` a un punto de conexión HTTP.
```
POST / HTTP/1.1
x-amz-sns-message-type: SubscriptionConfirmation
x-amz-sns-message-id: 165545c9-2a5c-472c-8df2-7ff2be2b3b1b
x-amz-sns-topic-arn: arn:aws:sns:us-west-2:123456789012:MyTopic
Content-Length: 1336
Content-Type: text/plain; charset=UTF-8
Host: myhost.example.com
Connection: Keep-Alive
User-Agent: Amazon Simple Notification Service Agent
{
"Type" : "SubscriptionConfirmation",
"MessageId" : "165545c9-2a5c-472c-8df2-7ff2be2b3b1b",
"Token" : "2336412f37...",
"TopicArn" : "arn:aws:sns:us-west-2:123456789012:MyTopic",
"Message" : "You have chosen to subscribe to the topic arn:aws:sns:us-west-2:123456789012:MyTopic.\nTo confirm the subscription, visit the SubscribeURL included in this message.",
"SubscribeURL" : "https://sns.us-west-2.amazonaws.com/?Action=ConfirmSubscription&TopicArn=arn:aws:sns:us-west-2:123456789012:MyTopic&Token=2336412f37...",
"Timestamp" : "2012-04-26T20:45:04.751Z",
"SignatureVersion" : "1",
"Signature" : "EXAMPLEpH+DcEwjAPg8O9mY8dReBSwksfg2S7WKQcikcNKWLQjwu6A4VbeS0QHVCkhRS7fUQvi2egU3N858fiTDN6bkkOxYDVrY0Ad8L10Hs3zH81mtnPk5uvvolIC1CXGu43obcgFxeL3khZl8IKvO61GWB6jI9b5+gLPoBc1Q=",
"SigningCertURL" : "https://sns.us-west-2.amazonaws.com/SimpleNotificationService-f3ecfb7224c7233fe7bb5f59f96de52f.pem"
}
```
# Formato JSON de notificación HTTP/HTTPS
Cuando Amazon SNS envía una notificación a un punto de enlace HTTP o HTTPS suscrito, el cuerpo del mensaje POST enviado al punto de enlace contiene un documento JSON con los siguientes pares de nombre-valor.
**`Type`**
Tipo de mensaje. Para una notificación, el tipo es `Notification`.
**`MessageId`**
Un identificador único universal (UUID), único para cada mensaje publicado. En las notificaciones que Amazon SNS reenvía durante un reintento, se usa el ID de mensaje original.
**`TopicArn`**
Nombre de recurso de Amazon (ARN) del tema en el que se publicó el mensaje.
**`Subject`**
Parámetro `Subject` especificado cuando se publicó la notificación en el tema.
Se trata de un parámetro opcional. Si no se especifica `Subject`, el par de nombre y valor no aparecerá en este documento JSON.
**`Message`**
Valor `Message` especificado cuando se publicó la notificación en el tema.
**`Timestamp`**
Hora (GMT) de publicación de la notificación.
**`SignatureVersion`**
Versión de la firma de Amazon SNS utilizada.
+ Si `SignatureVersion` es **1**, `Signature` es una firma `SHA1withRSA` codificada en Base64 de los valores `Message`, `MessageId`, `Subject` ( si está presente), `Type`, `Timestamp` y `TopicArn`.
+ Si `SignatureVersion` es **2**, `Signature` es una firma `SHA256withRSA` codificada en Base64 de los valores `Message`, `MessageId`, `Subject` ( si está presente), `Type`, `Timestamp` y `TopicArn`.
**`Signature`**
Firma de `SHA1withRSA` o `SHA256withRSA` codificada en Base64 de los valores `Message`, `MessageId`, `Subject` (si está presente), `Type`, `Timestamp` y `TopicArn`.
**`SigningCertURL`**
Dirección URL del certificado que se utilizó para firmar el mensaje.
**`UnsubscribeURL`**
Dirección URL que puede utilizar para cancelar la suscripción del punto de enlace a este tema. Si visita esta URL, Amazon SNS cancela la suscripción del punto de enlace y deja de enviarle notificaciones.
El mensaje HTTP POST siguiente es un ejemplo de un mensaje de `Notification` a un punto de conexión HTTP.
```
POST / HTTP/1.1
x-amz-sns-message-type: Notification
x-amz-sns-message-id: 22b80b92-fdea-4c2c-8f9d-bdfb0c7bf324
x-amz-sns-topic-arn: arn:aws:sns:us-west-2:123456789012:MyTopic
x-amz-sns-subscription-arn: arn:aws:sns:us-west-2:123456789012:MyTopic:c9135db0-26c4-47ec-8998-413945fb5a96
Content-Length: 773
Content-Type: text/plain; charset=UTF-8
Host: myhost.example.com
Connection: Keep-Alive
User-Agent: Amazon Simple Notification Service Agent
{
"Type" : "Notification",
"MessageId" : "22b80b92-fdea-4c2c-8f9d-bdfb0c7bf324",
"TopicArn" : "arn:aws:sns:us-west-2:123456789012:MyTopic",
"Subject" : "My First Message",
"Message" : "Hello world!",
"Timestamp" : "2012-05-02T00:54:06.655Z",
"SignatureVersion" : "1",
"Signature" : "EXAMPLEw6JRN...",
"SigningCertURL" : "https://sns.us-west-2.amazonaws.com/SimpleNotificationService-f3ecfb7224c7233fe7bb5f59f96de52f.pem",
"UnsubscribeURL" : "https://sns.us-west-2.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-west-2:123456789012:MyTopic:c9135db0-26c4-47ec-8998-413945fb5a96"
}
```
# Formato JSON de confirmación de cancelación de suscripción HTTP/HTTPS
Cuando se cancela la suscripción de un HTTP/HTTPS punto final a un tema, Amazon SNS envía un mensaje de confirmación de cancelación de la suscripción al punto final.
El mensaje de cancelación de la suscripción es un mensaje POST con un cuerpo que contiene un documento JSON con los siguientes pares de nombre-valor.
**`Type`**
Tipo de mensaje. Para obtener una confirmación de la cancelación de suscripción, el tipo es `UnsubscribeConfirmation`.
**`MessageId`**
Un identificador único universal (UUID), único para cada mensaje publicado. En los mensajes que Amazon SNS reenvía durante un reintento, se usa el ID de mensaje original.
**`Token`**
Valor que puede utilizar con la acción [https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html](https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html) para volver a confirmar la suscripción. También puede visitar simplemente `SubscribeURL`.
**`TopicArn`**
Nombre de recurso de Amazon (ARN) del tema del que el punto de enlace ha cancelado su suscripción.
**`Message`**
Cadena que describe el mensaje. Para la confirmación de la cancelación de suscripción, esta cadena tiene el aspecto siguiente:
```
You have chosen to deactivate subscription arn:aws:sns:us-east-2:123456789012:MyTopic:2bcfbf39-05c3-41de-beaa-fcfcc21c8f55.\nTo cancel this operation and restore the subscription, visit the SubscribeURL included in this message.
```
**`SubscribeURL`**
Dirección URL que debe visitar para volver a confirmar la suscripción. O bien, puede utilizar `Token` con la acción [https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html](https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html) para volver a confirmar la suscripción.
**`Timestamp`**
Hora (GMT) de envío de la cancelación de la suscripción.
**`SignatureVersion`**
Versión de la firma de Amazon SNS utilizada.
+ Si `SignatureVersion` es **1**, `Signature` es una firma `SHA1withRSA` codificada en Base64 de los valores `Message`, `MessageId`, `Type`, `Timestamp` y `TopicArn`.
+ Si `SignatureVersion` es **2**, `Signature` es una firma `SHA256withRSA` codificada en Base64 de los valores `Message`, `MessageId`, `Type`, `Timestamp` y `TopicArn`.
**`Signature`**
Firma de `SHA1withRSA` o `SHA256withRSA` codificada en Base64 de los valores `Message`, `MessageId`, `Type`, `Timestamp` y `TopicArn`.
**`SigningCertURL`**
Dirección URL del certificado que se utilizó para firmar el mensaje.
El mensaje HTTP POST siguiente es un ejemplo de un mensaje de `UnsubscribeConfirmation` a un punto de conexión HTTP.
```
POST / HTTP/1.1
x-amz-sns-message-type: UnsubscribeConfirmation
x-amz-sns-message-id: 47138184-6831-46b8-8f7c-afc488602d7d
x-amz-sns-topic-arn: arn:aws:sns:us-west-2:123456789012:MyTopic
x-amz-sns-subscription-arn: arn:aws:sns:us-west-2:123456789012:MyTopic:2bcfbf39-05c3-41de-beaa-fcfcc21c8f55
Content-Length: 1399
Content-Type: text/plain; charset=UTF-8
Host: myhost.example.com
Connection: Keep-Alive
User-Agent: Amazon Simple Notification Service Agent
{
"Type" : "UnsubscribeConfirmation",
"MessageId" : "47138184-6831-46b8-8f7c-afc488602d7d",
"Token" : "2336412f37...",
"TopicArn" : "arn:aws:sns:us-west-2:123456789012:MyTopic",
"Message" : "You have chosen to deactivate subscription arn:aws:sns:us-west-2:123456789012:MyTopic:2bcfbf39-05c3-41de-beaa-fcfcc21c8f55.\nTo cancel this operation and restore the subscription, visit the SubscribeURL included in this message.",
"SubscribeURL" : "https://sns.us-west-2.amazonaws.com/?Action=ConfirmSubscription&TopicArn=arn:aws:sns:us-west-2:123456789012:MyTopic&Token=2336412f37fb6...",
"Timestamp" : "2012-04-26T20:06:41.581Z",
"SignatureVersion" : "1",
"Signature" : "EXAMPLEHXgJm...",
"SigningCertURL" : "https://sns.us-west-2.amazonaws.com/SimpleNotificationService-f3ecfb7224c7233fe7bb5f59f96de52f.pem"
}
```
# SetSubscriptionAttributes política de entrega (formato JSON)
Si envía una solicitud a la acción `SetSubscriptionAttributes` y establece el parámetro `AttributeName` al valor `DeliveryPolicy`, el valor del parámetro `AttributeValue` válido debe ser un objeto JSON válido. Por ejemplo, el siguiente ejemplo establece la política de entrega en 5 reintentos en total.
```
http://sns.us-east-2.amazonaws.com/
?Action=SetSubscriptionAttributes
&SubscriptionArn=arn%3Aaws%3Asns%3Aus-east-2%3A123456789012%3AMy-Topic%3A80289ba6-0fd4-4079-afb4-ce8c8260f0ca
&AttributeName=DeliveryPolicy
&AttributeValue={"healthyRetryPolicy":{"numRetries":5}}
...
```
Utilice el siguiente formato JSON para el valor del parámetro `AttributeValue`.
```
{
"healthyRetryPolicy" : {
"minDelayTarget" : int,
"maxDelayTarget" : int,
"numRetries" : int,
"numMaxDelayRetries" : int,
"backoffFunction" : "linear|arithmetic|geometric|exponential"
},
"throttlePolicy" : {
"maxReceivesPerSecond" : int
},
"requestPolicy" : {
"headerContentType" : "text/plain | application/json | application/xml"
}
}
```
Para obtener más información sobre la `SetSubscriptionAttribute` acción, consulta la *referencia [SetSubscriptionAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html)de la API de Amazon Simple Notification Service*. Para obtener más información sobre los encabezados content-type de HTTP compatibles, consulte [Crear una política HTTP/S de entrega](sns-message-delivery-retries.md#creating-delivery-policy).
# SetTopicAttributes política de entrega (formato JSON)
Si envía una solicitud a la acción `SetTopicAttributes` y establece el parámetro `AttributeName` al valor `DeliveryPolicy`, el valor del parámetro `AttributeValue` válido debe ser un objeto JSON válido. Por ejemplo, el siguiente ejemplo establece la política de entrega en 5 reintentos en total.
```
http://sns.us-east-2.amazonaws.com/
?Action=SetTopicAttributes
&TopicArn=arn%3Aaws%3Asns%3Aus-east-2%3A123456789012%3AMy-Topic
&AttributeName=DeliveryPolicy
&AttributeValue={"http":{"defaultHealthyRetryPolicy":{"numRetries":5}}}
...
```
Utilice el siguiente formato JSON para el valor del parámetro `AttributeValue`.
```
{
"http" : {
"defaultHealthyRetryPolicy" : {
"minDelayTarget": int,
"maxDelayTarget": int,
"numRetries": int,
"numMaxDelayRetries": int,
"backoffFunction": "linear|arithmetic|geometric|exponential"
},
"disableSubscriptionOverrides" : Boolean,
"defaultThrottlePolicy" : {
"maxReceivesPerSecond" : int
},
"defaultRequestPolicy" : {
"headerContentType" : "text/plain | application/json | application/xml"
}
}
}
```
Para obtener más información sobre la `SetTopicAttribute` acción, consulta la *referencia [SetTopicAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetTopicAttributes.html)de la API de Amazon Simple Notification Service*. Para obtener más información sobre los encabezados content-type de HTTP compatibles, consulte [Crear una política HTTP/S de entrega](sns-message-delivery-retries.md#creating-delivery-policy).
# Distribuya los eventos de Amazon SNS AWS a Event Fork Pipelines
| |
| --- |
| Para el archivado y el análisis de eventos, Amazon SNS recomienda ahora utilizar su integración nativa con Amazon Data Firehose. Puede suscribir las transmisiones de entrega de Firehose a temas de SNS, lo que le permite enviar notificaciones a puntos de enlace de archivado y análisis, como depósitos de Amazon Simple Storage Service (Amazon S3), tablas de Amazon Redshift, Amazon Service (Service) y más. OpenSearch OpenSearch El uso de Amazon SNS con las transmisiones de entrega de Firehose es una solución totalmente gestionada y sin código que no requiere el uso de funciones. AWS Lambda Para obtener más información, consulte [Distribución ramificada a los flujos de entrega de Firehose](sns-firehose-as-subscriber.md). |
Puede usar Amazon SNS para crear aplicaciones basadas en eventos que utilicen los servicios de suscriptor para realizar trabajos de manera automática en respuesta a eventos desencadenados por los servicios de publicador. Este patrón arquitectónico puede hacer que los servicios sean más reutilizables, interoperables y escalables. Sin embargo, puede ser muy laborioso bifurcar el procesamiento de eventos a canalizaciones que cumplan los requisitos comunes de administración de eventos, como el almacenamiento, la copia de seguridad, la búsqueda, el análisis y la reproducción de eventos.
Para acelerar el desarrollo de sus aplicaciones basadas en eventos, puede suscribir canales de gestión de eventos (impulsados por Event Fork AWS Pipelines) a los temas de Amazon SNS. AWS **Event Fork Pipelines es un conjunto de [aplicaciones anidadas de código abierto, basadas en el modelo de aplicaciones AWS](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-nested-applications.html) [sin servidor](https://aws.amazon.com/serverless/sam/) (AWS SAM), que puede implementar directamente desde el paquete [AWS Event Fork Pipelines (elija Mostrar aplicaciones que creen funciones de IAM personalizadas o políticas de recursos) en su cuenta](https://serverlessrepo.aws.amazon.com/applications?query=aws-event-fork-pipelines).** AWS
Para ver un AWS caso de uso de Event Fork Pipelines, consulte. [Implementación y prueba de la aplicación de ejemplo de canalizaciones de bifurcación de eventos de Amazon SNS](sns-deploy-test-fork-pipelines-sample-application.md)
**Topics**
+ [Cómo funciona AWS Event Fork Pipelines](#how-sns-fork-works)
+ [Implementación de Event Fork Pipelines AWS](#deploying-sns-fork-pipelines)
+ [Implementación y prueba de la aplicación de ejemplo de canalizaciones de bifurcación de eventos de Amazon SNS](sns-deploy-test-fork-pipelines-sample-application.md)
+ [Suscripción de AWS Event Fork Pipelines a un tema de Amazon SNS](sns-subscribe-event-fork-pipelines.md)
## Cómo funciona AWS Event Fork Pipelines
AWS Event Fork Pipelines es un patrón de diseño sin servidor. Sin embargo, también es un conjunto de aplicaciones anidadas sin servidor basadas en AWS SAM (que puede implementar directamente desde el AWS Serverless Application Repository (AWS SAR) al suyo para enriquecer sus Cuenta de AWS plataformas basadas en eventos). Puede implementar estas aplicaciones anidadas de forma individual, según lo requiera su arquitectura.
**Topics**
+ [Canalización de almacenamiento y copia de seguridad de eventos](#sns-fork-event-storage-and-backup-pipeline)
+ [Canalización de búsqueda y análisis de eventos](#sns-fork-event-search-and-analytics-pipeline)
+ [Canalización de reproducción de eventos](#sns-fork-event-replay-pipeline)
El siguiente diagrama muestra una aplicación AWS Event Fork Pipelines complementada con tres aplicaciones anidadas. Puede implementar cualquiera de las canalizaciones del paquete AWS Event Fork Pipelines en el AWS SAR de forma independiente, según lo requiera su arquitectura.
![\[La arquitectura AWS Event Fork Pipelines, que muestra cómo se filtran y procesan los eventos de un tema de Amazon SNS a través de tres canalizaciones distintas: Event Storage and Backup, Event Search and Analytics y Event Replay. Estas canalizaciones se representan como cajas apiladas verticalmente, cada una de las cuales procesa de forma independiente eventos en paralelo desde el mismo tema de Amazon SNS.\]](http://docs.aws.amazon.com/es_es/sns/latest/dg/images/sns-fork-pipeline-as-subscriber-how-it-works.png)
Cada canalización está suscrita al mismo tema de Amazon SNS, lo que le permite procesar eventos en paralelo a medida que se publican en el tema. Cada canalización es independiente y puede establecer su propia [política de filtros de suscripción](sns-subscription-filter-policies.md). De este modo, una canalización puede procesar solo un subconjunto de los eventos que le interesan (en lugar de todos los eventos publicados en el tema).
**nota**
Como colocas las tres canalizaciones de AWS Event Fork junto a las canalizaciones de procesamiento de eventos habituales (es posible que ya estés suscrito a tu tema de Amazon SNS), no necesitas cambiar ninguna parte de tu editor de mensajes actual para aprovechar las canalizaciones de AWS Event Fork en tus cargas de trabajo actuales.
### Canalización de almacenamiento y copia de seguridad de eventos
En el siguiente diagrama se muestra la [canalización de almacenamiento y copia de seguridad de eventos](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~fork-event-storage-backup-pipeline). Puede suscribir esta canalización a su tema de Amazon SNS para hacer una copia de seguridad automática de los eventos que pasan por su sistema.
Esta canalización se compone de una cola de Amazon SQS que almacena en búfer los eventos publicados por el tema de Amazon SNS, una AWS Lambda función que sondea automáticamente estos eventos de la cola y los coloca en una transmisión, y un depósito de Amazon S3 que hace copias de seguridad duraderas de los eventos cargados por la transmisión.
![\[El Fork-Event-Storage-Backup -Pipeline, que está diseñado para procesar y realizar copias de seguridad de eventos de un tema de Amazon SNS. El flujo comienza con un tema de Amazon SNS desde el que los eventos se distribuyen a una cola de Amazon SQS. A continuación, una función de Lambda procesa estos eventos filtrados y los reenvía a una instancia de Data Firehose. El flujo de Firehose se encarga de almacenar en búfer, transformar y comprimir los eventos antes de cargarlos en un bucket de copia de seguridad de Amazon S3. Por último, se puede utilizar Amazon Athena para consultar los datos almacenados. El diagrama utiliza una serie de iconos y flechas para ilustrar el flujo de un servicio al siguiente, en el que cada componente de la canalización está etiquetado claramente.\]](http://docs.aws.amazon.com/es_es/sns/latest/dg/images/sns-fork-event-storage-and-backup-pipeline.png)
Para optimizar el comportamiento del flujo de Firehose, puede configurarlo para que almacene en búfer, transforme y comprima los eventos antes de cargarlos en el bucket. A medida que se carguen los eventos, puede utilizar Amazon Athena para consultar el bucket mediante consultas de SQL estándar. También puede configurar la canalización para reutilizar un bucket de Amazon S3 existente o crear uno nuevo.
### Canalización de búsqueda y análisis de eventos
En el siguiente diagrama se muestra la [canalización de búsqueda y análisis de eventos](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~fork-event-search-analytics-pipeline). Puede suscribir esta canalización a su tema de Amazon SNS para indexar los eventos que pasan por su sistema en un dominio de búsqueda y, a continuación, ejecutar análisis en ellos.
Esta canalización se compone de una cola de Amazon SQS que almacena en búfer los eventos publicados por el tema de Amazon SNS, una AWS Lambda función que sondea los eventos de la cola y los envía a una transmisión, un dominio de Amazon OpenSearch Service que indexa los eventos cargados por la transmisión Firehose y un depósito de Amazon S3 que almacena los eventos sin procesar que no se pueden indexar en el dominio de búsqueda.
![\[La canalización de búsqueda y análisis de eventos dentro de una arquitectura. AWS Comienza a la izquierda con el tema de Amazon SNS recibiendo todos los eventos. Luego, estos eventos se canalizan a través de una línea discontinua que representa los “eventos filtrados distribuidos” hacia una cola de Amazon SQS. Desde la cola, una función de Lambda procesa estos eventos y los reenvía a un flujo de Data Firehose. Data Firehose dirige los eventos a dos destinos: una ruta lleva a una instancia de Amazon Elasticsearch Service para su indexación y la otra envía los eventos no procesables o fallidos a un bucket de eventos fallidos de Amazon S3. En el extremo derecho, el resultado de Elasticsearch Service se envía a un panel de Kibana para su análisis y visualización. Todo el flujo se presenta horizontalmente y cada componente está conectado por líneas que muestran la dirección del flujo de datos.\]](http://docs.aws.amazon.com/es_es/sns/latest/dg/images/sns-fork-event-search-and-analytics-pipeline.png)
Si desea ajustar el flujo de Firehose en cuanto al almacenamiento en búfer, la transformación y la compresión de eventos, puede configurar esta canalización.
También puedes configurar si la canalización debe reutilizar un OpenSearch dominio existente en el tuyo Cuenta de AWS o crear uno nuevo para ti. A medida que los eventos se indexan en el dominio de búsqueda, puede utilizar Kibana para ejecutar análisis de sus eventos y actualizar los paneles visuales en tiempo real.
### Canalización de reproducción de eventos
En el siguiente diagrama se muestra la [canalización de reproducción de eventos](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~fork-event-replay-pipeline). Para registrar los eventos que ha procesado el sistema en los últimos 14 días (por ejemplo, cuando su plataforma necesita recuperarse de un error), puede suscribir esta canalización a su tema de Amazon SNS y, a continuación, volver a procesar los eventos.
Esta canalización está compuesta por una cola de Amazon SQS que almacena en búfer los eventos publicados por el tema de Amazon SNS y una AWS Lambda función que sondea los eventos de la cola y los redirige a su canalización de procesamiento de eventos normal, que también está suscrita a su tema.
![\[La canalización de reproducción de eventos en formato de diagrama de flujo. De izquierda a derecha, comienza con un tema de Amazon SNS que distribuye los eventos filtrados a dos procesos paralelos. El flujo superior representa la canalización de procesamiento de eventos habitual, que incluye una cola de Amazon SQS que procesa los eventos. El flujo inferior, denominado «»fork-event-replay-pipeline, incluye una cola de reproducción de Amazon SQS en la que los eventos se almacenan temporalmente antes de ser procesados por una función de reproducción de Lambda. Esta función de Lambda tiene la capacidad de redirigir los eventos a su canalización de procesamiento de eventos normal o retenerlos para su reproducción, en función de si la característica de reproducción está habilitada o deshabilitada. El diagrama también indica que los operadores pueden activar o desactivar la característica de reproducción de eventos.\]](http://docs.aws.amazon.com/es_es/sns/latest/dg/images/sns-fork-event-replay-pipeline.png)
**nota**
De forma predeterminada, la característica de reproducción está deshabilitada, por lo que los eventos no se redireccionan. Si necesita volver a procesar los eventos, debe habilitar la cola de reproducción de Amazon SQS como fuente de eventos para la característica de reproducción de AWS Lambda .
## Implementación de Event Fork Pipelines AWS
[La [suite AWS Event Fork Pipelines](https://serverlessrepo.aws.amazon.com/applications?query=aws-event-fork-pipelines) (elija **Mostrar aplicaciones que creen funciones de IAM o políticas de recursos personalizadas**) está disponible como un grupo de aplicaciones públicas en el AWS Serverless Application Repository, desde donde puede desplegarlas y probarlas manualmente mediante la AWS Lambda consola.](https://console.aws.amazon.com/lambda/) Para obtener información sobre la implementación de canalizaciones mediante la AWS Lambda consola, consulte. [Suscripción de AWS Event Fork Pipelines a un tema de Amazon SNS](sns-subscribe-event-fork-pipelines.md)
En un escenario de producción, recomendamos incrustar AWS Event Fork Pipelines en la plantilla SAM general de AWS la aplicación. La función de aplicación anidada le permite hacerlo añadiendo el recurso `[AWS::Serverless::Application](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template.html#serverless-sam-template-application)` a su plantilla de AWS SAM, haciendo referencia al AWS SAR `ApplicationId` y al de la aplicación anidada. `SemanticVersion`
Por ejemplo, puedes usar Event Storage and Backup Pipeline como una aplicación anidada añadiendo el siguiente fragmento de código YAML a la `Resources` sección de tu plantilla SAM. AWS
```
Backup:
Type: AWS::Serverless::Application
Properties:
Location:
ApplicationId: arn:aws:serverlessrepo:us-east-2:123456789012:applications/fork-event-storage-backup-pipeline
SemanticVersion: 1.0.0
Parameters:
#The ARN of the Amazon SNS topic whose messages should be backed up to the Amazon S3 bucket.
TopicArn: !Ref MySNSTopic
```
Al especificar los valores de los parámetros, puede utilizar funciones AWS CloudFormation intrínsecas para hacer referencia a otros recursos de la plantilla. Por ejemplo, en el fragmento de código YAML anterior, el `TopicArn` parámetro hace referencia al `[AWS::SNS::Topic](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-sns-topic.html)` recurso`MySNSTopic`, definido en otra parte de la plantilla. AWS SAM Para obtener más información, consulte la [Referencia de funciones intrínsecas](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference.html) en la *Guía del usuario de AWS CloudFormation *.
**nota**
La página de la AWS Lambda consola de la aplicación AWS SAR incluye el botón **Copiar como recurso SAM, que copia** en el portapapeles el YAML necesario para anidar una aplicación AWS SAR.
# Implementación y prueba de la aplicación de ejemplo de canalizaciones de bifurcación de eventos de Amazon SNS
Para acelerar el desarrollo de sus aplicaciones basadas en eventos, puede suscribir canales de gestión de eventos (impulsados por Event Fork AWS Pipelines) a temas de Amazon SNS. AWS **Event Fork Pipelines es un conjunto de [aplicaciones anidadas de código abierto, basadas en el modelo de aplicaciones AWS](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-nested-applications.html) [sin servidor](https://aws.amazon.com/serverless/sam/) (AWS SAM), que puede implementar directamente desde el paquete [AWS Event Fork Pipelines (elija Mostrar aplicaciones que creen funciones de IAM personalizadas o políticas de recursos) en su cuenta](https://serverlessrepo.aws.amazon.com/applications?query=aws-event-fork-pipelines).** AWS Para obtener más información, consulte [Cómo funciona AWS Event Fork Pipelines](sns-fork-pipeline-as-subscriber.md#how-sns-fork-works).
En esta página, se muestra cómo puede utilizarla Consola de administración de AWS para implementar y probar la aplicación de ejemplo Event Fork Pipelines. AWS
**importante**
Para evitar incurrir en costes no deseados una vez que termine de implementar la aplicación de ejemplo AWS Event Fork Pipelines, elimine su pila. CloudFormation Para obtener más información, consulte [Eliminación de una pila en la consola de CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-delete-stack.html) en la *Guía del usuario de AWS CloudFormation *.
# AWS Ejemplo de caso de uso de Event Fork Pipelines
El siguiente escenario describe una aplicación de comercio electrónico sin servidor y basada en eventos que utiliza AWS Event Fork Pipelines. Puede utilizar este [ejemplo de aplicación de comercio electrónico](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~fork-example-ecommerce-checkout-api) en la consola AWS Serverless Application Repository y, a continuación, implementarla en la suya Cuenta de AWS mediante la AWS Lambda consola, donde podrá probarla y examinar su código fuente. GitHub
![\[La arquitectura de una aplicación de comercio electrónico sin servidor que integra Servicios de AWS. Describe el flujo de los usuarios de comercio electrónico que realizan pedidos a través de una API Gateway con diferentes canalizaciones de procesamiento, incluidos el almacenamiento de pedidos, el análisis de búsquedas y la reproducción, con el fin de demostrar cómo se administran y analizan los eventos a través de Amazon SNS, Lambda, Amazon SQS, DynamoDB y Kibana.\]](http://docs.aws.amazon.com/es_es/sns/latest/dg/images/sns-fork-example-use-case.png)
Esta aplicación de comercio electrónico recibe los pedidos de los compradores a través de una RESTful API alojada en API Gateway y respaldada por la AWS Lambda función`CheckoutApiBackendFunction`. Con esta función, se publican todos los pedidos recibidos en un tema de Amazon SNS llamado `CheckoutEventsTopic` que, a su vez, distribuye los pedidos a cuatro canalizaciones diferentes.
La primera canalización es la canalización normal de procesamiento de pago que ha diseñado e implementado el propietario de la aplicación de comercio electrónico. Esta canalización incluye la cola Amazon SQS `CheckoutQueue` que almacena en búfer todos los pedidos recibidos, una AWS Lambda función denominada `CheckoutFunction` que sondea la cola para procesar estos pedidos y la tabla DynamoDB que guarda de forma segura todos los pedidos realizados. `CheckoutTable`
## Aplicando Event Fork AWS Pipelines
Los componentes de la aplicación de comercio electrónico controlan la lógica de negocio central. Sin embargo, el propietario de la aplicación de comercio electrónico también debe tener en cuenta lo siguiente:
+ **Conformidad**: copias de seguridad seguras y comprimidas, encriptadas en reposo, y saneamiento de la información confidencial.
+ **Resistencia**: reproducción de los pedidos más recientes en caso de que se interrumpa el proceso de gestión logística.
+ **Capacidad de búsqueda**: ejecutar análisis y generar métricas en pedidos realizados.
En lugar de implementar esta lógica de procesamiento de eventos, el propietario de la aplicación puede suscribir AWS Event Fork Pipelines al tema `CheckoutEventsTopic` Amazon SNS.
+ [Canalización de almacenamiento y copia de seguridad de eventos](sns-fork-pipeline-as-subscriber.md#sns-fork-event-storage-and-backup-pipeline) se ha configurado para transformar los datos a fin de eliminar los detalles de la tarjeta de crédito, almacenar en búfer los datos durante 60 segundos, comprimirlos mediante GZIP y cifrarlos mediante la clave administrada por el cliente predeterminada para Amazon S3. Esta clave es administrada AWS y alimentada por AWS Key Management Service ()AWS KMS.
Para obtener más información, consulte [Choose Amazon S3 For Your Destination](https://docs.aws.amazon.com/firehose/latest/dev/create-destination.html#create-destination-s3), [Amazon Data Firehose Data Transformation](https://docs.aws.amazon.com/firehose/latest/dev/data-transformation.html) y [Configure Settings](https://docs.aws.amazon.com/firehose/latest/dev/create-configure.html) en la *Guía para desarrolladores de Amazon Data Firehose*.
+ [Canalización de búsqueda y análisis de eventos](sns-fork-pipeline-as-subscriber.md#sns-fork-event-search-and-analytics-pipeline) se ha configurado con una duración de reintento de índice de 30 segundos, un bucket para almacenar los pedidos que no se han indexado en el dominio de búsqueda y una política de filtro para restringir el conjunto de pedidos indexados.
Para obtener más información, consulte [Elija un OpenSearch servicio para su destino](https://docs.aws.amazon.com/firehose/latest/dev/create-destination.html#create-destination-elasticsearch) en la Guía para *desarrolladores de Amazon Data Firehose*.
+ [Canalización de reproducción de eventos](sns-fork-pipeline-as-subscriber.md#sns-fork-event-replay-pipeline) se ha configurado con la parte de cola de Amazon SQS de la canalización normal de procesamiento de pedidos que ha diseñado e implementado el propietario de la aplicación de comercio electrónico.
Para obtener más información, consulte [Nombre y URL de la cola](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-general-identifiers.html#queue-name-url) en la *Guía para desarrolladores de Amazon Simple Queue Service*.
La siguiente política de filtro de JSON se establece en la configuración para la canalización de búsqueda y análisis de eventos. Solo coincide con los pedidos entrantes en los que el importe total es de 100 USD o superior. Para obtener más información, consulte [Filtrado de mensajes en Amazon SNS](sns-message-filtering.md).
```
{
"amount": [{ "numeric": [ ">=", 100 ] }]
}
```
Al utilizar el patrón AWS Event Fork Pipelines, el propietario de la aplicación de comercio electrónico puede evitar la sobrecarga de desarrollo que suele implicar la programación de una lógica indiferenciada para la gestión de eventos. En su lugar, puede implementar AWS Event Fork Pipelines directamente desde dentro de ella. AWS Serverless Application Repository Cuenta de AWS
# Paso 1: implementar la aplicación de ejemplo de Amazon SNS
1. Inicie sesión en la [consola de AWS Lambda](https://console.aws.amazon.com/lambda/).
1. En el panel de navegación, elija **Functions (Funciones)** y, a continuación, **Create function (Crear función)**.
1. En la página **Create function (Crear función)**, proceda del modo siguiente:
1. Elija **Examinar el repositorio de aplicaciones sin servidor**, **Aplicaciones públicas**, **Mostrar aplicaciones que crean roles de IAM personalizados o políticas de recursos**.
1. Busque `fork-example-ecommerce-checkout-api` y, a continuación, elija la aplicación.
1. En la página **fork-example-ecommerce-checkout-api**, haga lo siguiente:
1. En la sección **Application settings (Configuración de la aplicación)**, escriba el valor de **Application name (Nombre de aplicación)** (por ejemplo, `fork-example-ecommerce-my-app`).
**nota**
Para encontrar fácilmente sus recursos más tarde, mantenga el prefijo `fork-example-ecommerce`.
Para cada implementación, el nombre de la aplicación debe ser único. Si reutilizas el nombre de una aplicación, la implementación solo actualizará la CloudFormation pila implementada anteriormente (en lugar de crear una nueva).
1. (Opcional) Introduzca una de las siguientes **LogLevel**configuraciones para la ejecución de la función Lambda de la aplicación:
+ `DEBUG`
+ `ERROR`
+ `INFO` (predeterminado)
+ `WARNING`
1. Elija **I acknowledge that this app creates custom IAM roles, resource policies and deploys nested applications (Confirmo que esta aplicación crea políticas de recursos o roles de IAM personalizados e implementa aplicaciones anidadas)** y, a continuación, en la parte inferior de la página, elija **Deploy (Implementar)**.
En la *my-app* página **Estado de despliegue de fork-example-ecommerce -**, Lambda muestra el estado **Su aplicación se está desplegando**.
En la sección **Recursos**, CloudFormation comienza a crear la pila y muestra el **estado CREATE\$1IN\$1PROGRESS** de cada recurso. **Cuando se completa el proceso, muestra el estado CREATE\$1COMPLETE. CloudFormation **
**nota**
La implementación de todos los recursos puede tardar entre 20 y 30 minutos.
Cuando se haya completado la implementación, Lambda muestra el estado **La aplicación se ha implementado**.
# Paso 2: ejecutar la aplicación de ejemplo vinculada a SNS
1. **En la AWS Lambda consola, en el panel de navegación, selecciona Aplicaciones.**
1. En la página **Applications (Aplicaciones)**, en el campo de búsqueda, busque `serverlessrepo-fork-example-ecommerce-my-app` y, a continuación, seleccione la aplicación.
1. En la sección **Resources (Recursos)**, haga lo siguiente:
1. Para buscar el recurso cuyo tipo es **ApiGatewayRestApi**, por ejemplo, ordene los recursos por **tipo** y`ServerlessRestApi`, a continuación, amplíe el recurso.
1. Se muestran dos recursos anidados, de los tipos **ApiGatewayDeployment** y **ApiGatewayStage**.
1. Copie el enlace **Prod API endpoint (Punto de enlace de la API de Prod)** y añádale `/checkout`, por ejemplo:
```
https://abcdefghij.execute-api.us-east-2.amazonaws.com/Prod/checkout
```
1. Copie el siguiente código JSON a un archivo denominado `test_event.json`.
```
{
"id": 15311,
"date": "2019-03-25T23:41:11-08:00",
"status": "confirmed",
"customer": {
"id": 65144,
"quantity": 2,
"price": 25.00,
"subtotal": 50.00
}]
}
```
1. Para enviar una solicitud HTTPS a su punto de enlace de la API, pase la carga de evento de muestra como entrada mediante la ejecución de un comando `curl`, por ejemplo:
```
curl -d "$(cat test_event.json)" https://abcdefghij.execute-api.us-east-2.amazonaws.com/Prod/checkout
```
La API devuelve la siguiente respuesta vacía, lo que indica que la ejecución es correcta:
```
{ }
```
# Paso 3: verificar el rendimiento de la aplicación y las canalizaciones de Amazon SNS
## Paso 1: verificar la ejecución de la canalización de pago de ejemplo
1. Inicie sesión en la [consola de Amazon DynamoDB](https://console.aws.amazon.com/dynamodb/).
1. En el panel de navegación, elija **Tables (Tablas)**.
1. Busque `serverlessrepo-fork-example` y elija `CheckoutTable`.
1. En la página de detalles de tabla, elija **Items (Elementos)** y, a continuación, el elemento creado.
Se muestran los atributos almacenados.
## Paso 2: verificar la ejecución de la canalización de almacenamiento y copia de seguridad de eventos
1. Inicie sesión en la [consola de Amazon S3](https://console.aws.amazon.com/s3/).
1. En el panel de navegación, elija **Buckets**.
1. Busque `serverlessrepo-fork-example` y, a continuación, elija `CheckoutBucket`.
1. Navegue por la jerarquía de directorios hasta que encuentre un archivo con la extensión `.gz`.
1. Para descargar el archivo, elija **Actions (Acciones)**, **Open (Abrir)**.
1. La canalización se configura con una función Lambda con la que se sanea la información de la tarjeta de crédito por razones de conformidad.
Para verificar que la carga de JSON almacenada no contiene información de tarjeta de crédito, descomprima el archivo.
## Paso 3: verificar la ejecución de la canalización de búsqueda y análisis de eventos
1. Inicie sesión en la [consola OpenSearch de servicio](https://console.aws.amazon.com/aos/).
1. En el panel de navegación, en **My domains (Mis dominios)**, elija su dominio con el prefijo `serverl-analyt`.
1. La canalización se configura con una política de filtro de suscripciones de Amazon SNS con la que se establece una condición de coincidencia numérica.
****Para comprobar que el evento está indexado porque se refiere a una orden cuyo valor es superior a 100 USD, en la *abcdefgh1ijk* página **serverl-analyt-**, seleccione Indices, checkout\$1events.****
## Paso 4: verificar la ejecución de la canalización de reproducción de eventos
1. Inicie sesión en la [consola de Amazon SQS](https://console.aws.amazon.com/sqs/).
1. En la lista de colas, busque `serverlessrepo-fork-example` y elija `ReplayQueue`.
1. Seleccione **Enviar y recibir mensajes**.
1. **En el cuadro de *123ABCD4E5F6* diálogo **Enviar y recibir mensajes en fork-example-ecommerce -*my-app*... ReplayP- ReplayQueue -, seleccione Sondear** los mensajes.**
1. Para verificar que el evento está en cola, seleccione **More Details (Más detalles)** junto al mensaje que aparece en la cola.
# Paso 4: simular un problema y reproducir eventos para la recuperación
## Paso 1: habilitar el problema simulado y enviar una segunda solicitud de API
1. Inicie sesión en la [consola de AWS Lambda](https://console.aws.amazon.com/lambda/).
1. En el panel de navegación, elija **Functions (Funciones)**.
1. Busque `serverlessrepo-fork-example` y elija `CheckoutFunction`.
1. En el **fork-example-ecommerce- - *my-app* -... CheckoutFunction *ABCDEF*** **página, en la sección **Variables de entorno**, defina la variable **BUG\$1ENABLED en** **true** y, a continuación, seleccione Guardar.**
1. Copie el siguiente código JSON a un archivo denominado `test_event_2.json`.
```
{
"id": 9917,
"date": "2019-03-26T21:11:10-08:00",
"status": "confirmed",
"customer": {
"id": 56999,
"quantity": 1,
"price": 75.00,
"subtotal": 75.00
}]
}
```
1. Para enviar una solicitud HTTPS a su punto de enlace de la API, pase la carga de evento de muestra como entrada mediante la ejecución de un comando `curl`, por ejemplo:
```
curl -d "$(cat test_event_2.json)" https://abcdefghij.execute-api.us-east-2.amazonaws.com/Prod/checkout
```
La API devuelve la siguiente respuesta vacía, lo que indica que la ejecución es correcta:
```
{ }
```
## Paso 2: verificar la corrupción de datos simulada
1. Inicie sesión en la [consola de Amazon DynamoDB](https://console.aws.amazon.com/dynamodb/).
1. En el panel de navegación, elija **Tables (Tablas)**.
1. Busque `serverlessrepo-fork-example` y elija `CheckoutTable`.
1. En la página de detalles de tabla, elija **Items (Elementos)** y, a continuación, el elemento creado.
Se muestran los atributos almacenados, algunos marcados como **CORRUPTED\$1 (Dañados)**.
## Paso 3: deshabilitar el problema simulado
1. Inicie sesión en la [consola de AWS Lambda](https://console.aws.amazon.com/lambda/).
1. En el panel de navegación, elija **Functions (Funciones)**.
1. Busque `serverlessrepo-fork-example` y elija `CheckoutFunction`.
1. En el **fork-example-ecommerce- - *my-app* -... CheckoutFunction *ABCDEF*** **página, en la sección **Variables de entorno**, defina la variable **BUG\$1ENABLED en** **false** y, a continuación, seleccione Guardar.**
## Paso 4: habilitar la reproducción para la recuperación del problema
1. **En la AWS Lambda consola, en el panel de navegación, selecciona Funciones.**
1. Busque `serverlessrepo-fork-example` y elija `ReplayFunction`.
1. Expanda la sección **Designer (Diseñador)**, elija el mosaico **SQS** y, a continuación, en la sección **SQS**, elija **Enabled (Habilitado)**.
**nota**
El desencadenador de fuentes de eventos de Amazon SQS tarda aproximadamente un minuto en habilitarse.
1. Seleccione **Save**.
1. Para ver los atributos recuperados, vuelva a la consola de Amazon DynamoDB.
1. Para deshabilitar la reproducción, regrese a la AWS Lambda consola y desactive el activador de la fuente de eventos de Amazon SQS para. `ReplayFunction`
# Suscripción de AWS Event Fork Pipelines a un tema de Amazon SNS
Para acelerar el desarrollo de sus aplicaciones basadas en eventos, puede suscribir canales de gestión de eventos (impulsados por Event Fork AWS Pipelines) a los temas de Amazon SNS. AWS **Event Fork Pipelines es un conjunto de [aplicaciones anidadas de código abierto, basadas en el modelo de aplicaciones AWS](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-nested-applications.html) [sin servidor](https://aws.amazon.com/serverless/sam/) (AWS SAM), que puede implementar directamente desde el paquete [AWS Event Fork Pipelines (elija Mostrar aplicaciones que creen funciones de IAM personalizadas o políticas de recursos) en su cuenta](https://serverlessrepo.aws.amazon.com/applications?query=aws-event-fork-pipelines).** AWS Para obtener más información, consulte [Cómo funciona AWS Event Fork Pipelines](sns-fork-pipeline-as-subscriber.md#how-sns-fork-works).
En esta sección, se muestra cómo se puede utilizar Consola de administración de AWS para implementar una canalización y, a continuación, suscribir AWS Event Fork Pipelines a un tema de Amazon SNS. Antes de comenzar, [cree un tema de Amazon SNS](sns-create-topic.md).
Para eliminar los recursos que componen una canalización, busque la canalización en la página de **aplicaciones** de la AWS Lambda consola, expanda la **sección de plantillas de SAM**, elija **CloudFormationpila** y, a continuación, elija **Otras acciones**, **eliminar** pila.
# Implementación y suscripción de la canalización de almacenamiento y copia de seguridad de eventos en Amazon SNS
| |
| --- |
| Para el archivado y el análisis de eventos, Amazon SNS recomienda ahora utilizar su integración nativa con Amazon Data Firehose. Puede suscribir las transmisiones de entrega de Firehose a temas de SNS, lo que le permite enviar notificaciones a puntos de enlace de archivado y análisis, como depósitos de Amazon Simple Storage Service (Amazon S3), tablas de Amazon Redshift, Amazon Service (Service) y más. OpenSearch OpenSearch El uso de Amazon SNS con las transmisiones de entrega de Firehose es una solución totalmente gestionada y sin código que no requiere el uso de funciones. AWS Lambda Para obtener más información, consulte [Distribución ramificada a los flujos de entrega de Firehose](sns-firehose-as-subscriber.md). |
En este tutorial, se muestra cómo implementar la [canalización de almacenamiento y copia de seguridad de eventos](sns-fork-pipeline-as-subscriber.md#sns-fork-event-storage-and-backup-pipeline) y suscribirla a un tema de Amazon SNS. Este proceso convierte automáticamente la AWS SAM plantilla asociada a la canalización en una CloudFormation pila y, a continuación, implementa la pila en la suya. Cuenta de AWS Este proceso también crea y configura el conjunto de recursos que componen la canalización de almacenamiento y copia de seguridad de eventos, incluidos los siguientes:
+ Cola de Amazon SQS
+ Función de Lambda
+ Flujo de entrega de Firehose
+ Bucket de copia de seguridad de Amazon S3
Para obtener más información sobre la configuración de un flujo con un bucket de Amazon S3 como destino, consulte `[S3DestinationConfiguration](https://docs.aws.amazon.com/firehose/latest/APIReference/API_S3DestinationConfiguration.html)` en la *Referencia de la API de Amazon Data Firehose*.
Para obtener más información sobre la transformación de eventos y la configuración del almacenamiento en búfer de eventos, la compresión y el cifrado de eventos, consulte [Creación de un flujo de entrega](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html) en la *Guía para desarrolladores de Amazon Data Firehose*.
Para obtener más información sobre el filtrado de eventos, consulte [Políticas de filtro de suscripciones de Amazon SNS](sns-subscription-filter-policies.md) en esta guía.
1. Inicie sesión en la [consola de AWS Lambda](https://console.aws.amazon.com/lambda/).
1. En el panel de navegación, elija **Functions (Funciones)** y, a continuación, **Create function (Crear función)**.
1. En la página **Create function (Crear función)**, proceda del modo siguiente:
1. Elija **Examinar el repositorio de aplicaciones sin servidor**, **Aplicaciones públicas**, **Mostrar aplicaciones que crean roles de IAM personalizados o políticas de recursos**.
1. Busque `fork-event-storage-backup-pipeline` y, a continuación, elija la aplicación.
1. En la página **fork-event-storage-backup-pipeline**, haz lo siguiente:
1. En la sección **Application settings (Configuración de la aplicación)**, escriba el valor de **Application name (Nombre de aplicación)** (por ejemplo, `my-app-backup`).
**nota**
Para cada implementación, el nombre de la aplicación debe ser único. Si reutilizas el nombre de una aplicación, la implementación solo actualizará la CloudFormation pila implementada anteriormente (en lugar de crear una nueva).
1. (Opcional) Para **BucketArn**, introduzca el ARN del bucket de Amazon S3 en el que se cargan los eventos entrantes. Si no introduce ningún valor, se crea un nuevo bucket de Amazon S3 en su AWS cuenta.
1. (Opcional) Para **DataTransformationFunctionArn**, introduzca el ARN de la función Lambda a través de la cual se transforman los eventos entrantes. Si no escribe un valor, se deshabilita la transformación de datos.
1. (Opcional) Introduzca una de las siguientes **LogLevel**configuraciones para la ejecución de la función Lambda de la aplicación:
+ `DEBUG`
+ `ERROR`
+ `INFO` (predeterminado)
+ `WARNING`
1. Para **TopicArn**, introduzca el ARN del tema de Amazon SNS al que se va a suscribir esta instancia de la canalización de bifurcación.
1. (Opcional) Para **StreamBufferingIntervalInSeconds**e **StreamBufferingSizeInMBs**, introduzca los valores para configurar el almacenamiento en búfer de los eventos entrantes. Si no escribe ningún valor, se utilizan 300 segundos y 5 MB.
1. (Opcional) Introduzca uno de los siguientes **StreamCompressionFormat**ajustes para comprimir los eventos entrantes:
+ `GZIP`
+ `SNAPPY`
+ `UNCOMPRESSED` (predeterminado)
+ `ZIP`
1. (Opcional) Para **StreamPrefix**, introduzca el prefijo de cadena para nombrar los archivos almacenados en el bucket de copias de seguridad de Amazon S3. Si no escribe un valor, no se usa ningún prefijo.
1. (Opcional) Para **SubscriptionFilterPolicy**, introduzca la política de filtrado de suscripciones de Amazon SNS, en formato JSON, que se utilizará para filtrar los eventos entrantes. La política de filtrado decide qué eventos se indexan en el índice de OpenSearch servicios. Si no escribe ningún valor, no se utiliza el filtrado (se indexan todos los eventos).
1. (Opcional) Para **SubscriptionFilterPolicyScope**, introduzca la cadena `MessageBody` o `MessageAttributes` para habilitar el filtrado de mensajes basado en la carga útil o en los atributos.
1. Elija **I acknowledge that this app creates custom IAM roles, resource policies and deploys nested applications (Confirmo que esta aplicación crea políticas de recursos o roles de IAM personalizados e implementa aplicaciones anidadas)** y, a continuación, elija **Deploy (Implementar)**.
En la *my-app* página **Estado de despliegue** de, Lambda muestra el estado **Su aplicación se está desplegando**.
En la sección **Recursos**, CloudFormation comienza a crear la pila y muestra el **estado CREATE\$1IN\$1PROGRESS** de cada recurso. **Cuando se completa el proceso, muestra el estado CREATE\$1COMPLETE. CloudFormation **
Cuando se haya completado la implementación, Lambda muestra el estado **La aplicación se ha implementado**.
Los mensajes publicados en su tema de Amazon SNS se almacenan en el bucket de copia de seguridad de Amazon S3 aprovisionado de manera automática por la canalización de almacenamiento y copia de seguridad de eventos.
# Implementación y suscripción de la canalización de búsqueda y análisis de eventos en Amazon SNS
| |
| --- |
| Para el archivado y el análisis de eventos, Amazon SNS recomienda ahora utilizar su integración nativa con Amazon Data Firehose. Puede suscribir las transmisiones de entrega de Firehose a temas de SNS, lo que le permite enviar notificaciones a puntos de enlace de archivado y análisis, como depósitos de Amazon Simple Storage Service (Amazon S3), tablas de Amazon Redshift, Amazon Service (Service) y más. OpenSearch OpenSearch El uso de Amazon SNS con las transmisiones de entrega de Firehose es una solución totalmente gestionada y sin código que no requiere el uso de funciones. AWS Lambda Para obtener más información, consulte [Distribución ramificada a los flujos de entrega de Firehose](sns-firehose-as-subscriber.md). |
En este tutorial, se muestra cómo implementar la [canalización de búsqueda y análisis de eventos](sns-fork-pipeline-as-subscriber.md#sns-fork-event-search-and-analytics-pipeline) y suscribirla a un tema de Amazon SNS. Este proceso convierte automáticamente la AWS SAM plantilla asociada a la canalización en una CloudFormation pila y, a continuación, implementa la pila en la suya. Cuenta de AWS Este proceso también crea y configura el conjunto de recursos que componen la canalización de búsqueda y análisis de eventos, incluidos los siguientes:
+ Cola de Amazon SQS
+ Función de Lambda
+ Flujo de entrega de Firehose
+ Dominio OpenSearch de Amazon Service
+ Bucket de Amazon S3 de mensajes fallidos
Para obtener más información sobre la configuración de un flujo con un índice como destino, consulte `[ElasticsearchDestinationConfiguration](https://docs.aws.amazon.com/firehose/latest/APIReference/API_ElasticsearchDestinationConfiguration.html)` en la *Referencia de la API de Amazon Data Firehose*.
Para obtener más información sobre la transformación de eventos y la configuración del almacenamiento en búfer de eventos, la compresión y el cifrado de eventos, consulte [Creación de un flujo de entrega](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html) en la *Guía para desarrolladores de Amazon Data Firehose*.
Para obtener más información sobre el filtrado de eventos, consulte [Políticas de filtro de suscripciones de Amazon SNS](sns-subscription-filter-policies.md) en esta guía.
1. Inicie sesión en la [consola de AWS Lambda](https://console.aws.amazon.com/lambda/).
1. En el panel de navegación, elija **Functions (Funciones)** y, a continuación, **Create function (Crear función)**.
1. En la página **Create function (Crear función)**, proceda del modo siguiente:
1. Elija **Examinar el repositorio de aplicaciones sin servidor**, **Aplicaciones públicas**, **Mostrar aplicaciones que crean roles de IAM personalizados o políticas de recursos**.
1. Busque `fork-event-search-analytics-pipeline` y, a continuación, elija la aplicación.
1. En la página **fork-event-search-analytics-pipeline**, haga lo siguiente:
1. En la sección **Application settings (Configuración de la aplicación)**, escriba el valor de **Application name (Nombre de aplicación)** (por ejemplo, `my-app-search`).
**nota**
Para cada implementación, el nombre de la aplicación debe ser único. Si reutilizas el nombre de una aplicación, la implementación solo actualizará la CloudFormation pila implementada anteriormente (en lugar de crear una nueva).
1. (Opcional) Para **DataTransformationFunctionArn**, introduzca el ARN de la función Lambda utilizada para transformar los eventos entrantes. Si no escribe un valor, se deshabilita la transformación de datos.
1. (Opcional) Introduzca una de las siguientes **LogLevel**configuraciones para la ejecución de la función Lambda de la aplicación:
+ `DEBUG`
+ `ERROR`
+ `INFO` (predeterminado)
+ `WARNING`
1. (Opcional) Para **SearchDomainArn**, introduzca el ARN del dominio del OpenSearch servicio, un clúster que configura la funcionalidad de procesamiento y almacenamiento necesaria. Si no escribe ningún valor, se creará un nuevo dominio con la configuración predeterminada.
1. Para **TopicArn**, introduzca el ARN del tema de Amazon SNS al que se va a suscribir esta instancia de la canalización de bifurcación.
1. Para **SearchIndexName**, introduzca el nombre del índice de OpenSearch servicios para la búsqueda y el análisis de eventos.
**nota**
Las siguientes cuotas se aplican a los nombres de índice:
No pueden incluir letras mayúsculas
No pueden incluir los siguientes caracteres: `\ / * ? " < > | ` , #`
No pueden comenzar por los siguientes caracteres: `- + _`
No pueden ser los siguientes: `. ..`
No pueden tener más de 80 caracteres
No pueden tener más de 255 bytes
No puede contener dos puntos (de OpenSearch Service 7.0)
1. (Opcional) Introduzca una de las siguientes **SearchIndexRotationPeriod**configuraciones para el período de rotación del índice de OpenSearch servicios:
+ `NoRotation` (predeterminado)
+ `OneDay`
+ `OneHour`
+ `OneMonth`
+ `OneWeek`
La rotación de índice agrega una marca temporal al nombre del índice, lo que facilita el vencimiento de los datos antiguos.
1. Para **SearchTypeName**, introduzca el nombre del tipo de OpenSearch servicio para organizar los eventos en un índice.
**nota**
OpenSearch Los nombres de los tipos de servicio pueden contener cualquier carácter (excepto bytes nulos), pero no pueden empezar por él`_`.
En el OpenSearch caso de Service 6.x, solo puede haber un tipo por índice. Si especifica un tipo nuevo para un índice existente que ya tiene otro tipo, Firehose devuelve un error de tiempo de ejecución.
1. (Opcional) Para **StreamBufferingIntervalInSeconds**y **StreamBufferingSizeInMBs**, introduzca los valores para configurar el almacenamiento en búfer de los eventos entrantes. Si no escribe ningún valor, se utilizan 300 segundos y 5 MB.
1. (Opcional) Introduzca uno de los siguientes **StreamCompressionFormat**ajustes para comprimir los eventos entrantes:
+ `GZIP`
+ `SNAPPY`
+ `UNCOMPRESSED` (predeterminado)
+ `ZIP`
1. (Opcional) Para **StreamPrefix**, introduzca el prefijo de cadena para nombrar los archivos almacenados en el depósito de letras muertas de Amazon S3. Si no escribe un valor, no se usa ningún prefijo.
1. (Opcional) Para **StreamRetryDurationInSecons**, introduzca la duración del reintento en los casos en que Firehose no pueda indexar los eventos en OpenSearch el índice de servicios. Si no escribe un valor, se usan 300 segundos.
1. (Opcional) Para **SubscriptionFilterPolicy**, introduzca la política de filtrado de suscripciones de Amazon SNS, en formato JSON, que se utilizará para filtrar los eventos entrantes. La política de filtrado decide qué eventos se indexan en el índice de OpenSearch servicios. Si no escribe ningún valor, no se utiliza el filtrado (se indexan todos los eventos).
1. Elija **I acknowledge that this app creates custom IAM roles, resource policies and deploys nested applications (Confirmo que esta aplicación crea políticas de recursos o roles de IAM personalizados e implementa aplicaciones anidadas)** y, a continuación, elija **Deploy (Implementar)**.
En la *my-app-search* página **Estado de despliegue** de, Lambda muestra el estado **Su aplicación se está desplegando**.
En la sección **Recursos**, CloudFormation comienza a crear la pila y muestra el **estado CREATE\$1IN\$1PROGRESS** de cada recurso. **Cuando se completa el proceso, muestra el estado CREATE\$1COMPLETE. CloudFormation **
Cuando se haya completado la implementación, Lambda muestra el estado **La aplicación se ha implementado**.
Los mensajes publicados en tu tema de Amazon SNS se indexan automáticamente en el índice de OpenSearch servicios proporcionado por la canalización de búsqueda y análisis de eventos. Si la canalización no puede indexar un evento, lo almacena en un bucket de mensajes fallidos de Amazon S3.
# Implementación de la canalización de reproducción de eventos con la integración de Amazon SNS
En este tutorial, se muestra cómo implementar la [canalización de reproducción de eventos](sns-fork-pipeline-as-subscriber.md#sns-fork-event-replay-pipeline) y suscribirla a un tema de Amazon SNS. Este proceso convierte automáticamente la AWS SAM plantilla asociada a la canalización en una CloudFormation pila y, a continuación, despliega la pila en la suya Cuenta de AWS. Con este proceso, también se crea y configura el conjunto de recursos que componen la canalización de reproducción de eventos, incluida una cola de Amazon SQS y una función Lambda.
Para obtener más información sobre el filtrado de eventos, consulte [Políticas de filtro de suscripciones de Amazon SNS](sns-subscription-filter-policies.md) en esta guía.
1. Inicie sesión en la [consola de AWS Lambda](https://console.aws.amazon.com/lambda/).
1. En el panel de navegación, elija **Functions (Funciones)** y, a continuación, **Create function (Crear función)**.
1. En la página **Create function (Crear función)**, proceda del modo siguiente:
1. Elija **Examinar el repositorio de aplicaciones sin servidor**, **Aplicaciones públicas**, **Mostrar aplicaciones que crean roles de IAM personalizados o políticas de recursos**.
1. Busque `fork-event-replay-pipeline` y, a continuación, elija la aplicación.
1. En la página **fork-event-replay-pipeline**, haga lo siguiente:
1. En la sección **Application settings (Configuración de la aplicación)**, escriba el valor de **Application name (Nombre de aplicación)** (por ejemplo, `my-app-replay`).
**nota**
Para cada implementación, el nombre de la aplicación debe ser único. Si reutilizas el nombre de una aplicación, la implementación solo actualizará la CloudFormation pila implementada anteriormente (en lugar de crear una nueva).
1. (Opcional) Introduzca una de las siguientes **LogLevel**configuraciones para la ejecución de la función Lambda de la aplicación:
+ `DEBUG`
+ `ERROR`
+ `INFO` (predeterminado)
+ `WARNING`
1. (Opcional) Para **ReplayQueueRetentionPeriodInSeconds**, introduzca el tiempo, en segundos, durante el que la cola de reproducción de Amazon SQS guarda el mensaje. Si no escribe un valor, se usan 1 209 600 segundos (14 días).
1. Para **TopicArn**, introduzca el ARN del tema de Amazon SNS al que se va a suscribir esta instancia de la canalización de bifurcación.
1. Para **DestinationQueueName**, introduzca el nombre de la cola de Amazon SQS a la que la función de reproducción de Lambda reenvía los mensajes.
1. (Opcional) Para **SubscriptionFilterPolicy**, introduzca la política de filtrado de suscripciones de Amazon SNS, en formato JSON, que se utilizará para filtrar los eventos entrantes. La política de filtro decide qué eventos se almacenan en búfer para la reproducción. Si no escribe ningún valor, no se utiliza el filtrado (todos los eventos se almacenan en búfer para la reproducción).
1. Elija **I acknowledge that this app creates custom IAM roles, resource policies and deploys nested applications (Confirmo que esta aplicación crea políticas de recursos o roles de IAM personalizados e implementa aplicaciones anidadas)** y, a continuación, elija **Deploy (Implementar)**.
En la *my-app-replay* página **Estado de despliegue** de, Lambda muestra el estado **Su aplicación se está desplegando**.
En la sección **Recursos**, CloudFormation comienza a crear la pila y muestra el **estado CREATE\$1IN\$1PROGRESS** de cada recurso. **Cuando se completa el proceso, muestra el estado CREATE\$1COMPLETE. CloudFormation **
Cuando se haya completado la implementación, Lambda muestra el estado **La aplicación se ha implementado**.
Los mensajes publicados en su tema de Amazon SNS se almacenan en búfer para reproducirlos en la cola de Amazon SQS aprovisionada de manera automática por la canalización de reproducción de eventos.
**nota**
De forma predeterminada, la reproducción está deshabilitada. Para habilitar la reproducción, vaya a la página de la función en la consola de Lambda, expanda la sección **Diseñador**, seleccione el mosaico **SQS** y, a continuación, en la sección **SQS**, elija **Habilitado**.
# Uso de Amazon EventBridge Scheduler con Amazon SNS
[Amazon EventBridge Scheduler](https://docs.aws.amazon.com/scheduler/latest/UserGuide/what-is-scheduler.html) es un programador sin servidor que le permite crear, ejecutar y gestionar tareas desde un servicio gestionado centralizado. Con EventBridge Scheduler, puede crear planificaciones mediante expresiones de Cron y Rate para patrones recurrentes, o configurar invocaciones únicas. Puede configurar intervalos de tiempo flexibles para la entrega, definir límites de reintentos y establecer el tiempo máximo de retención para las invocaciones de la API.
En esta página se explica cómo usar EventBridge Scheduler para publicar un mensaje de un tema de Amazon SNS de forma programada.
## Configuración del rol de ejecución
Al crear una nueva programación, EventBridge Scheduler debe tener permiso para invocar la operación de la API de destino en su nombre. *Estos permisos se otorgan a EventBridge Scheduler mediante una función de ejecución.* La política de permisos que adjunta al rol de ejecución de su programación define los permisos necesarios. Estos permisos dependen de la API de destino que desee que invoque EventBridge Scheduler.
Cuando utilizas la consola del EventBridge Scheduler para crear una programación, como en el siguiente procedimiento, EventBridge Scheduler configura automáticamente una función de ejecución en función del objetivo seleccionado. Si desea crear un cronograma utilizando uno de los EventBridge planificadores SDKs, debe tener un rol de ejecución existente que otorgue los permisos que el EventBridge programador requiere para invocar un destino. AWS CLI CloudFormation*Para obtener más información sobre la configuración manual de una función de ejecución para su programación, consulte [Configuración de una función de ejecución en la Guía del usuario del Scheduler](https://docs.aws.amazon.com/scheduler/latest/UserGuide/setting-up.html#setting-up-execution-role). EventBridge *
## Creación de una programación
**Creación de una programación con la consola**
1. Abre la consola de Amazon EventBridge Scheduler en [https://console.aws.amazon.com/scheduler/casa.](https://console.aws.amazon.com/scheduler/home/)
1. En la página **Programaciones**, elija **Crear programación**.
1. En la página **Especificar los detalles de la programación**, en la sección **Nombre y descripción de la programación**, proceda del modo siguiente:
1. En **Nombre de la programación**, escriba un nombre para la programación. Por ejemplo, **MyTestSchedule**.
1. (Opcional) En **Descripción**, escriba una descripción para su programación. Por ejemplo, **My first schedule**.
1. En **Grupo de programaciones**, elija un grupo de programaciones de la lista desplegable. Si no tiene un grupo, elija **predeterminado**. Para crear un grupo de programaciones, elija **crear mi propia programación**.
Los grupos de programaciones se utilizan para añadir etiquetas a grupos de programaciones.
1.
1. Elija sus opciones de programación.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sns/latest/dg/using-eventbridge-scheduler.html)
1. (Opcional) Si elige **Programación recurrente** en el paso anterior, en la sección de **Periodo de tiempo**, realice lo siguiente:
1. En **Zona horaria**, elija una zona horaria.
1. En **Fecha y hora de inicio**, introduzca una fecha válida con el formato `YYYY/MM/DD` y, a continuación, especifique una marca de tiempo con el formato `hh:mm` de 24 horas.
1. En **Fecha y hora de finalización**, introduzca una fecha válida con el formato `YYYY/MM/DD` y, a continuación, especifique una marca de tiempo con el formato `hh:mm` de 24 horas.
1. Elija **Siguiente**.
1. En la página **Seleccione el destino**, elija la operación de AWS API que EventBridge Scheduler invoca:
1. Elija **Publicar Amazon SNS**.
1. En la sección **Publicar**, seleccione un tema de SNS o elija **Crear tema de SNS nuevo**.
1. (Opcional) Introduzca una carga útil de JSON. Si no ingresas una carga útil, EventBridge Scheduler utilizará un evento vacío para invocar la función.
1. Elija **Siguiente**.
1. En la página **Configuración**, haga lo siguiente:
1. Para activar la programación, en **Estado de la programación**, cambie a **Habilitar programación**.
1. Para configurar una política de reintentos para su programación, en **Política de reintento y cola de mensajes fallidos (DLQ)**, realice lo siguiente:
+ Cambie a **Reintentar**.
+ En **Duración máxima del evento**, introduce el número máximo de **horas** y **minutos** que EventBridge Scheduler debe mantener sin procesar un evento.
+ El tiempo máximo es de 24 horas.
+ En **Máximo número de reintentos**, introduce el número máximo de veces que EventBridge Scheduler reintenta la programación si el objetivo devuelve un error.
El valor máximo es 185 reintentos.
Con las políticas de reintentos, si un programa no puede invocar su objetivo, Scheduler vuelve a ejecutar el programa. EventBridge Si se encuentra configurado, debe establecer el tiempo máximo de retención y los reintentos máximos para la programación.
1. Elija dónde guarda el EventBridge Scheduler los eventos no entregados.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sns/latest/dg/using-eventbridge-scheduler.html)
1. Para utilizar una clave administrada por el cliente a fin de cifrar la entrada de destino, en **Cifrado**, elija **Personalizar la configuración de cifrado (avanzado)**.
Si elige esta opción, ingrese un ARN de clave de KMS existente o elija **Crear una AWS KMS key** para navegar hasta la consola de AWS KMS . Para obtener más información sobre cómo EventBridge Scheduler cifra los datos en reposo, consulte [Cifrado en reposo en la Guía del](https://docs.aws.amazon.com/scheduler/latest/UserGuide/encryption-rest.html) usuario de *Amazon EventBridge Scheduler*.
1. Para que EventBridge Scheduler cree un nuevo rol de ejecución para usted, elija **Crear un nuevo rol** para este programa. A continuación, ingrese un nombre para el **Nombre de rol**. Si eliges esta opción, EventBridge Scheduler adjunta al rol los permisos necesarios para el objetivo creado con la plantilla.
1. Elija **Siguiente**.
1. En la página de **Revisar y crear una programación**, revise los detalles de su programación. En cada sección, elija **Editar** para volver a ese paso y editar sus detalles.
1. Elija **Crear programación**.
Puede ver una lista de sus programaciones nuevas y existentes en la página **Programaciones**. En la columna **Estado**, verifique que su programación nueva se encuentre **Habilitada**.
## Recursos relacionados
Para obtener más información sobre EventBridge Scheduler, consulte lo siguiente:
+ [EventBridge Guía del usuario de Scheduler](https://docs.aws.amazon.com/scheduler/latest/UserGuide/what-is-scheduler.html)
+ [EventBridge Referencia de la API de Scheduler](https://docs.aws.amazon.com/scheduler/latest/APIReference/Welcome.html)
+ [EventBridge Precios de Scheduler](https://aws.amazon.com/eventbridge/pricing/#Scheduler)