As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Usando o Amazon SNS para mensagens application-to-application
O Amazon SNS simplifica as mensagens application-to-application (A2A) separando editores de assinantes, o que oferece suporte a microsserviços, sistemas distribuídos e aplicativos sem servidor. As mensagens são enviadas para tópicos do Amazon SNS, onde podem ser filtradas e entregues aos assinantes, como Lambda, Amazon SQS ou endpoints HTTP. Se a entrega falhar, as mensagens são armazenadas em uma fila de mensagens não entregues para análise ou reprocessamento adicionais.
![\[O Amazon SNS facilita o envio de application-to-application mensagens ao dissociar editores de assinantes usando tópicos. As mensagens de sistemas ou serviços são roteadas por meio de um tópico do Amazon SNS, onde podem ser filtradas e distribuídas para assinantes como Lambda, Amazon SQS ou sistemas de e-mail. Se a entrega falhar, as mensagens são armazenadas em uma fila de mensagens não entregues para análise ou reprocessamento posterior.\]](http://docs.aws.amazon.com/pt_br/sns/latest/dg/images/sns-a2a-overview.png)
# Fanout de fluxos de entrega do Firehose
Você pode inscrever [fluxos de entrega](https://docs.aws.amazon.com/firehose/latest/dev/what-is-this-service.html) em tópicos do Amazon SNS, o que permite enviar notificações para endpoints adicionais de armazenamento e analytics. As mensagens publicadas em um tópico do Amazon SNS são enviadas para o stream de entrega do Firehose assinante e entregues ao destino conforme configurado no Firehose. O proprietário de uma assinatura pode assinar até cinco fluxos de entrega do Firehose em um tópico do Amazon SNS. Cada stream de entrega do Firehose tem uma [cota padrão](https://docs.aws.amazon.com/firehose/latest/dev/limits.html) para solicitações e throughput por segundo. Esse limite poderia resultar em mais mensagens publicadas (tráfego de entrada) do que entregues (tráfego de saída). Se houver mais tráfego de entrada que de saída, sua assinatura pode acumular um grande backlog de menagens, causando alta latência na entrega de mensagens. Você pode solicitar um [aumento na cota](https://support.console.aws.amazon.com/support/home#/case/create?issueType=service-limit-increase) com base na taxa de publicação para evitar impactos adversos na workload.
Por meio dos streams de entrega do Firehose, você pode distribuir notificações do Amazon SNS para o Amazon Simple Storage Service (Amazon S3), Amazon Redshift, OpenSearch Amazon Service (Service) e para provedores de serviços terceirizados, como OpenSearch Datadog, New Relic, MongoDB e Splunk.
Por exemplo, você pode usar essa funcionalidade para armazenar permanentemente mensagens enviadas para um tópico em um bucket do Amazon S3 para fins de conformidade, arquivamento ou outros. Para fazer isso, crie um fluxo de entrega do Firehose com um destino de bucket do Amazon S3 e inscreva esse fluxo de entrega no tópico do Amazon SNS. Como outro exemplo, para realizar análises em mensagens enviadas para um tópico do Amazon SNS, crie um stream de entrega com um destino de índice OpenSearch de serviços. Depois, inscreva o fluxo de entrega do Firehose no tópico do Amazon SNS.
O Amazon SNS também oferece suporte a registro em log do status da entrega de mensagens para notificações enviadas para endpoints do Firehose. Para obter mais informações, consulte [Status de entrega de mensagens do Amazon SNS](sns-topic-attributes.md).
# Pré-requisitos para assinatura de fluxos de entrega do Firehose para tópicos do Amazon SNS
Para assinar um stream de entrega em um tópico do SNS, você Conta da AWS deve ter:
+ Um tópico do SNS padrão. Para obter mais informações, consulte [Criar um tópico do Amazon SNS](sns-create-topic.md).
+ Fluxo de entrega do Firehose. Para obter mais informações, consulte [Como criar um fluxo de entrega](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html) e [Conceder acesso aos recursos do Firehose à sua aplicação](https://docs.aws.amazon.com/firehose/latest/dev/controlling-access.html#access-to-firehose) no *Guia do desenvolvedor do Amazon Data Firehose*.
+ Uma função AWS Identity and Access Management (IAM) que confia no responsável pelo serviço principal do Amazon SNS e tem permissão para gravar no stream de entrega. Você deverá inserir o nome do recurso da Amazon (ARN) dessa função como `SubscriptionRoleARN` quando cria a assinatura. O Amazon SNS assume essa função, o que permite que o Amazon SNS coloque registros no fluxo de entrega do Firehose.
O exemplo de política seguinte mostra as permissões recomendadas:
------
#### [ 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 fornecer permissão total para usar o Firehose, você também pode usar a política AWS gerenciada. `AmazonKinesisFirehoseFullAccess` Ou, para fornecer permissões mais estritas para usar o Firehose, você pode criar sua própria política. No mínimo, a política deve fornecer permissão para executar a operação `PutRecord` em um fluxo de entrega específico.
Em todos os casos, você também deve editar o relacionamento de confiança para incluir o principal de serviço do Amazon SNS. Por exemplo:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "sns.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Para obter mais informações sobre a criação de funções, consulte [Como criar uma função para delegar permissões a um AWS serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) no *Guia do usuário do IAM*.
Depois de concluir esses requisitos, você pode [assinar o fluxo de entrega do tópico do SNS](firehose-endpoints-subscribe.md).
# Inscrever um fluxo de entrega do Firehose em um tópico do Amazon SNS
Para entregar notificações do Amazon SNS em [fluxos de entrega](sns-firehose-as-subscriber.md), primeiro certifique-se de ter abordado todos os [pré-requisitos](prereqs-kinesis-data-firehose.md). Para obter uma lista de endpoints compatíveis, consulte [endpoints e cotas](https://docs.aws.amazon.com/general/latest/gr/fh.html) no *Referência geral da Amazon Web Services*.
**Para inscrever um fluxo de entrega do Firehose em um tópico**
1. Faça login no [console do Amazon SNS](https://console.aws.amazon.com/sns/home).
1. No painel de navegação, escolha **Assinaturas**.
1. Na página **Assinaturas**, escolha **Criar assinatura**.
1. Na página **Criar assinatura**, na seção **Detalhes**, faça o seguinte:
1. Em **ARN do tópico**, escolha o nome do recurso da Amazon (ARN) de um tópico padrão.
1. Em **Protocolo**, escolha **Kinesis Data Firehose**.
1. Em **Endpoint**, escolha o ARN de um fluxo de entrega do Firehose que pode receber notificações do Amazon SNS.
1. Em **ARN da função de assinatura**, especifique o ARN da função do AWS Identity and Access Management (IAM) que você criou para gravar em fluxos de entrega do Firehose. Para obter mais informações, consulte [Pré-requisitos para assinatura de fluxos de entrega do Firehose para tópicos do Amazon SNS](prereqs-kinesis-data-firehose.md).
1. (Opcional) Para remover quaisquer metadados do Amazon SNS das mensagens publicadas, escolha **Habilitar a entrega de mensagens**. Para obter mais informações, consulte [Entrega de mensagens brutas do Amazon SNS](sns-large-payload-raw-message-delivery.md).
1. (Opcional) Para configurar uma política de filtros, expanda a seção **Subscription filter policy** (Política de filtro de assinatura). Para obter mais informações, consulte [Políticas de filtro de assinatura do Amazon SNS](sns-subscription-filter-policies.md).
1. (Opcional) Para configurar uma fila de mensagens não entregues para a assinatura, expanda a seção **Redrive policy (dead-letter queue)** (Política de redirecionamento (fila de mensagens não entregues)). Para obter mais informações, consulte [Filas de mensagens não entregues do Amazon SNS](sns-dead-letter-queues.md).
1. Selecione **Criar assinatura**.
O console cria a assinatura e abre a página **Details** (Detalhes) da assinatura.
# Gerenciamento de mensagens do Amazon SNS em vários destinos de fluxo de entrega
[os fluxos de entrega](sns-firehose-as-subscriber.md) permitem que você gerencie mensagens do Amazon SNS em vários destinos, permitindo a integração com Amazon S3, Amazon Service OpenSearch , Amazon Redshift e endpoints HTTP para armazenamento, indexação e análise. Ao configurar adequadamente a formatação e a entrega de mensagens, você pode armazenar notificações do Amazon SNS no Amazon S3 para processamento posterior, analisar dados estruturados de mensagens usando o Amazon Athena, indexar mensagens para pesquisa e visualização OpenSearch em tempo real e estruturar arquivos no Amazon Redshift para consultas avançadas.
# Armazenar e analisar mensagens do Amazon SNS em destinos do Amazon S3
Este tópico explica como fluxos de entrega publicam dados no Amazon Simple Storage Service (Amazon S3).
![\[A integração e o fluxo de trabalho dos serviços da Amazon para tratamento de mensagens. Mostra como um publicador envia mensagens para um tópico do Amazon SNS, que então as envia para várias filas do Amazon SQS e para um fluxo de entrega do Data Firehose. A partir daí, mensagens podem ser processadas por funções do Lambda ou armazenado de forma persistente em um bucket do Amazon S3.\]](http://docs.aws.amazon.com/pt_br/sns/latest/dg/images/firehose-architecture-s3.png)
**Topics**
+ [Formatação de notificações para armazenamento em destinos do Amazon S3](firehose-archived-message-format-S3.md)
+ [Analisar mensagens armazenadas no Amazon S3 usando o Athena](firehose-message-analysis-s3.md)
# Formatação de notificações do Amazon SNS para armazenamento em destinos do Amazon S3
O exemplo a seguir mostra uma notificação do Amazon SNS enviada para um bucket do Amazon Simple Storage Service (Amazon S3), usando recuos para legibilidade.
**nota**
Neste exemplo, a entrega de mensagens brutas está desativada para a mensagem publicada. Quando a entrega de mensagens brutas é desativada, o Amazon SNS adiciona metadados JSON à mensagem, incluindo estas propriedades:
`Type`
`MessageId`
`TopicArn`
`Subject`
`Timestamp`
`UnsubscribeURL`
`MessageAttributes`
Para obter mais informações sobre a entrega de mensagens brutas, consulte [Entrega de mensagens brutas do 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"
}
}
}
```
O exemplo a seguir mostra três mensagens do SNS enviadas por meio de um fluxo de entrega para o mesmo bucket do Amazon S3. O buffer é aplicado e as quebras de linha separam cada mensagem.
```
{"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"}
```
# Analisar mensagens do Amazon SNS armazenadas no Amazon S3 usando o Athena
Esta página explica como analisar mensagens do Amazon SNS enviadas por meio de fluxos de entrega para destinos do Amazon Simple Storage Service (Amazon S3).
**Para analisar mensagens do SNS enviadas por meio de fluxos de entrega do Firehose para destinos do Amazon S3**
1. Configure seus recursos do Amazon S3. Para obter instruções, consulte [Criação de buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) no *Manual do usuário do Amazon Simple Storage Service* e [Como trabalhar com buckets do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingBucket.html) no *Manual do usuário Amazon Simple Storage Service*.
1. Configure seu fluxo de entrega. Para obter instruções, consulte [Escolher o Amazon S3 para seu destino](https://docs.aws.amazon.com/firehose/latest/dev/create-destination.html#create-destination-s3) no *Guia do desenvolvedor do Amazon Data Firehose*.
1. Use o [Amazon Athena](https://console.aws.amazon.com/athena) para consultar os objetos do Amazon S3 com o SQL padrão. Para obter mais informações, consulte [Conceitos básicos](https://docs.aws.amazon.com/athena/latest/ug/getting-started.html) no *Manual do usuário do Amazon Athena*.
## Consulta de exemplo
Para esta consulta de exemplo, suponha o seguinte:
+ As mensagens são armazenadas na tabela `notifications` no esquema `default`.
+ A tabela `notifications` inclui uma coluna `timestamp` com um tipo de `string`.
A consulta a seguir retorna todas as mensagens do SNS recebidas no intervalo de datas 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';
```
# Integração de mensagens do Amazon SNS com destinos do Amazon Service OpenSearch
Esta seção explica como os fluxos de entrega publicam dados no Amazon OpenSearch Service (OpenSearch Service).
![\[Um publicador envia mensagens para um tópico do Amazon SNS, que então as distribui para várias filas do Amazon SQS. As mensagens dessas filas podem ser processadas por funções do Lambda ou enviadas por meio de um stream de entrega do Data Firehose para um OpenSearch Amazon Service, criando um índice de mensagens pesquisável. Essa configuração demonstra um cenário avançado de roteamento e processamento de mensagens usando os Serviços da AWS.\]](http://docs.aws.amazon.com/pt_br/sns/latest/dg/images/firehose-architecture-es.png)
**Topics**
+ [Formato de mensagens arquivadas](firehose-archived-message-format-elasticsearch.md)
+ [Analisar mensagens](firehose-message-analysis-elasticsearch.md)
# Armazenamento e formatação de notificações OpenSearch do Amazon SNS em índices de serviço
O exemplo a seguir demonstra uma notificação do Amazon SNS enviada para um índice do OpenSearch Amazon Service OpenSearch (Service) chamado. `my-index` Esse índice tem um campo de filtro de tempo no campo `Timestamp`. A notificação SNS é colocada na propriedade `_source` da carga útil.
**nota**
Neste exemplo, a entrega de mensagens brutas está desativada para a mensagem publicada. Quando a entrega de mensagens brutas é desativada, o Amazon SNS adiciona metadados JSON à mensagem, incluindo estas propriedades:
`Type`
`MessageId`
`TopicArn`
`Subject`
`Timestamp`
`UnsubscribeURL`
`MessageAttributes`
Para obter mais informações sobre a entrega de mensagens brutas, consulte [Entrega de mensagens brutas do 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
]
}
```
# Analisando mensagens do Amazon SNS para destinos de serviços OpenSearch
Este tópico explica como analisar mensagens do Amazon SNS enviadas por meio de fluxos de entrega para destinos do Amazon OpenSearch Service (OpenSearch Service).
**Para analisar mensagens de SNS enviadas por meio de fluxos OpenSearch de entrega do Firehose para destinos de serviço**
1. Configure seus recursos OpenSearch de serviço. Para obter instruções, consulte [Conceitos básicos do Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/es-gsg.html) no *Amazon OpenSearch Service Developer Guide*.
1. Configure seu fluxo de entrega. Para obter instruções, consulte [Escolha o OpenSearch serviço para seu destino](https://docs.aws.amazon.com/firehose/latest/dev/create-destination.html#create-destination-elasticsearch) no Guia do *desenvolvedor do Amazon Data Firehose*.
1. Execute uma consulta usando consultas OpenSearch de serviço e Kibana. Para obter mais informações, consulte [Etapa 3: Pesquisar documentos em um domínio de OpenSearch serviço](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/es-gsg-search.html) e [Kibana](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/es-kibana.html) no *Amazon OpenSearch Service Developer* Guide.
## Consulta de exemplo
O exemplo a seguir cria o índice `my-index` para todas as mensagens do SNS recebidas no intervalo de datas 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"
}
}
}
]
}
}
}
```
# Configuração da entrega e análise de mensagens do Amazon SNS nos destinos do Amazon Redshift
Este tópico explica como extrair notificações do Amazon SNS para um fluxo de entrega, que então publica dados no Amazon Redshift. Com essa configuração, é possível se conectar ao banco de dados do Amazon Redshift e usar uma ferramenta de consulta SQL para recuperar mensagens do Amazon SNS que atendam a determinados critérios.
![\[As mensagens publicadas por um remetente em um tópico do Amazon SNS são distribuídas para várias filas do Amazon SQS para processamento por funções do Lambda, além de enviadas por meio de um fluxo de entrega do Data Firehose para um cluster do Amazon Redshift para armazenamento e análise em um data warehouse de mensagens. Essa configuração demonstra uma arquitetura robusta de tratamento de mensagens e armazenamento de dados usando Serviços da AWS.\]](http://docs.aws.amazon.com/pt_br/sns/latest/dg/images/firehose-architecture-rs.png)
**Topics**
+ [Estruturação de arquivos de mensagens em tabelas do Amazon Redshift](firehose-archive-table-structure-redshift.md)
+ [Analisar mensagens armazenadas em destinos do Amazon Redshift](firehose-message-analysis-redshift.md)
# Estruturação de arquivos de mensagens do Amazon SNS em tabelas do Amazon Redshift
Para endpoints do Amazon Redshift, as mensagens do Amazon SNS são arquivadas como linhas em uma tabela. Veja a seguir um exemplo de como os dados são armazenados:
**nota**
Neste exemplo, a entrega de mensagens brutas está desativada para a mensagem publicada. Quando a entrega de mensagens brutas é desativada, o Amazon SNS adiciona metadados JSON à mensagem, incluindo estas propriedades:
`Type`
`MessageId`
`TopicArn`
`Subject`
`Message`
`Timestamp`
`UnsubscribeURL`
`MessageAttributes`
Para obter mais informações sobre a entrega de mensagens brutas, consulte [Entrega de mensagens brutas do Amazon SNS](sns-large-payload-raw-message-delivery.md).
Embora o Amazon SNS adicione propriedades à mensagem usando a capitalização mostrada nesta lista, os nomes de colunas nas tabelas do Amazon Redshift aparecem em todos os caracteres minúsculos. Para transformar os metadados JSON para o endpoint do Amazon Redshift, você pode usar o comando `COPY`. Para obter mais informações, consulte [Copy from JSON examples](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY_command_examples.html#r_COPY_command_examples-copy-from-json) (“Copiar de exemplos JSON”) e [Load from JSON data using the 'auto ignorecase' option](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY_command_examples.html#copy-from-json-examples-using-auto-ignorecase) (“Carregar de dados JSON usando a opção “auto ignorecase””) no *Guia do desenvolvedor de banco de dados do Amazon Redshift*.
| type | messageid | topicarn | subject | message | timestamp | unsubscribeurl | messageattributes |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Notificação | ea544832-a0d8-581d-9275-108243c46103 | arn:aws:sns:us-east-1:111111111111:my-topic | Exemplo do assunto | Exemplo de mensagem | 2020-12-02T00:33:32.272Z | https://sns.us-east-1.amazonaws.com/? Ação = Cancelar inscrição& =arn:aws:sns:us-east- SubscriptionArn 1:111111111111:my-topic:326deeeb-cbf4-45da-b92b-ca77a247813b | \$1\$1"my\$1attribute\$1":\$1\$1"Type\$1":\$1"String\$1",\$1"Value\$1":\$1"my\$1value\$1"\$1\$1 |
| Notificação | ab124832-a0d8-581d-9275-108243c46114 | arn:aws:sns:us-east-1:111111111111:my-topic | Exemplo de assunto 2 | Exemplo de mensagem 2 | 2020-12-03T00:18:11.129Z | https://sns.us-east-1.amazonaws.com/? Ação = Cancelar inscrição& =arn:aws:sns:us-east- SubscriptionArn 1:111111111111:my-topic:326deeeb-cbf4-45da-b92b-ca77a247813b | \$1\$1"my\$1attribute2\$1":\$1\$1"Type\$1":\$1"String\$1",\$1"Value\$1":\$1"my\$1value\$1"\$1\$1 |
| Notificação | ce644832-a0d8-581d-9275-108243c46125 | arn:aws:sns:us-east-1:111111111111:my-topic | Exemplo de assunto 3 | Exemplo de mensagem 3 | 2020-12-09T00:08:44.405Z | https://sns.us-east-1.amazonaws.com/? Ação = Cancelar inscrição& =arn:aws:sns:us-east- SubscriptionArn 1:111111111111:my-topic:326deeeb-cbf4-45da-b92b-ca77a247813b | \$1\$1"my\$1attribute3\$1":\$1\$1"Type\$1":\$1"String\$1",\$1"Value\$1":\$1"my\$1value\$1"\$1\$1 |
Para obter mais informações sobre divulgação de notificações de eventos para o Amazon Redshift, consulte [Configuração da entrega e análise de mensagens do Amazon SNS nos destinos do Amazon Redshift](firehose-redshift-destinations.md).
# Analisar mensagens do Amazon SNS armazenadas em destinos do Amazon Redshift
Este tópico descreve como analisar as mensagens do Amazon SNS enviadas por meio de fluxos de entrega para destinos do Amazon Redshift.
**Para analisar mensagens do SNS enviadas por meio de fluxos de entrega do Firehose para destinos do Amazon Redshift**
1. Configure seus recursos do Amazon Redshift. Para obter instruções, consulte [Conceitos básicos do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/getting-started.html) no *Guia de conceitos básicos do Amazon Redshift*.
1. Configure seu fluxo de entrega. Para obter instruções, consulte [Escolher o Amazon Redshift para seu destino](https://docs.aws.amazon.com/firehose/latest/dev/create-destination.html#create-destination-redshift) no *Guia do desenvolvedor do Amazon Data Firehose*.
1. Execute uma consulta. Para obter mais informações, confira [Consultar um banco de dados usando o editor de consultas](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor.html) no *Guia de gerenciamento do Amazon Redshift*.
## Consulta de exemplo
Para esta consulta de exemplo, suponha o seguinte:
+ As mensagens são armazenadas na tabela `notifications` no esquema `public` padrão.
+ A propriedade `Timestamp` da mensagem SNS é armazenada na coluna `timestamp` da tablea com um tipo de dados de coluna `timestamptz`.
**nota**
Para transformar os metadados JSON para o endpoint do Amazon Redshift, você pode usar o comando `COPY`. Para obter mais informações, consulte [Copy from JSON examples](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY_command_examples.html#r_COPY_command_examples-copy-from-json) (“Copiar de exemplos JSON”) e [Load from JSON data using the 'auto ignorecase' option](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY_command_examples.html#copy-from-json-examples-using-auto-ignorecase) (“Carregar de dados JSON usando a opção “auto ignorecase””) no *Guia do desenvolvedor de banco de dados do Amazon Redshift*.
A consulta a seguir retorna todas as mensagens do SNS recebidas no intervalo de datas especificado:
```
SELECT *
FROM public.notifications
WHERE timestamp > '2020-12-01T09:00:00.000Z' AND timestamp < '2020-12-02T09:00:00.000Z';
```
# Como configurar a entrega de mensagens do Amazon SNS para destinos HTTP usando
Este tópico explica como fluxos de entrega publicam dados em endpoints HTTP.
![\[Um publicador de um tópico do Amazon SNS, que então distribui as mensagens para várias filas do Amazon SQS. Essas mensagens são processadas por meio de funções do Lambda e também enviadas por meio de um fluxo de entrega do Data Firehose para um endpoint HTTP. Essa configuração mostra como trabalhar em conjunto com Serviços da AWS para facilitar o tratamento de mensagens e a integração com serviços HTTP externos.\]](http://docs.aws.amazon.com/pt_br/sns/latest/dg/images/firehose-architecture-http.png)
**Topics**
+ [Formato de notificação para entrega para destinos HTTP](firehose-delivered-message-format-http.md)
# Formato de notificação do Amazon SNS para entrega em destinos HTTP
Veja a seguir um exemplo de corpo de solicitação HTTP POST do Amazon SNS enviado por meio de um fluxo de entrega para um endpoint HTTP. A notificação do Amazon SNS é codificada como uma carga útil base64 na propriedade dos registros.
**nota**
Neste exemplo, a entrega de mensagens brutas está desativada para a mensagem publicada. Para obter mais informações sobre a entrega de mensagens brutas, consulte [Entrega de mensagens brutas do Amazon SNS](sns-large-payload-raw-message-delivery.md).
```
"body": {
"requestId": "ebc9e8b2-fce3-4aef-a8f1-71698bf8175f",
"timestamp": 1606255960435,
"records": [
{
"data": "eyJUeXBlIjoiTm90aWZpY2F0aW9uIiwiTWVzc2FnZUlkIjoiMjFkMmUzOGQtMmNhYi01ZjYxLTliYTItYmJiYWFhYzg0MGY2IiwiVG9waWNBcm4iOiJhcm46YXdzOnNuczp1cy1lYXN0LTE6MTExMTExMTExMTExOm15LXRvcGljIiwiTWVzc2FnZSI6IlNhbXBsZSBtZXNzYWdlIGZvciBBbWF6b24gS2luZXNpcyBEYXRhIEZpcmVob3NlIGVuZHBvaW50cyIsIlRpbWVzdGFtcCI6IjIwMjAtMTEtMjRUMjI6MDc6MzEuNjY3WiIsIlVuc3Vic2NyaWJlVVJMIjoiaHR0cHM6Ly9zbnMudXMtZWFzdC0xLmFtYXpvbmF3cy5jb20vP0FjdGlvbj1VbnN1YnNjcmliZSZTdWJzY3JpcHRpb25Bcm49YXJuOmF3czpzbnM6MTExMTExMTExMTExOm15LXRvcGljOjAxYjY5MTJjLTAwNzAtNGQ4Yi04YjEzLTU1NWJmYjc2ZTdkNCJ9"
}
]
}
```
# Arquivamento e análise de mensagens do Amazon SNS: um exemplo de uso para plataformas de emissão de passagens aéreas
Este tópico fornece um tutorial de um caso de uso comum para arquivar e analisar mensagens do Amazon SNS.
A configuração deste caso de uso é uma plataforma de emissão de bilhetes de avião que opera em um ambiente regulamentado.
1. A plataforma está sujeita a um framework de conformidade que exige que a empresa arquive todas as vendas de ingressos por pelo menos cinco anos.
1. Para atender à meta de conformidade de retenção de dados, a empresa inscreve um fluxo de entrega em um tópico existente do Amazon SNS.
1. O destino do fluxo de entrega é um bucket do Amazon Simple Storage Service (Amazon S3). Com essa configuração, todos os eventos publicados no tópico SNS são arquivados no bucket do Amazon S3.
O diagrama seguinte mostra a arquitetura dessa configuração:
![\[Uma AWS arquitetura para uma plataforma de emissão de passagens aéreas, ilustrando como os dados de vendas de passagens são processados e arquivados. Ele mostra o fluxo de dados de uma função do Lambda por meio de um tópico do Amazon SNS, que então distribui mensagens para as filas do Amazon SQS para processamento de pagamentos e detecção de fraudes, gerenciadas pelas respectivas funções do Lambda. Os dados também são transmitidos pelo Data Firehose para um bucket do Amazon S3 para arquivamento de longo prazo, apoiando a conformidade com os requisitos de retenção de dados. Essa configuração permite que a plataforma execute análises detalhadas dos dados de vendas de ingressos usando ferramentas como o Amazon Athena.\]](http://docs.aws.amazon.com/pt_br/sns/latest/dg/images/sns-archiving-use-case.png)
Para executar análises e obter insights sobre vendas de ingressos, a empresa executa consultas SQL usando o Amazon Athena. Por exemplo, a empresa pode consultar para saber mais sobre os destinos mais populares e os passageiros mais frequentes.
Para criar os AWS recursos para esse caso de uso, você pode usar o Console de gerenciamento da AWS ou um CloudFormation modelo.
**Topics**
+ [Configurando AWS recursos iniciais para arquivamento e análise de mensagens](firehose-example-initial-resources.md)
+ [Configurar um stream de entrega do Firehose para arquivamento de mensagens](firehose-example-create-delivery-stream.md)
+ [Inscrever o fluxo de entrega do tópico](firehose-example-subscribe-delivery-stream-to-topic.md)
+ [Testar e consultar uma configuração para um gerenciamento de dados eficaz](firehose-example-test-and-query.md)
+ [Automatizando o arquivamento de mensagens com um modelo CloudFormation](firehose-example-cfn.md)
# Configurando AWS recursos iniciais para arquivamento e análise de mensagens do Amazon SNS
Este tópico descreve como criar os seguintes recursos para o [exemplo de caso de uso de arquivamento e analytics de mensagens](firehose-example-use-case.md):
+ Um bucket do Amazon Simple Storage Service (Amazon S3)
+ Duas filas do Amazon Simple Queue Service (Amazon SQS)
+ Um tópico do Amazon SNS
+ Duas inscrições do Amazon SQS no tópico do Amazon SNS
**Para criar os recursos iniciais**
1. Criar o bucket do Amazon S3:
1. Abra o [console Amazon S3](https://console.aws.amazon.com/s3/home).
1. Selecione **Criar bucket**.
1. Em **Bucket name** (Nome do bucket), insira um nome globalmente exclusivo. Mantenha os outros campos como os padrões.
1. Selecione **Criar bucket**.
Para obter mais informações sobre buckets do Amazon S3, consulte [Criação de buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) no *Manual do usuário do Amazon Simple Storage Service* e [Como trabalhar com buckets do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingBucket.html) no *Manual do usuário do Amazon Simple Storage Service*.
1. Crie as duas filas do Amazon SQS:
1. Abra o [console do Amazon SQS](https://console.aws.amazon.com/sqs/home).
1. Selecione **Criar fila**.
1. Em **Tipo**, escolha **Padrão**.
1. Em **Nome**, digite **ticketPaymentQueue**.
1. Em **Access policy** (Política de acesso), para **Choose method** (Escolher método), escolha **Advanced** (Avançado).
1. Na caixa JSON policy (Política de JSON), cole a seguinte 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"
}
}
}
]
}
```
------
Nessa política de acesso, substitua o Conta da AWS número (*123456789012*) pelo seu e altere a AWS Região (*us-east-1*) de acordo.
1. Selecione **Criar fila**.
1. Repita essas etapas para criar uma segunda fila do SQS chamada **ticketFraudQueue**.
Para obter mais informações sobre a criação de filas do SQS, consulte [Creating an Amazon SQS queue (console)](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-configure-create-queue.html) no *Guia do desenvolvedor do Amazon Simple Queue Service*.
1. Criar o tópico do SNS:
1. Abra a [página Topics](https://console.aws.amazon.com/sns/home#/topics) (Tópicos) no console do Amazon SNS.
1. Escolha **Criar tópico**.
1. Em **Details** (Detalhes), para **Type** (Tipo), escolha **Standard** (Padrão).
1. Em **Nome**, digite **ticketTopic**.
1. Escolha **Criar tópico**.
Para obter mais informações sobre a criação de tópicos do SNS, consulte [Criar um tópico do Amazon SNS](sns-create-topic.md).
1. Inscreva as duas filas do SQS no tópico do SNS:
1. No [console do Amazon SNS](https://console.aws.amazon.com/sns/home#/topics), na página de detalhes do tópico **ticketTopic**, escolha **Create subscription** (Criar assinatura).
1. Em **Details** (Detalhes), para **Protocol** (Protocolo), escolha **Amazon SQS**.
1. Para **Endpoint**, escolha o Amazon Resource Name (ARN) da **ticketPaymentQueue**fila.
1. Selecione **Criar assinatura**.
1. Repita essas etapas para criar uma segunda assinatura usando o ARN da **ticketFraudQueue**fila.
Para obter mais informações sobre a inscrição em tópicos do SNS, consulte [Criação de uma assinatura em um tópico do Amazon SNS](sns-create-subscribe-endpoint-to-topic.md). Você também pode assinar filas SQS para tópicos do SNS no console do Amazon SQS. Para obter mais informações,consulte [Subscribing an Amazon SQS queue to an Amazon SNS topic (console)](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-configure-subscribe-queue-sns-topic.html) no *Guia do desenvolvedor do Amazon Simple Queue Service*.
Você criou os recursos iniciais para este exemplo de caso de uso. Para continuar, consulte [Configurar um fluxo de entrega do Amazon Data Firehose para arquivamento de mensagens do Amazon SNS](firehose-example-create-delivery-stream.md).
# Configurar um fluxo de entrega do Amazon Data Firehose para arquivamento de mensagens do Amazon SNS
Este tópico explica como criar o fluxo de entrega do Amazon Data Firehose para o [exemplo de caso de uso de arquivamento e analytics de mensagens](firehose-example-use-case.md).
**Como criar o fluxo de entrega do Amazon Data Firehose**
1. Abra o [console de serviços do Amazon Data Firehose](https://console.aws.amazon.com/kinesis/home).
1. Escolha **Firehose** e, depois, escolha **Criar fluxo de entrega**.
1. Na página **Novo fluxo de entrega**, em **Nome do fluxo de entrega**, insira **ticketUploadStream** e, depois, escolha **Próximo**.
1. Na página **Process records** (Processar registros), escolha **Next Step** (Próxima etapa).
1. Na página **Choose a Destination** (Selecionar um destino), faça o seguinte:
1. Para **Destination** (Destino), escolha **Amazon S3**.
1. Em **S3 destination** (Destino do S3), em **S3 bucket** (Bucket do S3), escolha o bucket do S3 que você [criou inicialmente](firehose-example-initial-resources.md).
1. Escolha **Próximo**.
1. Na página **Configure settings** (Definir configurações), para **S3 buffer conditions** (Condições de buffer do S3), faça o seguinte:
+ Em **Buffer size** (Tamanho do buffer), insira **1**.
+ Em **Buffer interval** (Intervalo buffer), insira **60**.
O uso desses valores para o buffer do Amazon S3 permite testar rapidamente a configuração. A primeira condição que é atendida aciona a entrega de dados para o bucket do S3.
1. Na página **Definir configurações**, em **Permissões**, escolha criar uma função AWS Identity and Access Management (IAM) com as permissões necessárias atribuídas automaticamente. Escolha **Próximo**.
1. Na página **Review** (Revisar), selecione **Create delivery stream** (Criar fluxo de entrega).
1. Na **página de streams de entrega do Amazon Data Firehose,** escolha o stream de entrega que você acabou de criar (). **ticketUploadStream** Na guia **Details** (Detalhes), anote o nome do recurso da Amazon (ARN) do fluxo para mais tarde.
Para obter mais informações sobre a criação de fluxos de entrega, consulte [Como criar um fluxo de entrega do Amazon Firehose Data](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html) no *Guia do desenvolvedor do Amazon Data Firehose*. Para obter mais informações sobre a criação de funções do IAM, consulte [Como criar uma função para delegar permissões a um AWS serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) no *Guia do usuário do IAM*.
Você criou o fluxo de entrega do Firehose com as permissões necessárias. Para continuar, consulte [Assinar o fluxo de entrega do Firehose no tópico do Amazon SNS](firehose-example-subscribe-delivery-stream-to-topic.md).
# Assinar o fluxo de entrega do Firehose no tópico do Amazon SNS
Este tópico explica como criar os seguintes recursos para o [exemplo de caso de uso de arquivamento e analytics de mensagens](firehose-example-use-case.md):
+ A função AWS Identity and Access Management (IAM) que permite que a assinatura do Amazon SNS coloque registros no fluxo de entrega.
+ A inscrição do fluxo de entrega do Firehose no tópico do Amazon SNS.
**Para criar o perfil do IAM para a assinatura do Amazon SNS**
1. Abra a página [Funções](https://console.aws.amazon.com/iam/home?#/roles) no console do IAM.
1. Selecione **Criar função**.
1. Em **Selecionar tipo de entidade confiável**, selecione **serviço da AWS **.
1. Para **Choose a use case** (Escolher um caso de uso), escolha **SNS**. Então, escolha **Próximo: permissões**.
1. Escolha **Próximo: tags**.
1. Selecione **Próximo: revisar**.
1. Na página **Revisar**, em **Nome da função**, insira **ticketUploadStreamSubscriptionRole**. Então, escolha **Criar perfil**.
1. Quando a função for criada, escolha seu nome (**ticketUploadStreamSubscriptionRole**).
1. Na página **Summary** (Resumo), escolha **Add inline policy** (Adicionar política inline).
1. Na página **Create policy** (Criar política), escolha a guia **JSON** e cole a seguinte política JSON na caixa:
------
#### [ 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"
}
]
}
```
------
Nessa política, substitua o Conta da AWS número (*123456789012*) pelo seu e altere a AWS Região (*us-east-1*) de acordo.
1. Selecione **Revisar política**.
1. Na página **Review policy (Revisar política)**, em **Name (Nome)**, insira **FirehoseSnsPolicy**. Selecione **Criar política**.
1. Na página **Summary** (Resumo) da função, anote o **Role ARN** (ARN da função) para mais tarde.
Para obter mais informações sobre a criação de funções do IAM, consulte [Como criar uma função para delegar permissões a um AWS serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) no *Guia do usuário do IAM*.
**Para inscrever o fluxo de entrega do Firehose no tópico do SNS**
1. Abra a [página Topics](https://console.aws.amazon.com/sns/home#/topics) (Tópicos) no console do Amazon SNS.
1. Na guia **Assinaturas**, escolha **Criar assinatura**.
1. Em **Detalhes**, em **Protocolo**, escolha ****.
1. Para **Endpoint**, insira o Amazon Resource Name (ARN) **ticketUploadStream**do stream de entrega que você criou anteriormente. Por exemplo, digite **arn:aws:firehose:us-east-1:123456789012:deliverystream/ticketUploadStream**.
1. **Em ARN da função de assinatura**, insira o ARN da função do **ticketUploadStreamSubscriptionRole**IAM que você criou anteriormente. Por exemplo, digite **arn:aws:iam::123456789012:role/ticketUploadStreamSubscriptionRole**.
1. Marque a caixa de seleção **Enable raw message delivery** (Habilitar a entrega de mensagens).
1. Selecione **Criar assinatura**.
Você criou a função do IAM e a assinatura do tópico do SNS. Para continuar, consulte [Testar e consultar uma configuração do Amazon SNS para um gerenciamento de dados eficaz](firehose-example-test-and-query.md).
# Testar e consultar uma configuração do Amazon SNS para um gerenciamento de dados eficaz
Este tópico explica como testar o [exemplo de caso de uso de arquivamento e analytics de mensagens](firehose-example-use-case.md) publicando uma mensagem no tópico do Amazon SNS. As instruções incluem uma consulta de exemplo que você pode executar e se adaptar às suas próprias necessidades.
**Para testar sua configuração**
1. Abra a [página Topics](https://console.aws.amazon.com/sns/home#/topics) (Tópicos) no console do Amazon SNS.
1. Selecione o tópico **ticketTopic**.
1. Selecione **Publish message (Publicar mensagem)**.
1. Na página **Publicar mensagem no tópico**, insira o seguinte para o corpo da mensagem. Adicione um caractere de nova linha no final da mensagem.
```
{"BookingDate":"2020-12-15","BookingTime":"2020-12-15 04:15:05","Destination":"Miami","FlyingFrom":"Vancouver","TicketNumber":"abcd1234"}
```
Mantenha todas as outras opções como seus valores padrão.
1. Selecione **Publish message (Publicar mensagem)**.
Para obter mais informações sobre publicação de mensagens, consulte [Publicar uma mensagem do Amazon SNS](sns-publishing.md).
1. Após o intervalo de fluxo de entrega de 60 segundos, abra a caixa de diálogo [Console do Amazon Simple Storage Service (Amazon S3)](https://console.aws.amazon.com/s3/home) e escolha o bucket do Amazon S3 que você [criou inicialmente](firehose-example-initial-resources.md).
A mensagem publicada é exibida no bucket.
**Para consultar os dados**
1. Abra o [console do Amazon Athena](https://console.aws.amazon.com/athena/home).
1. Execute uma consulta.
Por exemplo, suponha que a tabela `notifications` no esquema `default` contenha os seguintes dados:
```
{"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 localizar o destino superior, execute a seguinte consulta:
```
SELECT destination
FROM default.notifications
GROUP BY destination
ORDER BY count(*) desc
LIMIT 1;
```
Para consultar tickets vendidos durante um intervalo de data e hora específico, execute uma consulta como a seguinte:
```
SELECT *
FROM default.notifications
WHERE bookingtime
BETWEEN TIMESTAMP '2020-12-15 10:00:00'
AND TIMESTAMP '2020-12-15 12:00:00';
```
Você pode adaptar ambas as consultas de exemplo para suas próprias necessidades. Para obter mais informações sobre como usar o Athena para executar consultas, consulte [Conceitos básicos](https://docs.aws.amazon.com/athena/latest/ug/getting-started.html) no *Manual do usuário do Amazon Athena*.
## Liberar
Para evitar incorrer em cobranças de uso depois de terminar o teste, exclua os seguintes recursos criados durante o tutorial:
+ Assinaturas do Amazon SNS
+ Tópico do Amazon SNS
+ Filas do Amazon Simple Queue Service (Amazon SQS)
+ Bucket do Amazon S3.
+ fluxo de entrega
+ AWS Identity and Access Management Funções e políticas (IAM)
# Automatizando o arquivamento de mensagens do Amazon SNS com um modelo CloudFormation
Para automatizar a implantação do [caso de uso de exemplo de arquivamento e análise de mensagens](firehose-example-use-case.md) do Amazon SNS, você pode usar o seguinte modelo 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
```
# Fanout notificações do Amazon SNS para funções do Lambda para processamento automatizado
O Amazon SNS se integra ao AWS Lambda, permitindo que você acione funções Lambda em resposta às notificações do Amazon SNS. Quando uma mensagem é publicada em um tópico do SNS que tem uma função do Lambda inscrita, a função do Lambda é chamada com a carga útil da mensagem publicada. A função Lambda recebe a carga da mensagem como um parâmetro de entrada e pode manipular as informações na mensagem, publicá-la em outros tópicos do SNS ou enviá-la para outros serviços. AWS
O Amazon SNS também oferece suporte a atributos de status de entrega para notificações por mensagens enviadas a endpoints do Lambda. Para obter mais informações, consulte [Status de entrega de mensagens do Amazon SNS](sns-topic-attributes.md).
**Topics**
+ [Pré-requisitos](lambda-prereq.md)
+ [Inscrever uma função em um tópico](lambda-console.md)
# Pré-requisitos para integrar o Amazon SNS às funções do Lambda em todas as regiões
Para chamar funções do Lambda usando notificações do Amazon SNS, você precisa do seguinte:
+ Uma função do Lambda
+ Um tópico do Amazon SNS
Para obter informações sobre a criação de uma função do Lambda para usar com o Amazon SNS, consulte [Usar o Lambda](https://docs.aws.amazon.com/lambda/latest/dg/with-sns-example.html) com o Amazon SNS. Para obter informações sobre a criação de um tópico do Amazon SNS, consulte [Criar um tópico](https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html).
Quando você usa o Amazon SNS para entregar mensagens de regiões de adesão para regiões habilitadas por padrão, é necessário alterar a política criada na função do AWS Lambda substituindo o principal `sns.amazonaws.com` por `sns..amazonaws.com`.
Por exemplo, se você quiser inscrever uma função do Lambda no Leste dos EUA (Norte da Virgínia) em um tópico do SNS na Ásia-Pacífico (Hong Kong), altere o principal na política de função do AWS Lambda para `sns.ap-east-1.amazonaws.com`. As regiões de adesão incluem as regiões lançadas após 20 de março de 2019, que abrangem Ásia-Pacífico (Hong Kong), Oriente Médio (Bahrein), UE (Milão) e África (Cidade do Cabo). As regiões lançadas antes de 20 de março de 2019 são habilitadas por padrão.
**nota**
AWS não oferece suporte à entrega entre regiões para o Lambda de uma região que está habilitada por padrão para uma região opcional. Além disso, não há suporte para o encaminhamento de mensagens do SNS entre duas regiões de adesão.
# Assinar tópico do Amazon SNS de uma função do Lambda
Este tópico explica como inscrever uma função do Lambda em um tópico do Amazon SNS, permitindo que a função seja acionada por mensagens publicadas.
1. Faça login no [console do Amazon SNS](https://console.aws.amazon.com/sns/home).
1. No painel de navegação, escolha **Tópicos**.
1. Na página **Topics (Tópicos)**, escolha um tópico.
1. Na seção **Inscrições**, escolha **Criar inscrição**.
1. Na página **Criar assinatura**, na seção **Detalhes**, faça o seguinte:
1. Verifique o **ARN do tópico** escolhido.
1. Para **Protocolo**, escolha AWS Lambda.
1. Em **Endpoint,** insira o ARN de uma função.
1. Selecione **Criar assinatura**.
Quando uma mensagem é publicada em um tópico do SNS que tem uma função do Lambda inscrita, a função do Lambda é chamada com a carga útil da mensagem publicada. Para obter informações sobre como usar AWS Lambda com o Amazon SNS, incluindo um tutorial, consulte [Usando AWS Lambda com o Amazon SNS](https://docs.aws.amazon.com/lambda/latest/dg/with-sns.html).
# Fanout de notificações do Amazon SNS para filas do Amazon SQS para processamento assíncrono
O [Amazon SNS](https://aws.amazon.com/sns/) funciona em conjunto com o Amazon Simple Queue Service (Amazon SQS). Esses serviços oferecem benefícios diferentes para os desenvolvedores. O Amazon SNS permite que aplicativos enviem mensagens urgentes para vários inscritos através de um mecanismo de “push”, eliminando a necessidade de verificar ou “pesquisar” periodicamente atualizações. O Amazon SQS é um serviço de fila de mensagens usado por aplicativos distribuídos para trocar mensagens por meio de um modelo de pesquisa e pode ser usado para decompor os componentes de envio e recebimento — sem a necessidade de cada componente estar disponível simultaneamente. Ao usar o Amazon SNS e o Amazon SQS em conjunto, as mensagens podem ser entregues a aplicativos que exigem uma notificação imediata de um evento e também podem continuar em uma fila do Amazon SQS para que outros aplicativos as processem posteriormente.
Ao inscrever uma fila do Amazon SQS em um tópico do Amazon SNS, é possível publicar uma mensagem no tópico e o Amazon SNS envia uma mensagem do Amazon SQS para a fila inscrita. A mensagem do Amazon SQS contém o assunto e a mensagem publicados no tópico juntamente com os metadados sobre a mensagem em um documento JSON. A mensagem do Amazon SQS será semelhante ao seguinte documento JSON.
```
{
"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"
}
```
# Inscrever uma fila do Amazon SQS em um tópico do Amazon SNS
Para permitir que um tópico do Amazon SNS envie mensagens a uma fila do Amazon SQS, escolha um destes procedimentos:
+ Use o [console do Amazon SQS](https://console.aws.amazon.com/sqs/), o que simplifica o processo. Para obter mais informações,consulte [Subscribing an Amazon SQS queue to an Amazon SNS topic](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-configure-subscribe-queue-sns-topic.html) no *Guia do desenvolvedor do Amazon Simple Queue Service*.
+ Use as seguintes etapas:
1. [Obtenha o Nome de recurso da Amazon (ARN) da fila para a qual deseja enviar mensagens e o tópico no qual você deseja inscrever a fila.](#SendMessageToSQS.arn)
1. [Conceda a permissão `sqs:SendMessage` ao tópico do Amazon SNS para que ele possa enviar mensagens para a fila.](#SendMessageToSQS.sqs.permissions)
1. [Inscreva a fila no tópico do Amazon SNS.](#SendMessageToSQS.subscribe)
1. [Forneça aos usuários do IAM ou às Contas da AWS as permissões apropriadas para publicar no tópico do Amazon SNS e ler mensagens da fila do Amazon SQS.](#SendMessageToSQS.iam.permissions)
1. [Faça um teste publicando uma mensagem no tópico e lendo a mensagem a partir da fila.](#SendMessageToSQS.test)
Para saber mais sobre como configurar um tópico para enviar mensagens a uma fila que está em uma conta da AWS diferente, consulte [Enviar mensagens do Amazon SNS para uma fila do SQS em uma conta diferente](sns-send-message-to-sqs-cross-account.md).
Para ver um CloudFormation modelo que cria um tópico que envia mensagens para duas filas, consulte[Automatize as mensagens do Amazon SNS para o Amazon SQS com AWS CloudFormation](SendMessageToSQS.cloudformation.md).
## Etapa 1: Obter o ARN da fila e do tópico
Ao inscrever uma fila em seu tópico, você precisará de uma cópia do ARN da fila. Da mesma forma, ao conceder permissão para o tópico enviar mensagens para a fila, você precisará de uma cópia do ARN do tópico.
Para obter o ARN da fila, você pode usar o console do Amazon SQS ou a ação da API. [GetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/Query_QueryGetQueueAttributes.html)
**Para obter o ARN da fila do console do Amazon SQS**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon SQS em. [https://console.aws.amazon.com/sqs/](https://console.aws.amazon.com/sqs/)
1. Marque a caixa de seleção da fila cujo ARN você deseja obter.
1. Na seção **Details** (Detalhes), copie o valor do ARN e use-o para se inscrever no tópico do Amazon SSN.
Para obter o ARN do tópico, use o console do Amazon SNS, o comando `[sns-get-topic-attributes](https://docs.aws.amazon.com/cli/latest/reference/sns/get-topic-attributes.html)` ou a ação da API `[GetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/Query_QueryGetQueueAttributes.html)`.
**Para obter o ARN do tópico do console do Amazon SNS**
1. Faça login no [console do Amazon SNS](https://console.aws.amazon.com/sns/home).
1. No painel de navegação, selecione o tópico do qual você deseja obter o ARN.
1. Na seção **Details** (Detalhes), copie o valor de **ARN** a fim de usá-lo para conceder permissão ao tópico do Amazon SNS para enviar mensagens à fila.
## Etapa 2: Conceder permissão ao tópico do Amazon SNS para enviar mensagens à fila do Amazon SQS
Para que um tópico do Amazon SNS possa de enviar mensagens a uma fila, você deve definir uma política na fila que permita que o tópico do Amazon SNS execute a ação `sqs:SendMessage`.
Antes de inscrever uma fila em um tópico, você precisa de um tópico e uma fila. Se ainda não criou um tópico ou uma fila, crie-os agora. Para obter mais informações, consulte [Criar um tópico](sns-create-topic.md) e [Criar uma fila](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/step-create-queue.html) no *Guia do desenvolvedor do Amazon Simple Queue Service*.
Para definir uma política em uma fila, você pode usar o console do Amazon SQS ou [SetQueueAttributes](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/Query_QuerySetQueueAttributes.html)a ação da API. Antes de começar, verifique se você tem o ARN do tópico que você deseja permitir que envie mensagens para a fila. Se você estiver assinando uma fila para vários tópicos, sua política deverá conter um elemento `Statement` para cada tópico.
**Para definir uma SendMessage política em uma fila usando o console do Amazon SQS**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon SQS em. [https://console.aws.amazon.com/sqs/](https://console.aws.amazon.com/sqs/)
1. Marque a caixa da fila cuja política você deseja definir, escolha a guia **Access policy** (Política de acesso) e escolha **Edit** (Editar).
1. No**Política de acesso**, defina quem pode acessar sua fila.
+ Adicione uma condição que permite a ação para o tópico.
+ Defina `Principal` como o serviço do Amazon SNS, conforme exibido no exemplo abaixo.
+ Use as chaves de condição globais [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) ou [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 se proteger contra o cenário [confused deputy](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html). Para usar essas chaves de condição, defina o valor como o ARN de seu tópico. Se sua fila estiver inscrita em vários tópicos, use `aws:SourceAccount` em seu lugar.
Por exemplo, a política a seguir MyTopic permite enviar mensagens para 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"
}
}
}
]
}
```
## Etapa 3: Inscrever a fila no tópico do Amazon SNS
Para enviar mensagens para uma fila por meio de um tópico, você deve inscrever a fila no tópico do Amazon SNS. Você especifica a fila por meio de sua ARN. Para se inscrever em um tópico, use o console do Amazon SNS, o comando `[sns-subscribe](https://docs.aws.amazon.com/cli/latest/reference/sns/subscribe.html)` da CLI ou a ação da API `[Subscribe](https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html)`. Antes de começar, verifique se você tem o ARN para a fila que deseja inscrever.
1. Faça login no [console do Amazon SNS](https://console.aws.amazon.com/sns/home).
1. No painel de navegação, escolha **Tópicos**.
1. Na página **Topics (Tópicos)**, escolha um tópico.
1. Na ***MyTopic*** página, na página **Assinaturas**, escolha **Criar** assinatura.
1. Na página **Criar assinatura**, na seção **Detalhes**, faça o seguinte:
1. Verifique o **ARN do tópico**.
1. Em **Protocol** (Protocolo), escolha **Amazon SQS**.
1. Em **Endpoint**, insira o ARN de uma fila do Amazon SQS.
1. Escolha **Create Subscription** (Criar assinatura).
Quando a inscrição for confirmada, o **ID da inscrição** da nova inscrição exibirá o ID da inscrição. Se o proprietário da fila criar a inscrição, ela será automaticamente confirmada e deverá ser ativada quase que imediatamente.
Geralmente, você inscreverá sua própria fila em seu próprio tópico em sua própria conta. No entanto, você também pode inscrever uma fila de uma conta diferente em seu tópico. Se o usuário que criar a inscrição não for o proprietário da fila (por exemplo, se um usuário da conta A inscreve uma fila da conta B para um tópico na conta A), a inscrição deverá ser confirmada. Para obter mais informações sobre como inscrever uma fila de uma conta diferente e confirmar a inscrição, consulte [Enviar mensagens do Amazon SNS para uma fila do SQS em uma conta diferente](sns-send-message-to-sqs-cross-account.md).
## Etapa 4: Conceder aos usuários permissões para o tópico apropriado e as ações da fila
Você deve usar AWS Identity and Access Management (IAM) para permitir que somente usuários apropriados publiquem no tópico do Amazon SNS e nas read/delete mensagens da fila do Amazon SQS. Para obter mais informações sobre como controlar ações em tópicos e filas para usuários do IAM, consulte[Usar políticas baseadas em identidade com o Amazon SNS](sns-using-identity-based-policies.md), e[Identity and Access Management no Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/UsingIAM.html)no Guia do desenvolvedor do Amazon Simple Queue Service.
Há duas maneiras de controlar o acesso a um tópico ou uma fila:
+ [Adicione uma política para um usuário ou grupo do IAM](#SendMessageToSQS.iam.permissions.user). A maneira mais simples de conceder aos usuários permissões para tópicos ou filas é criar um grupo e adicionar a política adequada e os usuários ao grupo. É muito mais fácil adicionar e remover usuários de um grupo do que controlar as políticas definidas para usuários individualmente.
+ [Adicione uma política ao tópico ou à fila](#SendMessageToSQS.iam.permissions.resource). Se você quiser conceder permissões para um tópico ou fila para outra AWS conta, a única maneira de fazer isso é adicionando uma política que tenha como principal a pessoa à qual Conta da AWS você deseja conceder permissões.
Você deve usar o primeiro método para a maioria dos casos (aplicar políticas a grupos e gerenciar permissões para usuários adicionando ou removendo os usuários adequados aos grupos). Se você precisa conceder permissões para um usuário em outra conta, use o segundo método.
### Adicionar uma política a um usuário ou grupo do IAM
Se você adicionasse a política a seguir a um usuário ou grupo do IAM, concederia permissão a esse usuário ou membros desse grupo para realizar a `sns:Publish` ação no tópico MyTopic.
```
{
"Statement": [
{
"Effect": "Allow",
"Action": "sns:Publish",
"Resource": "arn:aws:sns:us-east-2:123456789012:MyTopic"
}
]
}
```
Se você adicionasse a política a seguir a um usuário ou grupo do IAM, concederia a esse usuário ou membros desse grupo permissão para realizar as `sqs:DeleteMessage` ações `sqs:ReceiveMessage` e nas filas MyQueue 1 e MyQueue 2.
```
{
"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"
]
}
]
}
```
### Adição de uma política a um tópico ou uma fila
Os exemplos de políticas a seguir mostram como conceder a outra conta permissões para um tópico e uma fila.
**nota**
Ao conceder outro Conta da AWS acesso a um recurso em sua conta, você também concede aos usuários do IAM que têm acesso em nível de administrador (acesso curinga) permissões a esse recurso. Todos os outros usuários do IAM na outra conta têm automaticamente o acesso negado a seus recursos. Se desejar conceder a usuários específicos do IAM dessa Conta da AWS acesso a seu recurso, a conta ou um usuário do IAM com acesso de nível de administrador deverá delegar permissões para o recurso para esses usuários do IAM. Para obter mais informações sobre a delegação entre contas, consulte [Habilitar acesso entre contas](https://docs.aws.amazon.com/IAM/latest/UserGuide/Delegation.html) no *Guia de uso do IAM*.
Se você adicionasse a política a seguir a um tópico MyTopic na conta 123456789012, concederia permissão à conta 111122223333 para realizar a ação nesse tópico. `sns:Publish`
```
{
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "111122223333"
},
"Action": "sns:Publish",
"Resource": "arn:aws:sns:us-east-2:123456789012:MyTopic"
}
]
}
```
Se você adicionasse a política a seguir a uma fila MyQueue na conta 123456789012, concederia permissão à conta 111122223333 para realizar as ações e nessa fila. `sqs:ReceiveMessage` `sqs:DeleteMessage`
```
{
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "111122223333"
},
"Action": [
"sqs:DeleteMessage",
"sqs:ReceiveMessage"
],
"Resource": [
"arn:aws:sqs:us-east-2:123456789012:MyQueue"
]
}
]
}
```
## Etapa 5: Testar as assinaturas de fila do tópico
Você pode testar as inscrições de fila de um tópico publicando nele e visualizando a mensagem que ele envia para a fila.
**Para publicar um tópico usando o console do Amazon SNS**
1. Usando as credenciais do usuário Conta da AWS ou do IAM com permissão para publicar no tópico, faça login no Console de gerenciamento da AWS e abra o console do Amazon SNS em. [https://console.aws.amazon.com/sns/](https://console.aws.amazon.com/sns/home)
1. No painel de navegação, escolha o tópico e selecione **Publicar no tópico**.
1. Na caixa **Assunto**, digite um assunto (por exemplo, **Testing publish to queue**), na caixa **Mensagem**, digite algum texto (por exemplo, **Hello world\$1**) e escolha **Publicar mensagem**. Será exibida a seguinte mensagem: Your message has been successfully published.
**Para visualizar a mensagem do tópico usando o console do Amazon SQS**
1. Usando as credenciais do usuário Conta da AWS ou do IAM com permissão para visualizar mensagens na fila, faça login no Console de gerenciamento da AWS e abra o console do Amazon SQS em. [https://console.aws.amazon.com/sqs/](https://console.aws.amazon.com/sqs/)
1. Escolha uma **fila** que esteja inscrita no tópico.
1. Escolha **Send and receive messages** (Enviar e receber mensagens), depois escolha **Poll for messages** (Pesquisar mensagens). Uma mensagem com um tipo de **Notificação** é exibida.
1. Na coluna **Corpo**, escolha **Mais detalhes**. A caixa **Detalhes da mensagem** inclui um documento JSON que contém o assunto e a mensagem publicada no tópico. A mensagem é semelhante ao seguinte documento JSON.
```
{
"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. Escolha **Fechar**. Você publicou com sucesso em um tópico que envia mensagens de notificação para uma fila.
# Automatize as mensagens do Amazon SNS para o Amazon SQS com AWS CloudFormation
CloudFormation permite que você use um arquivo de modelo para criar e configurar uma coleção de AWS recursos juntos como uma única unidade. Esta seção tem um modelo de exemplo que facilita a implantação de tópicos que publicam em filas. Os modelos processam as etapas de configuração para você, criando duas filas, criando um tópico com inscrições das filas, adicionando uma política às filas para que o tópico possa enviar mensagens para as filas e criando usuários e grupos do IAM para controlar o acesso a esses recursos.
Para obter mais informações sobre como implantar AWS recursos usando um CloudFormation modelo, consulte [Introdução](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/GettingStarted.Walkthrough.html) no *Guia do CloudFormation usuário*.
## Usando um CloudFormation modelo para configurar tópicos e filas em um Conta da AWS
O modelo de exemplo cria um tópico do Amazon SNS que pode enviar mensagens para duas filas do Amazon SQS com as permissões adequadas para que os membros de um grupo do IAM publiquem no tópico e os membros do outro leiam mensagens das filas. O modelo também cria usuários do IAM que são adicionados a cada grupo.
Copie o conteúdo do modelo em um arquivo. Você também pode baixar o modelo na [página AWS CloudFormation Modelos](https://aws.amazon.com/cloudformation/aws-cloudformation-templates/). Na página de modelos, escolha **Procurar modelos de amostra por AWS serviço** e, em seguida, escolha **Amazon Simple Queue Service**.
SNSTopic O My está configurado para publicar em dois endpoints inscritos, que são duas filas do Amazon SQS MyQueue (1 e 2). MyQueue MyPublishTopicGroup é um grupo do IAM cujos membros têm permissão para publicar no My SNSTopic usando a ação da API [Publish](https://docs.aws.amazon.com/sns/latest/api/API_Publish.html) ou o comando [sns-publish](https://docs.aws.amazon.com/cli/latest/reference/sns/publish.html). O modelo cria os usuários do IAM MyPublishUser MyQueueUser e fornece a eles perfis de login e chaves de acesso. O usuário que cria uma pilha com esse modelo especifica as senhas para os perfis de login como parâmetros de entrada. O modelo cria chaves de acesso para os dois usuários do IAM com MyPublishUserKey MyQueueUserKey e. AddUserToMyPublishTopicGroup adiciona MyPublishUser ao MyPublishTopicGroup para que o usuário tenha as permissões atribuídas ao grupo.
My RDMessage QueueGroup é um grupo do IAM cujos membros têm permissão para ler e excluir mensagens das duas filas do Amazon SQS usando as ações [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/Query_QueryReceiveMessage.html)e [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/Query_QueryDeleteMessage.html)da API. AddUserToMyQueueGroup adiciona MyQueueUser ao Meu RDMessage QueueGroup para que o usuário tenha as permissões atribuídas ao grupo. MyQueuePolicy atribui permissão para SNSTopic que My publique suas notificações nas duas filas.
A lista a seguir mostra o conteúdo do CloudFormation modelo.
```
{
"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"]
}
]
]
}
}
}
}
```
# Fanout de notificações do Amazon SNS para endpoints HTTPS
Use o Amazon SNS para enviar mensagens de notificação a um ou mais endpoints HTTP ou HTTPS. Quando você inscrever um endpoint em um tópico, será possível publicar uma notificação no tópico, e o Amazon SNS envia uma solicitação HTTP POST entregando o conteúdo da notificação para o endpoint inscrito. Ao inscrever o endpoint, você seleciona se o Amazon SNS usa HTTP ou HTTPS para enviar a solicitação POST ao endpoint. Se você usar HTTPS, poderá aproveitar o suporte do Amazon SNS para o seguinte:
+ **Server Name Indication (SNI)**: permite que o Amazon SNS ofereça suporte a endpoints HTTPS que exigem SNI, como um servidor que exige vários certificados para hospedar vários domínios. Para obter mais informações sobre SNI, consulte [Server Name Indication](http://en.wikipedia.org/wiki/Server_Name_Indication).
+ **Autenticação de acesso Basic e Digest**: permite que você especifique um nome de usuário e uma senha no URL HTTPS para a solicitação HTTP POST, como `https://user:password@domain.com` ou `https://user@domain.com`. O nome do usuário e a senha são criptografados pela conexão SSL estabelecida ao usar HTTPS. Somente o nome de domínio é enviado em texto sem formatação. Para obter mais informações sobre autenticação e controle de acesso Basic e Digest, consulte a [RFC-2617](http://www.rfc-editor.org/info/rfc2617).
**Importante**
No momento, o Amazon SNS não é compatível com endpoints HTTP(S) privados.
HTTPS só podem ser URLs recuperados da ação de API do Amazon `GetSubscriptionAttributes` SNS, para entidades às quais você concedeu acesso à API.
**nota**
O serviço de cliente deve poder oferecer suporte à resposta de cabeçalho `HTTP/1.1 401 Unauthorized`
A solicitação contém o assunto e a mensagem que foram publicados no tópico juntamente com os metadados sobre a notificação em um documento JSON. A solicitação será semelhante à seguinte solicitação POST HTTP. Para obter detalhes sobre o cabeçalho HTTP e o formato JSON do corpo de solicitação, consulte [Cabeçalhos HTTP/HTTPS](http-header.md) e [Formato JSON de notificação HTTP/HTTPS](http-notification-json.md).
**nota**
O Amazon SNS considera todos os erros 5XX e 429 (muitas solicitações enviadas) como passíveis de repetição. Esses erros estão sujeitos à política de entrega. Todos os outros erros são considerados falhas permanentes e não serão feitas novas tentativas.
```
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"
}
```
# Inscrever um endpoint HTTPS em um tópico do Amazon SNS
Este tópico explica como inscrever HTTP/S endpoints em tópicos do Amazon SNS.
**Topics**
+ [Etapa 1: Verificar se o endpoint está pronto para processar mensagens do Amazon SNS](SendMessageToHttp.prepare.md)
+ [Etapa 2: Inscrever o HTTP/HTTPS endpoint no tópico do Amazon SNS](SendMessageToHttp.subscribe.md)
+ [Etapa 3: confirmar sua assinatura do Amazon SNS](SendMessageToHttp.confirm.md)
+ [Etapa 4: opcional - definir a política de entrega para a assinatura do Amazon SNS.](SendMessageToHttp.retry.md)
+ [Etapa 5: opcional - conceder aos usuários permissões para publicar no tópico do Amazon SNS](SendMessageToHttp.iam.permissions.md)
+ [Etapa 6: Enviar mensagens do Amazon SNS para o endpoint HTTP/HTTPS](SendMessageToHttp.publish.md)
# Etapa 1: Verificar se o endpoint está pronto para processar mensagens do Amazon SNS
Antes de inscrever um endpoint HTTP ou HTTPS em um tópico, você deve garantir que ele tem a capacidade de lidar com as solicitações HTTP POST que o Amazon SNS usa para enviar a confirmação de inscrição e as mensagens de notificação. Geralmente, isso significa a criação e a implantação de uma aplicação web (por exemplo, um servlet Java se o host do endpoint está executando Linux com Apache e Tomcat) que processa solicitações HTTP do Amazon SNS. Quando você inscreve um endpoint HTTP, o Amazon SNS envia uma solicitação de confirmação de inscrição. Seu endpoint deve estar preparado para receber e processar essa solicitação quando você criar a assinatura, porque o Amazon SNS envia essa solicitação nesse momento. O Amazon SNS não enviará notificações ao endpoint até que a assinatura seja confirmada. Assim que você confirmar a inscrição, o Amazon SNS enviará notificações para o endpoint quando uma ação de publicação for realizada no tópico inscrito.
**Para configurar o endpoint para processar as mensagens de notificação e de confirmação de inscrição**
1. Seu código deve conter os cabeçalhos HTTP de solicitações HTTP POST que o Amazon SNS envia para seu endpoint. O código deve procurar o campo do cabeçalho `x-amz-sns-message-type`, que mostra o tipo de mensagem que o Amazon SNS enviou a você. Ao visualizar o cabeçalho, você pode determinar o tipo da mensagem sem a necessidade de analisar o corpo da solicitação HTTP. Há dois tipos com os quais você precisa lidar: `SubscriptionConfirmation` e `Notification`. A mensagem `UnsubscribeConfirmation` é usada somente quando a assinatura é excluída do tópico.
Para obter detalhes sobre o cabeçalho HTTP, consulte [Cabeçalhos HTTP/HTTPS](http-header.md). A seguinte solicitação HTTP POST é um exemplo de uma mensagem de confirmação de inscrição.
```
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. Seu código deve analisar o documento JSON no corpo da solicitação HTTP POST e no tipo de conteúdo text/plain para ler os pares de nome e valor que compõem a mensagem do Amazon SNS. Use um analisador JSON que faça a conversão da representação em sequência de escape dos caracteres de controle de volta para seus valores de caracteres ASCII (por exemplo, converter \$1n para um caractere de nova linha). Você pode usar um analisador JSON existente, como o [ProcessadorJackson JSON](https://github.com/FasterXML/jackson) ou escrever seu próprio analisador. Para enviar o texto nos campos de assunto e mensagem em formato JSON válido, o Amazon SNS deve converter alguns caracteres de controle para representações em sequência de escape para inclusão no documento JSON. Ao receber o documento JSON no corpo da solicitação POST enviada para o endpoint, você deve converter os caracteres em sequência de escape de volta para seus valores de caractere originais se quiser uma representação exata do assunto e das mensagens originais publicadas no tópico. Isso é essencial se você deseja verificar a assinatura de uma notificação, pois a assinatura usa a mensagem e o assunto em seus formulários originais como parte da string para assinar.
1. Seu código deve verificar a autenticidade de uma mensagem de notificação, confirmação de inscrição ou confirmação de cancelamento de inscrição enviada pelo Amazon SNS. o usar informações contidas na mensagem do Amazon SNS, o endpoint pode recriar a assinatura para que você possa verificar o conteúdo da mensagem comparando sua assinatura com a assinatura enviada pelo Amazon SNS junto com a mensagem. Para obter mais informações sobre como verificar a assinatura de uma mensagem, consulte [Verificação das assinaturas de mensagens do Amazon SNS](sns-verify-signature-of-message.md).
1. Com base no tipo especificado pelo campo de cabeçalho `x-amz-sns-message-type`, seu código deve ler o documento JSON contido no corpo da solicitação HTTP e processar a mensagem. A seguir, são apresentadas as diretrizes para lidar com os dois tipos principais de mensagens:
**SubscriptionConfirmation**
Leia o valor para `SubscribeURL` e acesse o URL. Para confirmar a assinatura e começar a receber notificações no endpoint, é necessário visitar o URL`SubscribeURL` (por exemplo, enviando uma solicitação HTTP GET para o URL). Consulte o exemplo de solicitação HTTP na etapa anterior para ver qual a aparência de `SubscribeURL`. Para obter mais informações sobre o formato da mensagem `SubscriptionConfirmation`, consulte [Formato JSON de confirmação de assinatura HTTP/HTTPS](http-subscription-confirmation-json.md). Ao acessar o URL, você receberá de volta uma resposta que se parece com o seguinte documento XML. O documento retorna o ARN da inscrição para o endpoint no elemento `ConfirmSubscriptionResult`.
```
arn:aws:sns:us-west-2:123456789012:MyTopic:2bcfbf39-05c3-41de-beaa-fcfcc21c8f55
075ecce8-8dac-11e1-bf80-f781d96e9307
```
Como alternativa à visita ao`SubscribeURL`, você pode confirmar a assinatura usando a [ConfirmSubscription](https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html)ação com o valor correspondente `Token` definido na `SubscriptionConfirmation` mensagem. Se você deseja permitir que somente o proprietário do tópico e o proprietário da inscrição cancelem o recebimento para o endpoint, chame a ação `ConfirmSubscription` com uma assinatura AWS .
**Notificação**
Leia os valores de `Subject` e `Message` para obter as informações da notificação que foi publicada no tópico.
Para obter mais detalhes sobre o formato da mensagem `Notification`, consulte [Cabeçalhos HTTP/HTTPS](http-header.md). A seguinte solicitação HTTP POST é um exemplo de uma mensagem de notificação enviada para o endpoint 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. Certifique-se de que o endpoint responde à mensagem de HTTP POST do Amazon SNS com o código de status apropriado. A conexão atingirá o tempo limite em aproximadamente 15 segundos. Se o endpoint não responder antes da conexão atingir o tempo limite ou retornar um código de status fora do intervalo de 200–4*xx*, o Amazon SNS considerará que houve falha na entrega da mensagem.
1. Certifique-se de que o seu código pode lidar com novas tentativas de entrega de mensagens do Amazon SNS. Se o Amazon SNS não receber uma resposta bem-sucedida do endpoint, ele tenta entregar a mensagem novamente. Isso se aplica a todas as mensagens, incluindo a mensagem de confirmação de inscrição. Por padrão, se a entrega inicial da mensagem falhar, o Amazon SNS faz até três novas tentativas com uma espera de 20 segundos entre as tentativas malsucedidas.
**nota**
A solicitação da mensagem atinge o tempo limite de aproximadamente 15 segundos. Isso significa que se a falha na entrega da mensagem for causada por exceder o tempo limite, o Amazon SNS tentará outra vez por aproximadamente 35 segundos após a última tentativa de entrega. Você pode definir uma política de entrega diferente para o endpoint.
O Amazon SNS usa o campo de cabeçalho `x-amz-sns-message-id` para identificar de forma exclusiva cada mensagem publicada em um tópico do Amazon SNS. Ao comparar as IDs mensagens que você processou com as mensagens recebidas, você pode determinar se a mensagem é uma tentativa de nova tentativa.
1. Se estiver inscrevendo um endpoint HTTPS, verifique se o endpoint tem um certificado do servidor de uma autoridade de certificado (CA) confiável. O Amazon SNS só envia mensagens a endpoints HTTPS que têm um certificado de servidor assinado por uma CA confiável para o Amazon SNS.
1. Implante o código que você criou para receber mensagens do Amazon SNS. Quando você assinar o endpoint, ele deve estar pronto para receber pelo menos a mensagem de confirmação de inscrição.
# Etapa 2: Inscrever o HTTP/HTTPS endpoint no tópico do Amazon SNS
Para enviar mensagens a um endpoint HTTP ou HTTPS por meio de um tópico, inscreva o endpoint no tópico do Amazon SNS. Você especifica o endpoint usando seu URL. Para inscrever-se em um tópico, você pode usar o console do Amazon SNS, o comando [sns-subscribe](https://docs.aws.amazon.com/cli/latest/reference/sns/subscribe.html) ou a ação da API [Subscribe](https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html). Antes de começar, verifique se você tem o URL do endpoint que deseja inscrever e se o endpoint está preparado para receber a confirmação e as mensagens de notificação, como descrito na Etapa 1.
**Para inscrever um endpoint HTTP ou HTTPS em um tópico usando o console do Amazon SNS**
1. Faça login no [console do Amazon SNS](https://console.aws.amazon.com/sns/home).
1. No painel de navegação, escolha **Subscriptions (Assinaturas)**.
1. Selecione **Create subscription** (Criar assinatura).
1. Na lista suspensa **Protocolo**, selecione **HTTP** ou **HTTPS**.
1. Na caixa **Endpoint**, cole a URL do endpoint para o qual você deseja que o tópico envie mensagens e escolha **Create subscription (Criar inscrição)**.
1. A mensagem de confirmação é exibida. Escolha **Fechar**.
O **ID de assinatura da sua nova assinatura** é exibido PendingConfirmation. Quando você confirmar a inscrição, o **ID da inscrição** exibirá o ID da inscrição.
# Etapa 3: confirmar sua assinatura do Amazon SNS
Para confirmar uma assinatura no Amazon SNS, siga estas etapas para garantir que o endpoint possa receber mensagens com sucesso. Esse processo envolve configurar o endpoint para lidar com as mensagens de confirmação recebidas, recuperar o URL de confirmação necessário e confirmar a assinatura. Você pode confirmar a assinatura automática ou manualmente, dependendo da sua configuração.
1. Depois da assinatura ao tópico do Amazon SNS, o Amazon SNS enviará uma mensagem de confirmação a esse endpoint. Essa mensagem contém um `SubscribeURL`, que você deve usar para confirmar a assinatura.
1. O endpoint deve estar configurado para ouvir as mensagens recebidas do Amazon SNS. Quando a mensagem de confirmação chegar, extraia o **`SubscribeURL`** da mensagem.
1. Com o `SubscribeURL` em mãos, você poderá confirmar a assinatura de uma das maneiras a seguir:
+ **Confirmação automática**: o endpoint pode confirmar automaticamente a assinatura enviando uma **solicitação HTTP GET** para o `SubscribeURL`.
Este método não requer intervenção manual.
+ **Confirmação manual**: se a confirmação automática não estiver configurada, **copie** o **`SubscribeURL`** da mensagem de confirmação e **cole** na barra de endereço do seu navegador.
Isso confirmará a assinatura manualmente.
1. Você também pode verificar o **status da assinatura** usando o console do Amazon SNS.
1. Faça login no [console do Amazon SNS](https://console.aws.amazon.com/sns/home).
1. No painel de navegação, escolha **Assinaturas**.
1. Encontre sua **assinatura** na lista.
+ Se confirmada, o `SubscriptionArn` será exibido.
+ Se ainda não estiver confirmada, será exibida como `PendingConfirmation`.
# Etapa 4: opcional - definir a política de entrega para a assinatura do Amazon SNS.
Por padrão, se a entrega inicial da mensagem falhar, o Amazon SNS faz até três novas tentativas com uma espera de 20 segundos entre as tentativas malsucedidas. Conforme foi dito na [Etapa 1](SendMessageToHttp.prepare.md), o endpoint deve ter o código que pode processar novas tentativas de mensagens. Ao definir a política de entrega em um tópico ou inscrição, você pode controlar a frequência e o intervalo com que o Amazon SNS tentará entregar novamente mensagens com falha. Você também pode especificar o tipo de conteúdo para suas HTTP/S notificações em`DeliveryPolicy`. Para obter mais informações, consulte [Criação de uma política HTTP/S de entrega](sns-message-delivery-retries.md#creating-delivery-policy).
# Etapa 5: opcional - conceder aos usuários permissões para publicar no tópico do Amazon SNS
Por padrão, o proprietário do tópico tem permissão para publicar no tópico. Para permitir que outros usuários ou aplicativos publiquem no tópico, você deve usar AWS Identity and Access Management (IAM) para dar permissão de publicação ao tópico. Para obter mais informações sobre como conceder permissões para ações do Amazon SNS a usuários do IAM, consulte [Usar políticas baseadas em identidade com o Amazon SNS](sns-using-identity-based-policies.md).
Há duas maneiras de controlar o acesso a um tópico:
+ Adicione uma política para um usuário ou grupo do IAM. A maneira mais simples de conceder aos usuários permissões para tópicos é criar um grupo e adicionar a política adequada e os usuários ao grupo. É muito mais fácil adicionar e remover usuários de um grupo do que controlar as políticas definidas para usuários individualmente.
+ Adicione uma política ao tópico. Se deseja conceder permissões para um tópico para outra AWS , a única maneira de fazer isso é adicionando uma política com a Conta da AWS para a qual você deseja conceder permissões como principal.
Você deve usar o primeiro método para a maioria dos casos (aplicar políticas a grupos e gerenciar permissões para usuários adicionando ou removendo os usuários adequados aos grupos). Se você precisa conceder permissões a um usuário em outra conta, use o segundo método.
Se você adicionasse a política a seguir a um usuário ou grupo do IAM, concederia permissão a esse usuário ou membros desse grupo para realizar a `sns:Publish` ação no tópico MyTopic.
```
{
"Statement":[{
"Sid":"AllowPublishToMyTopic",
"Effect":"Allow",
"Action":"sns:Publish",
"Resource":"arn:aws:sns:us-east-2:123456789012:MyTopic"
}]
}
```
O exemplo a seguir de política mostra como conceder permissão à outra conta para um tópico.
**nota**
Ao conceder outro Conta da AWS acesso a um recurso em sua conta, você também concede aos usuários do IAM que têm acesso em nível de administrador (acesso curinga) permissões a esse recurso. Todos os outros usuários do IAM na outra conta têm automaticamente o acesso negado a seus recursos. Se você quiser dar a usuários específicos do IAM esse Conta da AWS acesso ao seu recurso, a conta ou um usuário do IAM com acesso em nível de administrador deve delegar permissões para o recurso a esses usuários do IAM. Para obter mais informações sobre a delegação entre contas, consulte [Habilitar acesso entre contas](https://docs.aws.amazon.com/IAM/latest/UserGuide/Delegation.html) no *Guia de uso do IAM*.
Se você adicionasse a política a seguir a um tópico MyTopic na conta 123456789012, concederia permissão à conta 111122223333 para realizar a ação nesse tópico. `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"
}]
}
```
# Etapa 6: Enviar mensagens do Amazon SNS para o endpoint HTTP/HTTPS
É possível enviar uma mensagem para inscrições em um tópico publicando no tópico. Para publicar um tópico, use o console do Amazon SNS, o comando `[sns-publish](https://docs.aws.amazon.com/cli/latest/reference/sns/publish.html)` da CLI ou a API `[Publish](https://docs.aws.amazon.com/sns/latest/api/API_Publish.html)`.
Se seguiu a [Etapa 1](SendMessageToHttp.prepare.md), o código que você implantou no endpoint deve processar a notificação.
**Para publicar um tópico usando o console do Amazon SNS**
1. Usando as credenciais do usuário Conta da AWS ou do IAM com permissão para publicar no tópico, faça login no Console de gerenciamento da AWS e abra o console do Amazon SNS em. [https://console.aws.amazon.com/sns/](https://console.aws.amazon.com/sns/home)
1. No painel de navegação, escolha **Topics (Tópicos)** e selecione um tópico.
1. Escolha o botão **Publicar mensagem**.
1. Na caixa **Subject (Assunto)**, insira um assunto (por exemplo, **Testing publish to my endpoint**).
1. Na caixa **Message (Mensagem)**, insira texto (por exemplo, **Hello world\$1**) e escolha **Publish message (Publicar mensagem)**.
Será exibida a seguinte mensagem: Your message has been successfully published.
# Verificação das assinaturas de mensagens do Amazon SNS
O Amazon SNS usa assinaturas de mensagens para confirmar a autenticidade das mensagens enviadas ao seu endpoint HTTP. Para garantir a integridade da mensagem e evitar falsificações, você **deve** verificar a assinatura antes de processar qualquer mensagem do Amazon SNS.
**Quando você deve verificar as assinaturas do Amazon SNS?**
Você deve verificar as assinaturas de mensagens do Amazon SNS nos seguintes cenários:
+ Quando o Amazon SNS envia uma mensagem de notificação ao seu endpoint HTTP (S).
+ Quando o Amazon SNS envia uma mensagem de confirmação para seu endpoint após uma chamada de API [https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html](https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html) ou [https://docs.aws.amazon.com/sns/latest/api/API_Unsubscribe.html](https://docs.aws.amazon.com/sns/latest/api/API_Unsubscribe.html).
**O Amazon SNS é compatível com duas versões de assinatura:**
+ SignatureVersion1 — Usa um SHA1 hash da mensagem.
+ SignatureVersion2 — Usa um SHA256 hash da mensagem. Isso fornece uma segurança mais forte e é a opção recomendada.
**Para verificar corretamente as assinaturas de mensagens do SNS, siga estas práticas recomendadas:**
+ Sempre recupere o certificado de assinatura usando HTTPS para evitar ataques de interceptação não autorizados.
+ Verifique se o certificado foi emitido pelo Amazon SNS.
+ Confirme se a cadeia de confiança do certificado é válida.
+ O certificado deve vir de um URL assinado pelo SNS.
+ Não confie em nenhum certificado fornecido na mensagem sem validação.
+ Rejeite qualquer mensagem com um `TopicArn` inesperado para evitar falsificação.
+ O AWS SDKs for Amazon SNS fornece lógica de validação integrada, reduzindo o risco de implementação incorreta.
# Como configurar a versão de assinatura de mensagens nos tópicos do Amazon SNS
Configurar a versão de assinatura de mensagens nos tópicos do Amazon SNS permite que você aprimore a segurança e a compatibilidade do seu processo de verificação de mensagens.
Selecione entre `SignatureVersion` **1** (SHA1) e `SignatureVersion` **2** (SHA256) para controlar o algoritmo de hash usado para assinar mensagens. Os tópicos do Amazon SNS têm como padrão `SignatureVersion`**1**. Você pode definir essa configuração usando a ação de API [https://docs.aws.amazon.com/sns/latest/api/API_SetTopicAttributes.html](https://docs.aws.amazon.com/sns/latest/api/API_SetTopicAttributes.html).
Use o exemplo de código a seguir para definir o atributo do tópico `SignatureVersion` usando a AWS CLI:
```
aws sns set-topic-attributes \
--topic-arn arn:aws:sns:us-east-2:123456789012:MyTopic \
--attribute-name SignatureVersion \
--attribute-value 2
```
# Verificação da assinatura de uma mensagem do Amazon SNS usando solicitações baseadas em consulta HTTP
Verificação da assinatura de uma mensagem do Amazon SNS usando solicitações baseadas em consulta HTTP garante a autenticidade e integridade da mensagem. Esse processo confirma que a mensagem é originária do Amazon SNS e não foi adulterada durante o trânsito. Ao analisar a mensagem, criar a string correta para assinar e validar a assinatura em relação a uma chave pública confiável, você protege seu sistema contra falsificações e alterações não autorizadas de mensagens.
1. Extraia os **pares chave/valor** do documento JSON no corpo da solicitação HTTP POST enviada pelo Amazon SNS. Esses campos são obrigatórios para criar a **string a ser assinada**.
+ `Message`
+ `Subject` (se presente)
+ `MessageId`
+ `Timestamp`
+ `TopicArn`
+ `Type`
Por exemplo:
```
MESSAGE_FILE="message.json"
FIELDS=("Message" "MessageId" "Subject" "Timestamp" "TopicArn" "Type")
```
**nota**
Se algum campo contiver caracteres de escape (por exemplo, `\n`), converta-os para o **formato original** para garantir uma correspondência exata.
1. Localize o campo `SigningCertURL` na mensagem do Amazon SNS. Esse certificado contém a chave pública necessária para verificar a assinatura da mensagem. Por exemplo:
```
SIGNING_CERT_URL=$(jq -r '.SigningCertURL' "$MESSAGE_FILE")
```
1. Certifique-se de que `SigningCertURL` seja de um AWS domínio confiável (por exemplo,https://sns.us-east-1.amazonaws.com). Rejeite qualquer ** AWS domínio URLs externo** por motivos de segurança.
1. Baixe o **certificado X.509** do URL fornecido. Por exemplo:
```
curl -s "$SIGNING_CERT_URL" -o signing_cert.pem
```
1. Extraia a **chave pública** do certificado X.509 baixado. A chave pública permite descriptografar a assinatura da mensagem e verificar sua integridade. Por exemplo:
```
openssl x509 -pubkey -noout -in signing_cert.pem > public_key.pem
```
1. Tipos de mensagem diferentes exigem pares de chave/valor diferentes na string a ser assinada. Identifique o **tipo de mensagem** (campo `Type` da mensagem do Amazon SNS) para determinar quais **pares de chave/valor** incluir:
+ **Mensagem de notificação**: inclui `Message`, `MessageId`, `Subject` (se presente), `Timestamp`, `TopicArn` e `Type`.
+ **SubscriptionConfirmation**ou **UnsubscribeConfirmation mensagem** — Inclui `Message``MessageId`,`SubscribeURL`, `Timestamp``Token`,`TopicArn`,, `Type` e.
1. O Amazon SNS exige que a string seja assinada para seguir uma ordem de campo fixa e rígida para verificação. **Somente os campos explicitamente obrigatórios devem ser incluídos**. Nenhum outro campo pode ser adicionado. Campos opcionais, como `Subject`, devem ser incluídos somente se estiverem presentes na mensagem e devem aparecer na posição exata definida pela ordem dos campos obrigatórios. Por exemplo:
```
KeyNameOne\nValueOne\nKeyNameTwo\nValueTwo
```
**Importante**
Não adicione um caractere de nova linha no final da mensagem.
1. Organize os **pares de chave/valor** em ordem de classificação por bytes (alfabética pelo nome da chave).
1. Crie a **string a ser assinada** usando o seguinte exemplo 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
```
**Exemplo de mensagem de notificação:**
```
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 exemplo:**
```
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. O campo `Signature` na mensagem é codificado em Base64. Você precisa **decodificá-lo** para comparar sua **forma binária bruta** com o **hash derivado**. Por exemplo:
```
SIGNATURE=$(jq -r '.Signature' "$MESSAGE_FILE")
echo "$SIGNATURE" | base64 -d > signature.bin
```
1. Use o campo `SignatureVersion` para selecionar o algoritmo de hash:
+ Para `SignatureVersion` **1**, use **SHA1**(por exemplo,`-sha1`).
+ Para `SignatureVersion` **2**, use **SHA256**(por exemplo,`-sha256`).
1. Para confirmar a autenticidade da mensagem do Amazon SNS, gere um **hash** da string criada e verifique a assinatura usando a **chave pública**.
```
openssl dgst -sha256 -verify public_key.pem -signature signature.bin <<< "$STRING_TO_SIGN"
```
Se a assinatura for válida, o resultado será `Verified OK`. Caso contrário, o resultado será `Verification Failure`.
## Exemplo de script com tratamento de erros
O seguinte script de exemplo automatiza o processo de verificação:
```
#!/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)
```
# Analisar formatos de mensagem do Amazon SNS
Quando o Amazon SNS envia mensagens para HTTP/HTTPS endpoints, eles contêm cabeçalhos HTTP e um corpo de mensagem JSON. Essas mensagens seguem um formato estruturado que inclui metadados, como tipo de mensagem, ARN do tópico, carimbos de data/hora e assinaturas digitais. Ao analisar corretamente as mensagens do Amazon SNS, você pode determinar se uma mensagem é uma confirmação de assinatura, notificação ou confirmação de cancelamento de assinatura, extrair dados relevantes e verificar a autenticidade usando a validação de assinatura.
# Cabeçalhos HTTP/HTTPS
Quando o Amazon SNS envia uma mensagem de confirmação, notificação ou confirmação de cancelamento de assinatura para HTTP/HTTPS endpoints, ele envia uma mensagem POST com vários valores de cabeçalho específicos do Amazon SNS. É possível usar valores de cabeçalho para tarefas como identificar o tipo de mensagem sem precisar analisar o corpo da mensagem JSON para ler o valor `Type`. Por padrão, o Amazon SNS envia todas as notificações para endpoints HTTP/S com `Content-Type` definido como `text/plain; charset=UTF-8`. Para escolher uma opção `Content-Type` diferente de text/plain (padrão), consulte `headerContentType` em[Criação de uma política HTTP/S de entrega](sns-message-delivery-retries.md#creating-delivery-policy).
**`x-amz-sns-message-type`**
O tipo de mensagem. Os valores possíveis são `SubscriptionConfirmation`, `Notification` e `UnsubscribeConfirmation`.
**`x-amz-sns-message-id`**
Um Identificador universalmente exclusivo (UUID), exclusivo para cada mensagem publicada. Para uma notificação que o Amazon SNS reenvia durante uma nova tentativa, o ID da mensagem original é usado.
**`x-amz-sns-topic-arn`**
O Nome de recurso da Amazon (ARN) para o tópico em que essa mensagem foi publicada.
**`x-amz-sns-subscription-arn`**
O ARN para a inscrição desse endpoint.
O cabeçalho HTTP POST a seguir é um exemplo de um cabeçalho para uma mensagem de `Notification` para um endpoint 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 confirmação de assinatura HTTP/HTTPS
Depois de assinar um HTTP/HTTPS endpoint, o Amazon SNS envia uma mensagem de confirmação da assinatura para HTTP/HTTPS o endpoint. Essa mensagem contém um valor `SubscribeURL` que você deve consultar para confirmar a assinatura (como alternativa, é possível usar o valor `Token` com o [https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html](https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html)).
**nota**
O Amazon SNS não enviará notificações para esse endpoint enquanto a inscrição não for confirmada.
A mensagem de confirmação da inscrição é uma mensagem POST com um corpo de mensagem que contém um documento JSON com os pares de nome/valor a seguir.
**`Type`**
O tipo de mensagem. Para uma confirmação da inscrição, o tipo é `SubscriptionConfirmation`.
**`MessageId`**
Um Identificador universalmente exclusivo (UUID), exclusivo para cada mensagem publicada. Para uma mensagem que o Amazon SNS reenvia durante uma nova tentativa, o ID da mensagem original é usado.
**`Token`**
Um valor que pode ser usado com a ação [https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html](https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html) para confirmar a assinatura. Como alternativa, você pode simplesmente acessar o `SubscribeURL`.
**`TopicArn`**
O Nome de recurso da Amazon (ARN) para o tópico em que este endpoint está inscrito.
**`Message`**
Uma string que descreve a mensagem. Para confirmação da inscrição, esta string é semelhante a:
```
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`**
O URL que você deve acessar para confirmar a inscrição. Como alternativa, é possível usar o `Token` com a ação [https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html](https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html) para confirmar a assinatura.
**`Timestamp`**
A hora (GMT) quando a confirmação da inscrição foi enviada.
**`SignatureVersion`**
Versão da assinatura do Amazon SNS usada.
+ Se `SignatureVersion` for **1**, `Signature` será uma assinatura `SHA1withRSA` codificada em Base64 dos valores `Message`, `MessageId`, `Type`, `Timestamp` e `TopicArn`.
+ Se `SignatureVersion` for **2**, `Signature` será uma assinatura `SHA256withRSA` codificada em Base64 dos valores `Message`, `MessageId`, `Type`, `Timestamp` e `TopicArn`.
**`Signature`**
Assinatura `SHA1withRSA` ou `SHA256withRSA` codificada em Base64 dos valores `Message`, `MessageId`, `Type`, `Timestamp` e `TopicArn`.
**`SigningCertURL`**
O URL do certificado que foi usado para assinar a mensagem.
A mensagem HTTP POST a seguir é um exemplo de uma mensagem de `SubscriptionConfirmation` para um endpoint 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 notificação HTTP/HTTPS
Quando o Amazon SNS envia uma notificação para um endpoint HTTP ou HTTPS inscrito, a mensagem POST enviada para o endpoint tem um corpo da mensagem que contém um documento JSON com os seguintes pares de nome-valor.
**`Type`**
O tipo de mensagem. Para uma notificação, o tipo é `Notification`.
**`MessageId`**
Um Identificador universalmente exclusivo (UUID), exclusivo para cada mensagem publicada. Para uma notificação que o Amazon SNS reenvia durante uma nova tentativa, o ID da mensagem original é usado.
**`TopicArn`**
O Nome de recurso da Amazon (ARN) para o tópico em que essa mensagem foi publicada.
**`Subject`**
O parâmetro `Subject` especificado quando a notificação foi publicada no tópico.
Esse parâmetro é opcional. Se nenhum `Subject` foi especificado, esse par de nome/valor não é exibido nesse documento JSON.
**`Message`**
O valor `Message` especificado quando a notificação foi publicada no tópico.
**`Timestamp`**
A hora (GMT) quando a notificação foi publicada.
**`SignatureVersion`**
Versão da assinatura do Amazon SNS usada.
+ Se `SignatureVersion` for **1**, `Signature` será uma assinatura `SHA1withRSA` codificada em Base64 dos valores `Message`, `MessageId`, `Subject` (se presente), `Type`, `Timestamp` e `TopicArn`.
+ Se `SignatureVersion` for **2**, `Signature` será uma assinatura `SHA256withRSA` codificada em Base64 dos valores `Message`, `MessageId`, `Subject` (se presente), `Type`, `Timestamp` e `TopicArn`.
**`Signature`**
Assinatura `SHA1withRSA` ou `SHA256withRSA` codificada em Base64 dos valores `Message`, `MessageId`, `Subject` (se presente), `Type`, `Timestamp` e `TopicArn`.
**`SigningCertURL`**
O URL do certificado que foi usado para assinar a mensagem.
**`UnsubscribeURL`**
Um URL que você pode usar para cancelar a inscrição do endpoint com base neste tópico. Se você acessar este URL, o Amazon SNS cancela a inscrição do endpoint e interrompe o envio de notificações para esse endpoint.
A mensagem HTTP POST a seguir é um exemplo de uma mensagem de `Notification` para um endpoint 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 confirmação de cancelamento de assinatura HTTP/HTTPS
Depois que um HTTP/HTTPS endpoint é desinscrito em um tópico, o Amazon SNS envia uma mensagem de confirmação de cancelamento de assinatura para o endpoint.
A mensagem de confirmação do cancelamento da inscrição é uma mensagem POST com um corpo de mensagem que contém um documento JSON com os pares de nome/valor a seguir.
**`Type`**
O tipo de mensagem. Para uma confirmação de cancelamento de inscrição, o tipo é `UnsubscribeConfirmation`.
**`MessageId`**
Um Identificador universalmente exclusivo (UUID), exclusivo para cada mensagem publicada. Para uma mensagem que o Amazon SNS reenvia durante uma nova tentativa, o ID da mensagem original é usado.
**`Token`**
Um valor que pode ser usado com a ação [https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html](https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html) para confirmar novamente a assinatura. Como alternativa, você pode simplesmente acessar o `SubscribeURL`.
**`TopicArn`**
O Nome de recurso da Amazon (ARN) para o tópico do qual esse endpoint teve sua inscrição cancelada.
**`Message`**
Uma string que descreve a mensagem. Para a confirmação de cancelamento de inscrição, esta string é semelhante a:
```
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`**
O URL que você deve acessar para confirmar novamente a inscrição. Como alternativa, é possível usar o `Token` com a ação [https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html](https://docs.aws.amazon.com/sns/latest/api/API_ConfirmSubscription.html) para confirmar novamente a assinatura.
**`Timestamp`**
A hora (GMT) quando a confirmação de cancelamento da inscrição foi enviada.
**`SignatureVersion`**
Versão da assinatura do Amazon SNS usada.
+ Se `SignatureVersion` for **1**, `Signature` será uma assinatura `SHA1withRSA` codificada em Base64 dos valores `Message`, `MessageId`, `Type`, `Timestamp` e `TopicArn`.
+ Se `SignatureVersion` for **2**, `Signature` será uma assinatura `SHA256withRSA` codificada em Base64 dos valores `Message`, `MessageId`, `Type`, `Timestamp` e `TopicArn`.
**`Signature`**
Assinatura `SHA1withRSA` ou `SHA256withRSA` codificada em Base64 dos valores `Message`, `MessageId`, `Type`, `Timestamp` e `TopicArn`.
**`SigningCertURL`**
O URL do certificado que foi usado para assinar a mensagem.
A mensagem HTTP POST a seguir é um exemplo de uma mensagem de `UnsubscribeConfirmation` para um endpoint 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 formato JSON da política de entrega
Se você envia uma solicitação para a ação `SetSubscriptionAttributes` e define o parâmetro `AttributeName` para um valor de `DeliveryPolicy`, o valor do parâmetro `AttributeValue` deve ser um objeto JSON válido. Por exemplo, o exemplo a seguir define a política de entrega para um total de cinco novas tentativas.
```
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}}
...
```
Use o formato JSON a seguir para o valor do 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 obter mais informações sobre a `SetSubscriptionAttribute` ação, acesse a *Referência [SetSubscriptionAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetSubscriptionAttributes.html)de API do Amazon Simple Notification Service*. Para obter mais informações sobre os cabeçalhos do tipo de conteúdo HTTP compatíveis, consulte [Criação de uma política HTTP/S de entrega](sns-message-delivery-retries.md#creating-delivery-policy).
# SetTopicAttributes formato JSON da política de entrega
Se você envia uma solicitação para a ação `SetTopicAttributes` e define o parâmetro `AttributeName` para um valor de `DeliveryPolicy`, o valor do parâmetro `AttributeValue` deve ser um objeto JSON válido. Por exemplo, o exemplo a seguir define a política de entrega para um total de cinco novas tentativas.
```
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}}}
...
```
Use o formato JSON a seguir para o valor do 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 obter mais informações sobre a `SetTopicAttribute` ação, acesse a *Referência [SetTopicAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetTopicAttributes.html)de API do Amazon Simple Notification Service*. Para obter mais informações sobre os cabeçalhos do tipo de conteúdo HTTP compatíveis, consulte [Criação de uma política HTTP/S de entrega](sns-message-delivery-retries.md#creating-delivery-policy).
# Transforme eventos do Amazon SNS em Event Fork AWS Pipelines
| |
| --- |
| Para arquivamento e análise de eventos, o Amazon SNS agora recomenda o uso de sua integração nativa com o Amazon Data Firehose. Você pode inscrever streams de entrega do Firehose em tópicos do SNS, o que permite enviar notificações para endpoints de arquivamento e análise, como buckets do Amazon Simple Storage Service (Amazon S3), tabelas do Amazon Redshift, Amazon Service (Service) e muito mais. OpenSearch OpenSearch Usar o Amazon SNS com os streams de entrega do Firehose é uma solução totalmente gerenciada e sem código que não exige o uso de funções. AWS Lambda Para obter mais informações, consulte [Fanout de fluxos de entrega do Firehose](sns-firehose-as-subscriber.md). |
Você pode usar o Amazon SNS para desenvolver aplicações orientadas por eventos que usam serviços de assinante para executar o trabalho automaticamente em resposta a eventos acionados por serviços do editor. Esse padrão de arquitetura pode tornar os serviços mais reutilizáveis, interoperáveis e dimensionáveis. No entanto, pode ser trabalhoso usar o processamento de eventos em pipelines que abordam os requisitos de manipulação de eventos comuns, como armazenamento de eventos, backup, pesquisa, análise e reprodução.
Para acelerar o desenvolvimento de seus aplicativos orientados a eventos, você pode inscrever pipelines de tratamento de eventos — desenvolvidos pelo AWS Event Fork Pipelines — em tópicos do Amazon SNS. AWS O Event Fork Pipelines é um conjunto de [aplicativos aninhados](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-nested-applications.html) de código aberto, baseado no [AWS Serverless Application Model](https://aws.amazon.com/serverless/sam/) (AWS SAM), que você pode implantar diretamente do [pacote AWS Event Fork Pipelines](https://serverlessrepo.aws.amazon.com/applications?query=aws-event-fork-pipelines) (escolha **Mostrar aplicativos que criam funções personalizadas do IAM** ou políticas de recursos) em sua conta. AWS
Para um AWS caso de uso do Event Fork Pipelines, consulte. [Implantar e testar a aplicação de exemplo de event fork pipelines do Amazon SNS](sns-deploy-test-fork-pipelines-sample-application.md)
**Topics**
+ [Como funciona o AWS Event Fork Pipelines](#how-sns-fork-works)
+ [Implantação de tubulações AWS Event Fork](#deploying-sns-fork-pipelines)
+ [Implantar e testar a aplicação de exemplo de event fork pipelines do Amazon SNS](sns-deploy-test-fork-pipelines-sample-application.md)
+ [Inscrevendo AWS Event Fork Pipelines em um tópico do Amazon SNS](sns-subscribe-event-fork-pipelines.md)
## Como funciona o AWS Event Fork Pipelines
AWS O Event Fork Pipelines é um padrão de design sem servidor. No entanto, também é um conjunto de aplicativos sem servidor aninhados baseados no AWS SAM (que você pode implantar diretamente do (AWS SAR) para o AWS Serverless Application Repository seu, a fim de enriquecer suas Conta da AWS plataformas orientadas a eventos). Você pode implantar essas aplicações aninhadas individualmente, conforme sua arquitetura exigir.
**Topics**
+ [O pipeline de armazenamento e backup de eventos](#sns-fork-event-storage-and-backup-pipeline)
+ [O pipeline de pesquisa e análise de eventos](#sns-fork-event-search-and-analytics-pipeline)
+ [O pipeline de reprodução de eventos](#sns-fork-event-replay-pipeline)
O diagrama a seguir mostra um aplicativo AWS Event Fork Pipelines complementado por três aplicativos aninhados. Você pode implantar qualquer um dos pipelines do pacote AWS Event Fork Pipelines no AWS SAR de forma independente, conforme sua arquitetura exige.
![\[A arquitetura AWS Event Fork Pipelines, mostrando como os eventos de um tópico do Amazon SNS são filtrados e processados por meio de três canais distintos: Armazenamento e Backup de Eventos, Pesquisa e Análise de Eventos e Repetição de Eventos. Esses pipelines são descritos como caixas empilhadas verticalmente, cada uma processando eventos paralelamente de forma independente do mesmo tópico do Amazon SNS.\]](http://docs.aws.amazon.com/pt_br/sns/latest/dg/images/sns-fork-pipeline-as-subscriber-how-it-works.png)
Cada pipeline é inscrito no mesmo tópico do Amazon SNS, o que permite que ele processe eventos em paralelo conforme esses eventos são publicados no tópico. Cada pipeline é independente e pode definir sua própria [política de filtro de assinatura](sns-subscription-filter-policies.md). Isso permite que um pipeline processe apenas um subconjunto dos eventos em que está interessado (em vez de todos os eventos publicados no tópico).
**nota**
Como você coloca os três AWS Event Fork Pipelines ao lado de seus pipelines regulares de processamento de eventos (possivelmente já inscritos no tópico do Amazon SNS), você não precisa alterar nenhuma parte do seu editor de mensagens atual para aproveitar os AWS Event Fork Pipelines em suas cargas de trabalho existentes.
### O pipeline de armazenamento e backup de eventos
O diagrama a seguir mostra o [pipeline de armazenamento e backup de eventos](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~fork-event-storage-backup-pipeline). Você pode inscrever esse pipeline em seu tópico do Amazon SNS para fazer backup automaticamente dos eventos que passam pelo sistema.
Esse pipeline é composto por uma fila do Amazon SQS que armazena em buffer os eventos entregues pelo tópico do Amazon SNS, AWS Lambda uma função que pesquisa automaticamente esses eventos na fila e os envia para um stream e um bucket do Amazon S3 que faz backup duradouro dos eventos carregados pelo stream.
![\[O Fork-Event-Storage-Backup -Pipeline, projetado para processar e fazer backup de eventos de um tópico do Amazon SNS. O fluxo começa com um tópico do Amazon SNS a partir do qual os eventos são distribuídos para uma fila do Amazon SQS. Esses eventos filtrados são então processados por uma função do Lambda, que os encaminha para um Data Firehose. O stream do Firehose é responsável por armazenar em buffer, transformar e compactar os eventos antes de carregá-los em um bucket de backup do Amazon S3. Por fim, o Amazon Athena pode ser usado para consultar os dados armazenados. O diagrama usa uma série de ícones e setas para ilustrar o fluxo de um serviço para o outro, identificando claramente cada componente do pipeline.\]](http://docs.aws.amazon.com/pt_br/sns/latest/dg/images/sns-fork-event-storage-and-backup-pipeline.png)
Para ajustar o comportamento de seu fluxo do Firehose, configure-o para armazenar em buffer, transformar e compactar seus eventos antes de carregá-los no bucket. À medida que os eventos forem carregados, use o Amazon Athena para consultar o bucket usando consultas SQL padrão. Você também pode configurar o pipeline para reutilizar um bucket do Simple Storage Service (Amazon S3) existente ou criar um novo.
### O pipeline de pesquisa e análise de eventos
O diagrama a seguir mostra o [pipeline de pesquisa e análise de eventos](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~fork-event-search-analytics-pipeline). Você pode inscrever esse pipeline em seu tópico do Amazon SNS para indexar os eventos que passam pelo sistema em um domínio de pesquisa e analisá-los.
Esse pipeline é composto por uma fila do Amazon SQS que armazena em buffer os eventos entregues pelo tópico do Amazon SNS, AWS Lambda uma função que pesquisa eventos da fila e os envia para um stream, um domínio do Amazon Service que indexa os eventos carregados pelo stream do Firehose e um bucket do OpenSearch Amazon S3 que armazena os eventos sem saída que não podem ser indexados no domínio de pesquisa.
![\[O pipeline de pesquisa e análise de eventos em uma AWS arquitetura. Começa à esquerda com o tópico Amazon SNS recebendo todos os eventos. Esses eventos são então canalizados por meio de uma linha tracejada representando “distribuir eventos filtrados” em uma fila do Amazon SQS. Da fila, os eventos são processados por uma função do Lambda, que os encaminha para um fluxo do Data Firehose. O Data Firehose direciona os eventos para dois destinos: uma rota leva a um Amazon Elasticsearch Service para indexação, e a outra rota envia eventos não processáveis ou “inativos” para um bucket de correio morto do Amazon S3. Na extrema direita, a saída do Elasticsearch Service é alimentada em um painel do Kibana para análise e visualização. Todo o fluxo é disposto horizontalmente e cada componente é conectado por linhas que mostram a direção do fluxo de dados.\]](http://docs.aws.amazon.com/pt_br/sns/latest/dg/images/sns-fork-event-search-and-analytics-pipeline.png)
Para ajustar o fluxo do Firehose em termos de armazenamento de eventos em buffer, transformação e compactação, você pode configurar esse pipeline.
Você também pode configurar se o pipeline deve reutilizar um OpenSearch domínio existente no seu Conta da AWS ou criar um novo para você. À medida que os eventos forem indexados no domínio de pesquisa, use o Kibana para executar a análise de seus eventos e atualizar os painéis visuais em tempo real.
### O pipeline de reprodução de eventos
O diagrama a seguir mostra o [pipeline de reprodução de eventos](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~fork-event-replay-pipeline). Para registrar os eventos que foram processados pelo sistema nos últimos 14 dias (por exemplo, quando sua plataforma precisar se recuperar de uma falha), inscreva esse pipeline em seu tópico do Amazon SNS e processe novamente os eventos.
Esse pipeline é composto por uma fila do Amazon SQS que armazena em buffer os eventos entregues pelo tópico do Amazon SNS e AWS Lambda uma função que pesquisa eventos da fila e os redireciona para seu pipeline regular de processamento de eventos, que também está inscrito em seu tópico.
![\[O Event Replay Pipeline em formato de fluxograma. Da esquerda para a direita, começa com um tópico do Amazon SNS que distribui eventos filtrados para dois processos paralelos. O fluxo superior representa seu pipeline regular de processamento de eventos, que inclui uma fila do Amazon SQS que processa eventos. O fluxo inferior, rotulado como "”fork-event-replay-pipeline, inclui uma fila de repetição do Amazon SQS em que os eventos são armazenados temporariamente antes de serem processados por uma função de reprodução do Lambda. Essa função do Lambda tem a capacidade de redirecionar eventos para seu pipeline regular de processamento de eventos ou mantê-los para reprodução, com base no fato de o recurso de repetição estar ativado ou desativado. O diagrama também indica que os operadores têm controle sobre a ativação ou desativação da funcionalidade de repetição de eventos.\]](http://docs.aws.amazon.com/pt_br/sns/latest/dg/images/sns-fork-event-replay-pipeline.png)
**nota**
Por padrão, a função de reprodução está desabilitada e não redireciona seus eventos. Se precisar reprocessar os eventos, você deve habilitar a fila de reprodução do Amazon SQS como uma origem de eventos para a função de reprodução do AWS Lambda .
## Implantação de tubulações AWS Event Fork
[O [pacote AWS Event Fork Pipelines](https://serverlessrepo.aws.amazon.com/applications?query=aws-event-fork-pipelines) (escolha **Mostrar aplicativos que criam funções personalizadas do IAM ou políticas de recursos**) está disponível como um grupo de aplicativos públicos no AWS Serverless Application Repository, de onde você pode implantá-los e testá-los manualmente usando o AWS Lambda console.](https://console.aws.amazon.com/lambda/) Para obter informações sobre como implantar pipelines usando o AWS Lambda console, consulte. [Inscrevendo AWS Event Fork Pipelines em um tópico do Amazon SNS](sns-subscribe-event-fork-pipelines.md)
Em um cenário de produção, recomendamos incorporar o AWS Event Fork Pipelines ao modelo geral de SAM do AWS seu aplicativo. O recurso de aplicativo aninhado permite que você faça isso adicionando o recurso `[AWS::Serverless::Application](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template.html#serverless-sam-template-application)` ao seu modelo AWS SAM, referenciando o AWS SAR `ApplicationId` e o `SemanticVersion` do aplicativo aninhado.
Por exemplo, você pode usar o Event Storage and Backup Pipeline como um aplicativo aninhado adicionando o seguinte trecho de YAML à `Resources` seção do seu modelo do 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
```
Ao especificar valores de parâmetros, você pode usar funções AWS CloudFormation intrínsecas para referenciar outros recursos em seu modelo. Por exemplo, no trecho YAML acima, o `TopicArn` parâmetro faz referência ao `[AWS::SNS::Topic](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-sns-topic.html)` recurso`MySNSTopic`, definido em outra parte do modelo. AWS SAM Para obter mais informações, consulte o [Referência à função intrínseca](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference.html) no *Guia do usuário do usuário do AWS CloudFormation *.
**nota**
A página do AWS Lambda console do seu aplicativo AWS SAR inclui o botão **Copiar como recurso do SAM**, que copia o YAML necessário para aninhar um aplicativo AWS SAR na área de transferência.
# Implantar e testar a aplicação de exemplo de event fork pipelines do Amazon SNS
Para acelerar o desenvolvimento de seus aplicativos orientados a eventos, você pode inscrever pipelines de tratamento de eventos — desenvolvidos pelo AWS Event Fork Pipelines — em tópicos do Amazon SNS. AWS O Event Fork Pipelines é um conjunto de [aplicativos aninhados](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-nested-applications.html) de código aberto, baseado no [AWS Serverless Application Model](https://aws.amazon.com/serverless/sam/) (AWS SAM), que você pode implantar diretamente do [pacote AWS Event Fork Pipelines](https://serverlessrepo.aws.amazon.com/applications?query=aws-event-fork-pipelines) (escolha **Mostrar aplicativos que criam funções personalizadas do IAM** ou políticas de recursos) em sua conta. AWS Para obter mais informações, consulte [Como funciona o AWS Event Fork Pipelines](sns-fork-pipeline-as-subscriber.md#how-sns-fork-works).
Esta página mostra como você pode usar o Console de gerenciamento da AWS para implantar e testar o aplicativo de amostra AWS Event Fork Pipelines.
**Importante**
Para evitar custos indesejados após concluir a implantação do aplicativo de amostra AWS Event Fork Pipelines, exclua sua pilha. CloudFormation Para obter mais informações, consulte [Excluir uma pilha no console do CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-delete-stack.html) no *Manual do usuário do AWS CloudFormation *.
# AWS Exemplo de caso de uso do Event Fork Pipelines
O cenário a seguir descreve um aplicativo de comércio eletrônico sem servidor e orientado por eventos que usa AWS o Event Fork Pipelines. Você pode usar esse [exemplo de aplicativo de comércio eletrônico](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~fork-example-ecommerce-checkout-api) no AWS Serverless Application Repository e depois implantá-lo no AWS Lambda console, onde você pode testá-lo e examinar seu código-fonte GitHub. Conta da AWS
![\[A arquitetura de um aplicativo de comércio eletrônico de tecnologia sem servidor que se integra a Serviços da AWS. Ele mostra o fluxo de usuários de comércio eletrônico que fazem pedidos por meio de um API Gateway para diferentes canais de processamento, incluindo armazenamento de pedidos, análise de pesquisa e reprodução, mostrando como os eventos são gerenciados e analisados por meio do Amazon SNS, Lambda, Amazon SQS, DynamoDB e Kibana.\]](http://docs.aws.amazon.com/pt_br/sns/latest/dg/images/sns-fork-example-use-case.png)
Esse aplicativo de comércio eletrônico recebe pedidos de compradores por meio de uma RESTful API hospedada pelo API Gateway e apoiada pela AWS Lambda função`CheckoutApiBackendFunction`. Essa função publica todos os pedidos recebidos em um tópico do Amazon SNS chamado `CheckoutEventsTopic` que, por sua vez, envia os pedidos para quatro pipelines diferentes.
O primeiro pipeline é o pipeline de processamento de checkout usual projetado e implementado pelo proprietário do aplicativo de comércio eletrônico. Esse pipeline tem a fila do Amazon SQS `CheckoutQueue` que armazena em buffer todos os pedidos recebidos, uma AWS Lambda função chamada `CheckoutFunction` que pesquisa a fila para processar esses pedidos e a tabela do DynamoDB que salva com segurança todos os pedidos feitos. `CheckoutTable`
## Aplicação de AWS tubulações Event Fork
Os componentes do aplicativo de comércio eletrônico processam a lógica de negócios central. No entanto, o proprietário do aplicativo de comércio eletrônico também precisa abordar o seguinte:
+ **Conformidade**: backups seguros e compactados, criptografados em repouso e limpeza de informações confidenciais
+ **Resiliência**: repetição dos pedidos mais recentes em caso de interrupção do processo de atendimento
+ **Capacidade de pesquisa**: execução de análise e geração de métricas nos pedidos realizados
Em vez de implementar essa lógica de processamento de eventos, o proprietário do aplicativo pode inscrever o AWS Event Fork Pipelines no tópico do Amazon `CheckoutEventsTopic` SNS
+ O [O pipeline de armazenamento e backup de eventos](sns-fork-pipeline-as-subscriber.md#sns-fork-event-storage-and-backup-pipeline) é configurado com o intuito de transformar dados para remover detalhes de cartões de crédito, armazenar os dados em buffer durante 60 segundos, compactá-los usando GZIP e criptografá-los usando a chave mestra de cliente (CMK) padrão do Amazon S3. Essa chave é gerenciada AWS e alimentada pelo AWS Key Management Service (AWS KMS).
Para obter mais informações, consulte [Escolher o Amazon S3 para seu destino](https://docs.aws.amazon.com/firehose/latest/dev/create-destination.html#create-destination-s3), [Transformação de dados do Amazon Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/data-transformation.html) e [Ajustar configurações](https://docs.aws.amazon.com/firehose/latest/dev/create-configure.html) no *Guia do desenvolvedor do Amazon Data Firehose*.
+ O [O pipeline de pesquisa e análise de eventos](sns-fork-pipeline-as-subscriber.md#sns-fork-event-search-and-analytics-pipeline) é configurado com uma duração de nova tentativa do índice de 30 segundos, um bucket para armazenar os pedidos que não são indexados no domínio de pesquisa e uma política de filtro para restringir o conjunto de pedidos indexados.
Para obter mais informações, consulte [Escolha o OpenSearch serviço para seu destino](https://docs.aws.amazon.com/firehose/latest/dev/create-destination.html#create-destination-elasticsearch) no Guia do *desenvolvedor do Amazon Data Firehose*.
+ O [O pipeline de reprodução de eventos](sns-fork-pipeline-as-subscriber.md#sns-fork-event-replay-pipeline) é configurado com a parte da fila do Amazon SQS do pipeline de processamento de pedidos usual projetado e implementado pela proprietária da aplicação de comércio eletrônico.
Para obter mais informações, consulte [Queue Name and URL](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-general-identifiers.html#queue-name-url) (“Nome e URL da fila”) no *Guia do desenvolvedor do Amazon Simple Queue Service*.
A seguinte política de filtro JSON é definida na configuração do pipeline de pesquisa e análise de eventos. Ela corresponde apenas aos pedidos de entrada em que a quantidade total for de 100 USD ou superior. Para obter mais informações, consulte [Filtragem de mensagens do Amazon SNS](sns-message-filtering.md).
```
{
"amount": [{ "numeric": [ ">=", 100 ] }]
}
```
Usando o padrão AWS Event Fork Pipelines, o proprietário do aplicativo de comércio eletrônico pode evitar a sobrecarga de desenvolvimento que geralmente segue a lógica indiferenciadora de codificação para tratamento de eventos. Em vez disso, ela pode implantar o AWS Event Fork Pipelines diretamente de AWS Serverless Application Repository dentro dela. Conta da AWS
# Etapa 1: implantar a aplicação de amostra do Amazon SNS
1. Faça login no [console do AWS Lambda](https://console.aws.amazon.com/lambda/).
1. No painel de navegação, escolha **Functions (Funções)** e selecione **Create function (Criar função)**.
1. Na página **Create function (Criar função)**, faça o seguinte:
1. Escolha **Browse serverless app repository** (Procurar no repositório de aplicações sem servidor), **Public applications** (Aplicações públicas), **Show apps that create custom IAM roles or resource policies** (Mostrar aplicações que criam funções do IAM ou políticas de recursos).
1. Procure `fork-example-ecommerce-checkout-api` e escolha o aplicativo.
1. Na página **fork-example-ecommerce-checkout-api**, faça o seguinte:
1. Na seção **Application settings (Configurações do aplicativo)**, insira um **Application name (Nome de aplicativo)** (por exemplo, `fork-example-ecommerce-my-app`).
**nota**
Para encontrar facilmente seus recursos posteriormente, mantenha o prefixo `fork-example-ecommerce`.
Para cada implantação, o nome do aplicativo deve ser exclusivo. Se você reutilizar o nome de um aplicativo, a implantação atualizará somente a CloudFormation pilha implantada anteriormente (em vez de criar uma nova).
1. (Opcional) Insira uma das seguintes **LogLevel**configurações para a execução da função Lambda do seu aplicativo:
+ `DEBUG`
+ `ERROR`
+ `INFO` (padrão)
+ `WARNING`
1. Escolha **I acknowledge that this app creates custom IAM roles, resource policies and deploys nested applications. (Eu reconheço que este aplicativo cria funções personalizadas do IAM, políticas de recursos e implanta aplicativos aninhados.)** e, na parte inferior da página, selecione **Deploy (Implantar)**.
Na *my-app* página **Status de implantação para fork-example-ecommerce -**, o Lambda exibe o status **Seu aplicativo está sendo implantado**.
Na seção **Recursos**, CloudFormation começa a criar a pilha e exibe o status **CREATE\$1IN\$1PROGRESS** de cada recurso. Quando o processo estiver concluído, CloudFormation exibirá o status **CREATE\$1COMPLETE**.
**nota**
Pode levar entre 20–30 minutos para que todos os recursos sejam implantados.
Quando a implantação for concluída, o Lambda exibirá o status **Your application has been deployed** (Sua aplicação foi implantada).
# Etapa 2: executar a aplicação de amostra vinculado ao SNS
1. No AWS Lambda console, no painel de navegação, escolha **Aplicativos**.
1. Na página **Aplicativos**, no campo de pesquisa, busque `serverlessrepo-fork-example-ecommerce-my-app` e escolha o aplicativo.
1. Na seção **Recursos**, faça o seguinte:
1. Para encontrar o recurso cujo tipo é **ApiGatewayRestApi**, classifique os recursos por **Tipo**, por exemplo`ServerlessRestApi`, e expanda o recurso.
1. Dois recursos aninhados são exibidos, dos tipos **ApiGatewayDeployment** e **ApiGatewayStage**.
1. Copie o link **Endpoint da API de produção** e anexe `/checkout` a ele, por exemplo:
```
https://abcdefghij.execute-api.us-east-2.amazonaws.com/Prod/checkout
```
1. Copie o JSON a seguir em um arquivo 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 uma solicitação HTTPS ao endpoint da API, envie a carga do evento de exemplo como entrada, executando um comando `curl`, por exemplo:
```
curl -d "$(cat test_event.json)" https://abcdefghij.execute-api.us-east-2.amazonaws.com/Prod/checkout
```
A API retorna a seguinte resposta vazia, indicando uma execução bem-sucedida:
```
{ }
```
# Etapa 3: verificar o desempenho do aplicativo e do pipeline do Amazon SNS
## Etapa 1: verificar a execução do pipeline de checkout de exemplo
1. Faça login no [console do Amazon DynamoDB](https://console.aws.amazon.com/dynamodb/).
1. No painel de navegação, escolha **Tables (Tabelas)**.
1. Busque `serverlessrepo-fork-example` e escolha `CheckoutTable`.
1. Na página de detalhes da tabela, escolha **Items (Itens)** e selecione o item criado.
Os atributos armazenados são exibidos.
## Etapa 2: verificar a execução do pipeline de armazenamento e backup de eventos
1. Faça login no [console do Amazon S3](https://console.aws.amazon.com/s3/).
1. No painel de navegação, selecione **Buckets**.
1. Busque `serverlessrepo-fork-example` e escolha `CheckoutBucket`.
1. Navegue pela hierarquia de diretórios até encontrar um arquivo com a extensão `.gz`.
1. Para fazer download do arquivo, escolha **Ações**, **Abrir**.
1. O pipeline está configurado com uma função do Lambda que limpa as informações de cartão de crédito por motivos de conformidade.
Para verificar se a carga JSON armazenada não contém informações de cartão de crédito, descompacte o arquivo.
## Etapa 3: verificar a execução do pipeline de pesquisa e análise de eventos
1. Faça login no [console OpenSearch de serviço](https://console.aws.amazon.com/aos/).
1. No painel de navegação, em **Meus domínios**, escolha o domínio prefixado com `serverl-analyt`.
1. O pipeline está configurado com uma política de filtro de assinatura do Amazon SNS que define uma condição de correspondência numérica.
****Para verificar se o evento está indexado porque se refere a um pedido cujo valor é maior que USD \$1100, na *abcdefgh1ijk* página **servidor-analista, escolha Índices, checkout\$1events**.****
## Etapa 4: verificar a execução do pipeline de repetição de eventos
1. Faça login no [console do Amazon SQS](https://console.aws.amazon.com/sqs/).
1. Na lista de filas, busque `serverlessrepo-fork-example` e escolha `ReplayQueue`.
1. Escolha **Enviar e receber mensagens**.
1. Na caixa de *123ABCD4E5F6* diálogo **Enviar e receber mensagens em fork-example-ecommerce -*my-app*... ReplayP- ReplayQueue -**, escolha **Sondagem** de mensagens.
1. Para verificar se o evento está enfileirado, escolha **Mais detalhes** ao lado da mensagem que aparece na fila.
# Etapa 4: simular um problema e repetir eventos para recuperação
## Etapa 1: habilitar o problema simulado e enviar uma segunda solicitação da API
1. Faça login no [console do AWS Lambda](https://console.aws.amazon.com/lambda/).
1. No painel de navegação, escolha **Functions (Funções)**.
1. Busque `serverlessrepo-fork-example` e escolha `CheckoutFunction`.
1. No **fork-example-ecommerce- *my-app* - CheckoutFunction -*ABCDEF*...** **página, na seção **Variáveis de ambiente**, defina a variável **BUG\$1ENABLED como** **verdadeira e escolha** Salvar.**
1. Copie o JSON a seguir em um arquivo 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 uma solicitação HTTPS ao endpoint da API, envie a carga do evento de exemplo como entrada, executando um comando `curl`, por exemplo:
```
curl -d "$(cat test_event_2.json)" https://abcdefghij.execute-api.us-east-2.amazonaws.com/Prod/checkout
```
A API retorna a seguinte resposta vazia, indicando uma execução bem-sucedida:
```
{ }
```
## Etapa 2: verificar a corrupção de dados simulados
1. Faça login no [console do Amazon DynamoDB](https://console.aws.amazon.com/dynamodb/).
1. No painel de navegação, escolha **Tables (Tabelas)**.
1. Busque `serverlessrepo-fork-example` e escolha `CheckoutTable`.
1. Na página de detalhes da tabela, escolha **Items (Itens)** e selecione o item criado.
Os atributos armazenados são exibidos, alguns marcados como **CORROMPIDOS\$1**
## Etapa 3: desabilitar o problema simulado
1. Faça login no [console do AWS Lambda](https://console.aws.amazon.com/lambda/).
1. No painel de navegação, escolha **Functions (Funções)**.
1. Busque `serverlessrepo-fork-example` e escolha `CheckoutFunction`.
1. No **fork-example-ecommerce- *my-app* - CheckoutFunction -*ABCDEF*...** **página, na seção **Variáveis de ambiente**, defina a variável **BUG\$1ENABLED** **como falsa e escolha** Salvar.**
## Etapa 4: habilitar a repetição a fim de recuperar do problema
1. No AWS Lambda console, no painel de navegação, escolha **Funções**.
1. Busque `serverlessrepo-fork-example` e escolha `ReplayFunction`.
1. Expanda a seção **Designer**, escolha o bloco **SQS** e, na seção **SQS**, selecione **Habilitado**.
**nota**
Leva aproximadamente 1 minuto para que o acionador da origem de eventos do Amazon SQS seja habilitado.
1. Escolha **Salvar**.
1. Para visualizar os atributos recuperados, volte ao console do Amazon DynamoDB.
1. Para desativar a repetição, retorne ao AWS Lambda console e desative o gatilho de origem de eventos do Amazon SQS para. `ReplayFunction`
# Inscrevendo AWS Event Fork Pipelines em um tópico do Amazon SNS
Para acelerar o desenvolvimento de seus aplicativos orientados a eventos, você pode inscrever pipelines de tratamento de eventos — desenvolvidos pelo AWS Event Fork Pipelines — em tópicos do Amazon SNS. AWS O Event Fork Pipelines é um conjunto de [aplicativos aninhados](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-nested-applications.html) de código aberto, baseado no [AWS Serverless Application Model](https://aws.amazon.com/serverless/sam/) (AWS SAM), que você pode implantar diretamente do [pacote AWS Event Fork Pipelines](https://serverlessrepo.aws.amazon.com/applications?query=aws-event-fork-pipelines) (escolha **Mostrar aplicativos que criam funções personalizadas do IAM** ou políticas de recursos) em sua conta. AWS Para obter mais informações, consulte [Como funciona o AWS Event Fork Pipelines](sns-fork-pipeline-as-subscriber.md#how-sns-fork-works).
Esta seção mostra como você pode usar o Console de gerenciamento da AWS para implantar um pipeline e depois inscrever o AWS Event Fork Pipelines em um tópico do Amazon SNS. Antes de começar, [crie um tópico do Amazon SNS](sns-create-topic.md).
Para excluir os recursos que compõem um pipeline, localize o pipeline na página **Aplicativos** do AWS Lambda console, expanda a **seção de modelos do SAM**, escolha **CloudFormationpilha** e, em seguida, escolha **Outras ações**, **Excluir** pilha.
# Implantar e inscrever o pipeline de armazenamento e backup de eventos para o Amazon SNS
| |
| --- |
| Para arquivamento e análise de eventos, o Amazon SNS agora recomenda o uso de sua integração nativa com o Amazon Data Firehose. Você pode inscrever streams de entrega do Firehose em tópicos do SNS, o que permite enviar notificações para endpoints de arquivamento e análise, como buckets do Amazon Simple Storage Service (Amazon S3), tabelas do Amazon Redshift, Amazon Service (Service) e muito mais. OpenSearch OpenSearch Usar o Amazon SNS com os streams de entrega do Firehose é uma solução totalmente gerenciada e sem código que não exige o uso de funções. AWS Lambda Para obter mais informações, consulte [Fanout de fluxos de entrega do Firehose](sns-firehose-as-subscriber.md). |
Este tutorial mostra como implantar o [pipeline de armazenamento e backup de eventos](sns-fork-pipeline-as-subscriber.md#sns-fork-event-storage-and-backup-pipeline) e inscrevê-lo em um tópico do Amazon SNS. Esse processo transforma automaticamente o AWS SAM modelo associado ao pipeline em uma CloudFormation pilha e, em seguida, implanta a pilha na sua. Conta da AWS Esse processo também cria e configura o conjunto de recursos que compõe o pipeline de armazenamento e backup de eventos, incluindo o seguinte:
+ Fila do Amazon SQS
+ Função do Lambda
+ Fluxo de entrega do Firehose
+ Bucket de backup do Amazon S3
Para obter mais informações sobre como configurar um fluxo com um bucket do Amazon S3 como destino, consulte `[S3DestinationConfiguration](https://docs.aws.amazon.com/firehose/latest/APIReference/API_S3DestinationConfiguration.html)` na *Referência de API do Amazon Data Firehose*.
Para obter mais informações sobre como transformar eventos e configurar o armazenamento em buffer, a compactação e a criptografia de eventos, consulte [Criar um fluxo de entrega](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html) no *Guia do desenvolvedor do Amazon Data Firehose*.
Para obter mais informações sobre como filtrar eventos, consulte [Políticas de filtro de assinatura do Amazon SNS](sns-subscription-filter-policies.md) neste guia.
1. Faça login no [console do AWS Lambda](https://console.aws.amazon.com/lambda/).
1. No painel de navegação, escolha **Functions (Funções)** e selecione **Create function (Criar função)**.
1. Na página **Create function (Criar função)**, faça o seguinte:
1. Escolha **Browse serverless app repository** (Procurar no repositório de aplicações sem servidor), **Public applications** (Aplicações públicas), **Show apps that create custom IAM roles or resource policies** (Mostrar aplicações que criam funções do IAM ou políticas de recursos).
1. Procure `fork-event-storage-backup-pipeline` e escolha o aplicativo.
1. Na página **fork-event-storage-backup-pipeline**, faça o seguinte:
1. Na seção **Application settings (Configurações do aplicativo)**, insira um **Application name (Nome de aplicativo)** (por exemplo, `my-app-backup`).
**nota**
Para cada implantação, o nome do aplicativo deve ser exclusivo. Se você reutilizar o nome de um aplicativo, a implantação atualizará somente a CloudFormation pilha implantada anteriormente (em vez de criar uma nova).
1. (Opcional) Para **BucketArn**, insira o ARN do bucket do Amazon S3 no qual os eventos recebidos são carregados. Se você não inserir um valor, um novo bucket do Amazon S3 será criado em sua AWS conta.
1. (Opcional) Para **DataTransformationFunctionArn**, insira o ARN da função Lambda por meio da qual os eventos recebidos são transformados. Se você não inserir um valor, a transformação de dados será desativada.
1. (Opcional) Insira uma das seguintes **LogLevel**configurações para a execução da função Lambda do seu aplicativo:
+ `DEBUG`
+ `ERROR`
+ `INFO` (padrão)
+ `WARNING`
1. Para **TopicArn**, insira o ARN do tópico do Amazon SNS no qual essa instância do fork pipeline deve ser assinada.
1. (Opcional) **StreamBufferingSizeInMBs**Em **StreamBufferingIntervalInSeconds**e, insira os valores para configurar o armazenamento em buffer de eventos recebidos. Se nenhum valor for inserido, são usados 300 segundos e 5 MB.
1. (Opcional) Insira uma das seguintes **StreamCompressionFormat**configurações para compactar eventos recebidos:
+ `GZIP`
+ `SNAPPY`
+ `UNCOMPRESSED` (padrão)
+ `ZIP`
1. (Opcional) Para **StreamPrefix**, insira o prefixo da string para nomear os arquivos armazenados no bucket de backup do Amazon S3. Se você não inserir um valor, nenhum prefixo será usado.
1. (Opcional) Para **SubscriptionFilterPolicy**, insira a política de filtro de assinatura do Amazon SNS, no formato JSON, a ser usada para filtrar eventos recebidos. A política de filtro decide quais eventos são indexados no índice OpenSearch de serviços. Se nenhum valor for inserido, nenhuma filtragem será usada (todos os eventos serão indexados).
1. (Opcional) Para **SubscriptionFilterPolicyScope**, insira a string `MessageBody` ou habilite `MessageAttributes` a filtragem de mensagens baseada em carga ou atributo.
1. Escolha **I acknowledge that this app creates custom IAM roles, resource policies and deploys nested applications. (Eu reconheço que este aplicativo cria funções personalizadas do IAM, políticas de recursos e implanta aplicativos aninhados.)** e selecione **Deploy (Implantar)**.
Na *my-app* página **Status de implantação para**, o Lambda exibe o status **Seu aplicativo está sendo implantado**.
Na seção **Recursos**, CloudFormation começa a criar a pilha e exibe o status **CREATE\$1IN\$1PROGRESS** de cada recurso. Quando o processo estiver concluído, CloudFormation exibirá o status **CREATE\$1COMPLETE**.
Quando a implantação for concluída, o Lambda exibirá o status **Your application has been deployed** (Sua aplicação foi implantada).
As mensagens publicadas em seu tópico do Amazon SNS são armazenadas no bucket de backup do Amazon S3 provisionado pelo pipeline de armazenamento e backup de eventos automaticamente.
# Implantar e inscrever o pipeline de pesquisa e análise de eventos para o Amazon SNS
| |
| --- |
| Para arquivamento e análise de eventos, o Amazon SNS agora recomenda o uso de sua integração nativa com o Amazon Data Firehose. Você pode inscrever streams de entrega do Firehose em tópicos do SNS, o que permite enviar notificações para endpoints de arquivamento e análise, como buckets do Amazon Simple Storage Service (Amazon S3), tabelas do Amazon Redshift, Amazon Service (Service) e muito mais. OpenSearch OpenSearch Usar o Amazon SNS com os streams de entrega do Firehose é uma solução totalmente gerenciada e sem código que não exige o uso de funções. AWS Lambda Para obter mais informações, consulte [Fanout de fluxos de entrega do Firehose](sns-firehose-as-subscriber.md). |
Esta página mostra como implantar o [pipeline de pesquisa e análise de eventos](sns-fork-pipeline-as-subscriber.md#sns-fork-event-search-and-analytics-pipeline) e inscrevê-lo em um tópico do Amazon SNS. Esse processo transforma automaticamente o AWS SAM modelo associado ao pipeline em uma CloudFormation pilha e, em seguida, implanta a pilha na sua. Conta da AWS Esse processo também cria e configura o conjunto de recursos que compõe o pipeline de pesquisa e análise de eventos, incluindo o seguinte:
+ Fila do Amazon SQS
+ Função do Lambda
+ Fluxo de entrega do Firehose
+ Domínio do Amazon OpenSearch Service
+ Bucket de mensagens mortas do Amazon S3
Para obter mais informações sobre como configurar um fluxo com um índice como um destino, consulte `[ElasticsearchDestinationConfiguration](https://docs.aws.amazon.com/firehose/latest/APIReference/API_ElasticsearchDestinationConfiguration.html)` na *Referência de API do Amazon Data Firehose*.
Para obter mais informações sobre como transformar eventos e configurar o armazenamento em buffer, a compactação e a criptografia de eventos, consulte [Criar um fluxo de entrega](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html) no *Guia do desenvolvedor do Amazon Data Firehose*.
Para obter mais informações sobre como filtrar eventos, consulte [Políticas de filtro de assinatura do Amazon SNS](sns-subscription-filter-policies.md) neste guia.
1. Faça login no [console do AWS Lambda](https://console.aws.amazon.com/lambda/).
1. No painel de navegação, escolha **Functions (Funções)** e selecione **Create function (Criar função)**.
1. Na página **Create function (Criar função)**, faça o seguinte:
1. Escolha **Browse serverless app repository** (Procurar no repositório de aplicações sem servidor), **Public applications** (Aplicações públicas), **Show apps that create custom IAM roles or resource policies** (Mostrar aplicações que criam funções do IAM ou políticas de recursos).
1. Procure `fork-event-search-analytics-pipeline` e escolha o aplicativo.
1. Na página **fork-event-search-analytics-pipeline**, faça o seguinte:
1. Na seção **Application settings (Configurações do aplicativo)**, insira um **Application name (Nome de aplicativo)** (por exemplo, `my-app-search`).
**nota**
Para cada implantação, o nome do aplicativo deve ser exclusivo. Se você reutilizar o nome de um aplicativo, a implantação atualizará somente a CloudFormation pilha implantada anteriormente (em vez de criar uma nova).
1. (Opcional) Para **DataTransformationFunctionArn**, insira o ARN da função Lambda usada para transformar eventos recebidos. Se você não inserir um valor, a transformação de dados será desativada.
1. (Opcional) Insira uma das seguintes **LogLevel**configurações para a execução da função Lambda do seu aplicativo:
+ `DEBUG`
+ `ERROR`
+ `INFO` (padrão)
+ `WARNING`
1. (Opcional) Em **SearchDomainArn**, insira o ARN do domínio de OpenSearch serviço, um cluster que configura a funcionalidade necessária de computação e armazenamento. Se você não inserir um valor, um novo domínio será criado com a configuração padrão.
1. Para **TopicArn**, insira o ARN do tópico do Amazon SNS no qual essa instância do fork pipeline deve ser assinada.
1. Para **SearchIndexName**, insira o nome do índice de OpenSearch serviços para pesquisa e análise de eventos.
**nota**
As seguintes cotas se aplicam a nomes de índice:
Não é possível incluir letras maiúsculas
Não é possível incluir os seguintes caracteres: `\ / * ? " < > | ` , #`
Não é possível começar com os seguintes caracteres: `- + _`
Não podem ser o seguinte: `. ..`
Não podem ter mais que 80 caracteres
Não podem ter mais que 255 bytes
Não é possível conter dois pontos (do OpenSearch Serviço 7.0)
1. (Opcional) Insira uma das seguintes **SearchIndexRotationPeriod**configurações para o período de rotação do índice de OpenSearch serviços:
+ `NoRotation` (padrão)
+ `OneDay`
+ `OneHour`
+ `OneMonth`
+ `OneWeek`
A rotação de índice anexa um timestamp ao nome do índice, facilitando a expiração de dados antigos.
1. Para **SearchTypeName**, insira o nome do tipo de OpenSearch serviço para organizar os eventos em um índice.
**nota**
OpenSearch Os nomes dos tipos de serviço podem conter qualquer caractere (exceto bytes nulos), mas não podem começar com `_` eles.
Para o OpenSearch Service 6.x, só pode haver um tipo por índice. Se você especificar um novo tipo para um índice existente que já tem outro tipo, o Firehose retornará um erro runtime.
1. (Opcional) **StreamBufferingSizeInMBs**Em **StreamBufferingIntervalInSeconds**e, insira os valores para configurar o armazenamento em buffer de eventos recebidos. Se nenhum valor for inserido, são usados 300 segundos e 5 MB.
1. (Opcional) Insira uma das seguintes **StreamCompressionFormat**configurações para compactar eventos recebidos:
+ `GZIP`
+ `SNAPPY`
+ `UNCOMPRESSED` (padrão)
+ `ZIP`
1. (Opcional) Para **StreamPrefix**, insira o prefixo da string para nomear os arquivos armazenados no bucket de cartas mortas do Amazon S3. Se você não inserir um valor, nenhum prefixo será usado.
1. (Opcional) Para **StreamRetryDurationInSecons**, insira a duração da nova tentativa para casos em que o Firehose não consegue indexar eventos OpenSearch no índice de serviços. Se você não inserir um valor, será usado 300 segundos.
1. (Opcional) Para **SubscriptionFilterPolicy**, insira a política de filtro de assinatura do Amazon SNS, no formato JSON, a ser usada para filtrar eventos recebidos. A política de filtro decide quais eventos são indexados no índice OpenSearch de serviços. Se nenhum valor for inserido, nenhuma filtragem será usada (todos os eventos serão indexados).
1. Escolha **I acknowledge that this app creates custom IAM roles, resource policies and deploys nested applications. (Eu reconheço que este aplicativo cria funções personalizadas do IAM, políticas de recursos e implanta aplicativos aninhados.)** e selecione **Deploy (Implantar)**.
Na *my-app-search* página **Status de implantação para**, o Lambda exibe o status **Seu aplicativo está sendo implantado**.
Na seção **Recursos**, CloudFormation começa a criar a pilha e exibe o status **CREATE\$1IN\$1PROGRESS** de cada recurso. Quando o processo estiver concluído, CloudFormation exibirá o status **CREATE\$1COMPLETE**.
Quando a implantação for concluída, o Lambda exibirá o status **Your application has been deployed** (Sua aplicação foi implantada).
As mensagens publicadas em seu tópico do Amazon SNS são indexadas automaticamente no índice de OpenSearch serviços provisionado pelo pipeline de pesquisa e análise de eventos. Se o pipeline não puder indexar um evento, ele armazenará em um bucket de mensagens não entregues do Amazon S3.
# Implantação do Event Replay Pipeline com a integração do Amazon SNS
Esta página mostra como implantar o [pipeline de repetição de eventos](sns-fork-pipeline-as-subscriber.md#sns-fork-event-replay-pipeline) e inscrevê-lo em um tópico do Amazon SNS. Esse processo transforma automaticamente o AWS SAM modelo associado ao pipeline em uma CloudFormation pilha e, em seguida, implanta a pilha na sua. Conta da AWS Esse processo também cria e configura o conjunto de recursos que compõe o pipeline de repetição de eventos, incluindo uma fila do Amazon SQS e uma função do Lambda.
Para obter mais informações sobre como filtrar eventos, consulte [Políticas de filtro de assinatura do Amazon SNS](sns-subscription-filter-policies.md) neste guia.
1. Faça login no [console do AWS Lambda](https://console.aws.amazon.com/lambda/).
1. No painel de navegação, escolha **Functions (Funções)** e selecione **Create function (Criar função)**.
1. Na página **Create function (Criar função)**, faça o seguinte:
1. Escolha **Browse serverless app repository** (Procurar no repositório de aplicações sem servidor), **Public applications** (Aplicações públicas), **Show apps that create custom IAM roles or resource policies** (Mostrar aplicações que criam funções do IAM ou políticas de recursos).
1. Procure `fork-event-replay-pipeline` e escolha o aplicativo.
1. Na página **fork-event-replay-pipeline**, faça o seguinte:
1. Na seção **Application settings (Configurações do aplicativo)**, insira um **Application name (Nome de aplicativo)** (por exemplo, `my-app-replay`).
**nota**
Para cada implantação, o nome do aplicativo deve ser exclusivo. Se você reutilizar o nome de um aplicativo, a implantação atualizará somente a CloudFormation pilha implantada anteriormente (em vez de criar uma nova).
1. (Opcional) Insira uma das seguintes **LogLevel**configurações para a execução da função Lambda do seu aplicativo:
+ `DEBUG`
+ `ERROR`
+ `INFO` (padrão)
+ `WARNING`
1. (Opcional) Para **ReplayQueueRetentionPeriodInSeconds**, insira o tempo, em segundos, durante o qual a fila de repetição do Amazon SQS mantém a mensagem. Se você não inserir um valor, será usado 1.209.600 segundos (14 dias).
1. Para **TopicArn**, insira o ARN do tópico do Amazon SNS no qual essa instância do fork pipeline deve ser assinada.
1. Para **DestinationQueueName**, insira o nome da fila do Amazon SQS para a qual a função de reprodução do Lambda encaminha as mensagens.
1. (Opcional) Para **SubscriptionFilterPolicy**, insira a política de filtro de assinatura do Amazon SNS, no formato JSON, a ser usada para filtrar eventos recebidos. A política de filtro decide quais eventos serão armazenados em buffer para repetição. Se nenhum valor for inserido, nenhuma filtragem será usada (todos os eventos serão armazenados em buffer).
1. Escolha **I acknowledge that this app creates custom IAM roles, resource policies and deploys nested applications. (Eu reconheço que este aplicativo cria funções personalizadas do IAM, políticas de recursos e implanta aplicativos aninhados.)** e selecione **Deploy (Implantar)**.
Na *my-app-replay* página **Status de implantação para**, o Lambda exibe o status **Seu aplicativo está sendo implantado**.
Na seção **Recursos**, CloudFormation começa a criar a pilha e exibe o status **CREATE\$1IN\$1PROGRESS** de cada recurso. Quando o processo estiver concluído, CloudFormation exibirá o status **CREATE\$1COMPLETE**.
Quando a implantação for concluída, o Lambda exibirá o status **Your application has been deployed** (Sua aplicação foi implantada).
As mensagens publicadas em seu tópico do Amazon SNS são armazenadas em buffer para repetição na fila do Amazon SQS provisionada pelo pipeline de repetição de eventos automaticamente.
**nota**
Por padrão, a repetição está desabilitada. Para habilitar a repetição, navegue até a página da função no console do Lambda, expanda a seção **Designer**, escolha o bloco **SQS** e, na seção **SQS**, escolha **Enabled** (Habilitado).
# Usando o Amazon EventBridge Scheduler com o Amazon SNS
[O Amazon EventBridge Scheduler](https://docs.aws.amazon.com/scheduler/latest/UserGuide/what-is-scheduler.html) é um programador sem servidor que permite criar, executar e gerenciar tarefas a partir de um serviço gerenciado central. Com o EventBridge Scheduler, você pode criar agendas usando Cron e classificar expressões para padrões recorrentes ou configurar invocações únicas. Você pode configurar janelas de tempo flexíveis para entregas, definir limites de novas tentativas e o tempo máximo de retenção de invocações de API com falha.
Esta página explica como usar o EventBridge Scheduler para publicar uma mensagem de um tópico do Amazon SNS em uma programação.
## Configurar o perfil de execução
Quando você cria um novo EventBridge agendamento, o Scheduler deve ter permissão para invocar sua operação de API de destino em seu nome. Você concede essas permissões ao EventBridge Scheduler usando uma *função de execução*. A política de permissão que você anexa ao perfil de execução da programação define as permissões necessárias. Essas permissões dependem da API de destino que você deseja que o EventBridge Scheduler invoque.
Quando você usa o console do EventBridge Scheduler para criar um agendamento, como no procedimento a seguir, o EventBridge Scheduler configura automaticamente uma função de execução com base no destino selecionado. Se você quiser criar um EventBridge agendamento usando um dos Agendadores, o, ou SDKs AWS CLI CloudFormation, você deve ter uma função de execução existente que conceda as permissões que o EventBridge Agendador exige para invocar um alvo. *Para obter mais informações sobre como configurar manualmente uma função de execução para sua agenda, consulte [Configurando uma função de execução no Guia do](https://docs.aws.amazon.com/scheduler/latest/UserGuide/setting-up.html#setting-up-execution-role) usuário do EventBridge Scheduler.*
## Criar uma programação
**Para criar uma programação usando o console**
1. Abra o console do Amazon EventBridge Scheduler em [https://console.aws.amazon.com/scheduler/casa](https://console.aws.amazon.com/scheduler/home/).
1. Na página **Programações**, clique em **Criar programação**.
1. Na página **Especificar detalhes da programação**, na seção **Nome e descrição da programação**, faça o seguinte:
1. Em **Nome da programação**, insira um nome para a programação. Por exemplo, .**MyTestSchedule**
1. (Opcional) Em **Descrição**, insira a descrição da programação. Por exemplo, .**My first schedule**
1. Em **Grupo de programação**, escolha um grupo de programação na lista suspensa. Se você não tiver um grupo, escolha **padrão**. Para criar um grupo de programação, escolha **criar sua própria programação**.
Para adicionar tags a grupos de programação, você usa os grupos de programação.
1.
1. Escolha as opções de programação.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sns/latest/dg/using-eventbridge-scheduler.html)
1. (Opcional) Se você escolher **Programação recorrente** na etapa anterior, na seção **Período**, faça o seguinte:
1. Em **Fuso horário**, escolha um fuso horário.
1. Em **Data e hora de início**, insira uma data válida no formato `YYYY/MM/DD` e, em seguida, especifique um carimbo de data/hora no formato de 24 horas `hh:mm`.
1. Para **Data e hora de término**, insira uma data válida no formato `YYYY/MM/DD` e, em seguida, especifique um carimbo de data/hora no formato 24 horas `hh:mm`.
1. Escolha **Próximo**.
1. Na página **Selecionar destino**, escolha a operação de AWS API que o EventBridge Scheduler invoca:
1. Selecione **Publicação do Amazon SNS**.
1. Na seção **Publicar**, selecione um tópico do SNS ou escolha **Criar novo tópico do SNS**.
1. (Opcional) Insira uma carga útil JSON. Se você não inserir uma carga, o EventBridge Scheduler usará um evento vazio para invocar a função.
1. Escolha **Próximo**.
1. Na página **Configurações**, faça o seguinte:
1. Para ativar a programação, em **Estado da programação**, mude para **Ativar programação**.
1. Para configurar uma política de novas tentativas para a programação, em **Política de novas tentativas e fila de mensagens não entregues (DLQ)**, faça o seguinte:
+ Mude para **Tentar novamente**.
+ Em **Idade máxima do evento**, insira o (s) máximo (s) de **hora (s)** e **minuto (s)** em que o EventBridge Agendador deve manter um evento não processado.
+ O período máximo é de 24 horas.
+ Em **Máximo de tentativas**, insira o número máximo de vezes que o EventBridge Scheduler repete o agendamento se o alvo retornar um erro.
O valor máximo é 185 tentativas.
Com as políticas de repetição, se um agendamento falhar em invocar seu destino, o EventBridge Scheduler executará novamente o agendamento. Se configurado, você deve definir o tempo máximo de retenção e as novas tentativas da programação.
1. Escolha onde o EventBridge Scheduler armazena os eventos não entregues.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sns/latest/dg/using-eventbridge-scheduler.html)
1. Para usar uma chave gerenciada pelo cliente para criptografar a entrada de destino, em **Criptografia**, escolha **Personalizar as configurações de criptografia (avançado)**.
Se você escolher essa opção, insira o ARN da chave do KMS existente ou escolha **Criar AWS KMS key** para navegar até o console do AWS KMS . Para obter mais informações sobre como o EventBridge Scheduler criptografa seus dados em repouso, consulte [Criptografia em repouso no Guia](https://docs.aws.amazon.com/scheduler/latest/UserGuide/encryption-rest.html) do usuário do *Amazon EventBridge Scheduler*.
1. Para que o EventBridge Scheduler crie uma nova função de execução para você, escolha **Criar nova função para esta agenda**. Depois, insira um nome em **Nome do perfil**. Se você escolher essa opção, o EventBridge Scheduler anexará as permissões necessárias para seu alvo modelado à função.
1. Escolha **Próximo**.
1. Na página **Revisar e criar programação**, revise os detalhes da programação. Em cada seção, escolha **Editar** para voltar a essa etapa e editar seus detalhes.
1. Clique em **Criar programação**.
Você pode ver a lista com as programações novas e existentes na página **Programações**. Na coluna **Status**, verifique se a nova programação está **Ativada**.
## Recursos relacionados
Para obter mais informações sobre o EventBridge Scheduler, consulte o seguinte:
+ [EventBridge Guia do usuário do Scheduler](https://docs.aws.amazon.com/scheduler/latest/UserGuide/what-is-scheduler.html)
+ [EventBridge Referência da API Scheduler](https://docs.aws.amazon.com/scheduler/latest/APIReference/Welcome.html)
+ [EventBridge Preços do Scheduler](https://aws.amazon.com/eventbridge/pricing/#Scheduler)