Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Fanout degli eventi Amazon SNS su Event Fork AWS Pipelines
| |
| --- |
| Per l'archiviazione e l'analisi degli eventi, Amazon SNS ora consiglia di utilizzare la sua integrazione nativa con Amazon Data Firehose. Puoi abbonare i flussi di distribuzione Firehose agli argomenti SNS, il che ti consente di inviare notifiche a endpoint di archiviazione e analisi come i bucket Amazon Simple Storage Service (Amazon S3), le tabelle Amazon Redshift, Amazon Service (Service) e altro ancora. OpenSearch OpenSearch L'uso di Amazon SNS con i flussi di distribuzione Firehose è una soluzione completamente gestita e priva di codice che non richiede l'utilizzo di funzioni. AWS Lambda Per ulteriori informazioni, consulta [Flussi di distribuzione da Fanout a Firehose](sns-firehose-as-subscriber.md). |
È possibile utilizzare Amazon SNS per creare applicazioni basate su eventi che utilizzano i servizi del sottoscrittore per eseguire automaticamente il lavoro in risposta a eventi attivati dai servizi del publisher. Questo modello di architettura può rendere i servizi più riutilizzabili, interoperabili e scalabili. Tuttavia, può essere impegnativo eseguire il forking dell'elaborazione di eventi in pipeline rivolte ai requisiti di gestione di eventi comuni, come l’archiviazione, il backup, la ricerca, l'analisi dei dati e la riproduzione.
Per accelerare lo sviluppo delle tue applicazioni basate sugli eventi, puoi sottoscrivere pipeline di gestione degli eventi, basate su AWS Event Fork Pipelines, agli argomenti di Amazon SNS. AWS **Event Fork Pipelines è una suite di applicazioni [annidate open source, basata sul AWS Serverless Application](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-nested-applications.html) [Model](https://aws.amazon.com/serverless/sam/) (AWS SAM), che puoi distribuire direttamente dalla suite [AWS Event](https://serverlessrepo.aws.amazon.com/applications?query=aws-event-fork-pipelines) Fork Pipelines (scegli Show apps that create IAM role o policy di risorse personalizzate) nel tuo account.** AWS
Per un AWS caso d'uso di Event Fork Pipelines, vedi. [Implementazione e test dell'applicazione di esempio Amazon SNS Event Fork Pipeline](sns-deploy-test-fork-pipelines-sample-application.md)
**Topics**
+ [Come funziona AWS Event Fork Pipelines](#how-sns-fork-works)
+ [Distribuzione di Event Fork AWS Pipelines](#deploying-sns-fork-pipelines)
+ [Implementazione e test dell'applicazione di esempio Amazon SNS Event Fork Pipeline](sns-deploy-test-fork-pipelines-sample-application.md)
+ [Sottoscrizione di AWS Event Fork Pipelines a un argomento di Amazon SNS](sns-subscribe-event-fork-pipelines.md)
## Come funziona AWS Event Fork Pipelines
AWS Event Fork Pipelines è un modello di progettazione senza server. Tuttavia, è anche una suite di applicazioni serverless annidate basate su AWS SAM (che potete implementare direttamente da (AWS SAR) alle vostre piattaforme per AWS Serverless Application Repository arricchire le vostre piattaforme basate sugli Account AWS eventi). È possibile distribuire queste applicazioni nidificate individualmente, come richiesto dall'architettura.
**Topics**
+ [La pipeline di archiviazione di eventi e di backup](#sns-fork-event-storage-and-backup-pipeline)
+ [La pipeline di ricerca di eventi e di analisi dei dati](#sns-fork-event-search-and-analytics-pipeline)
+ [Pipeline di riproduzione eventi](#sns-fork-event-replay-pipeline)
Il diagramma seguente mostra un'applicazione AWS Event Fork Pipelines integrata da tre applicazioni annidate. È possibile distribuire qualsiasi pipeline della suite AWS Event Fork Pipelines sul SAR in modo indipendente, come richiesto dall'architettura. AWS
![\[L'architettura AWS Event Fork Pipelines, che mostra come gli eventi di un argomento di Amazon SNS vengono filtrati ed elaborati attraverso tre pipeline distinte: Event Storage and Backup, Event Search and Analytics ed Event Replay. Queste pipeline sono rappresentate come scatole impilate verticalmente, ciascuna delle quali elabora in modo indipendente eventi in parallelo sullo stesso argomento di Amazon SNS.\]](http://docs.aws.amazon.com/it_it/sns/latest/dg/images/sns-fork-pipeline-as-subscriber-how-it-works.png)
Ogni pipeline è sottoscritta allo stesso argomento Amazon SNS, facendo così in modo di elaborare eventi non appena vengono pubblicati nell'argomento. Ogni pipeline è indipendente ed è in grado di impostare la propria [Policy di filtro per le sottoscrizioni](sns-subscription-filter-policies.md). In questo modo una pipeline può elaborare solo un sottoinsieme di eventi a cui è interessata (invece che tutti gli eventi pubblicati nell'argomento).
**Nota**
Poiché colloca le tre AWS Event Fork Pipeline insieme alle normali pipeline di elaborazione degli eventi (probabilmente già iscritto al tuo argomento Amazon SNS), non è necessario modificare alcuna parte del tuo attuale editore di messaggi per sfruttare AWS Event Fork Pipelines nei tuoi carichi di lavoro esistenti.
### La pipeline di archiviazione di eventi e di backup
Il seguente diagramma mostra la [Pipeline di archiviazione di eventi e di backup](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~fork-event-storage-backup-pipeline). Puoi sottoscrivere questa pipeline al tuo argomento Amazon SNS per eseguire il backup automatico degli eventi che scorrono nel sistema.
Questa pipeline è composta da una coda Amazon SQS che memorizza nel buffer gli eventi forniti dall'argomento Amazon SNS, AWS Lambda una funzione che esegue automaticamente il polling di questi eventi nella coda e li inserisce in un flusso e un bucket Amazon S3 che esegue il backup durevole degli eventi caricati dallo stream.
![\[La Fork-Event-Storage-Backup -Pipeline, progettata per elaborare ed eseguire il backup di eventi da un argomento di Amazon SNS. Il flusso inizia con un argomento di Amazon SNS da cui gli eventi vengono trasferiti a ventaglio in una coda Amazon SQS. Questi eventi filtrati vengono quindi elaborati da una funzione Lambda, che li inoltra a un Data Firehose. Lo stream Firehose è responsabile del buffering, della trasformazione e della compressione degli eventi prima di caricarli in un bucket di backup Amazon S3. Infine, Amazon Athena può essere usato per interrogare i dati memorizzati. Il diagramma utilizza una serie di icone e frecce per illustrare il flusso da un servizio all'altro, etichettando chiaramente ogni componente della pipeline.\]](http://docs.aws.amazon.com/it_it/sns/latest/dg/images/sns-fork-event-storage-and-backup-pipeline.png)
Per affinare il comportamento del flusso Firehose, puoi configurarlo in modo che trasformi, comprima ed esegua il buffering degli eventi prima di caricarli nel bucket. Man mano che gli eventi vengono caricati, puoi utilizzare Amazon Athena per eseguire query sul bucket utilizzando query SQL standard. Puoi anche configurare la pipeline in modo che riutilizzi un bucket Amazon S3 esistente o ne crei uno nuovo.
### La pipeline di ricerca di eventi e di analisi dei dati
Il seguente diagramma mostra la [Pipeline di ricerca di eventi e di analisi dei dati](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~fork-event-search-analytics-pipeline). Puoi sottoscrivere questa pipeline al tuo argomento Amazon SNS per indicizzare gli eventi che scorrono nel sistema in un dominio di ricerca e per eseguirvi le analisi dei dati.
Questa pipeline è composta da una coda Amazon SQS che memorizza nel buffer gli eventi forniti dall'argomento Amazon SNS, AWS Lambda una funzione che analizza gli eventi dalla coda e li inserisce in un flusso, un dominio Amazon OpenSearch Service che indicizza gli eventi caricati dal flusso Firehose e un bucket Amazon S3 che memorizza gli eventi non indicizzabili in il dominio di ricerca.
![\[La pipeline di ricerca e analisi degli eventi all'interno di un' AWS architettura. Inizia a sinistra con l'argomento Amazon SNS che riceve tutti gli eventi. Questi eventi vengono quindi incanalati attraverso una linea tratteggiata che rappresenta «eventi filtrati a ventaglio» in una coda Amazon SQS. Dalla coda, gli eventi vengono elaborati da una funzione Lambda che poi li inoltra a un flusso Data Firehose. Data Firehose indirizza gli eventi in due destinazioni: una route conduce a un Amazon Elasticsearch Service per l'indicizzazione e l'altra invia eventi non elaborabili o «dead-letter» a un bucket di lettere morte di Amazon S3. All'estrema destra, l'output di Elasticsearch Service viene inserito in una dashboard di Kibana per l'analisi e la visualizzazione. L'intero flusso è disposto orizzontalmente e ogni componente è collegato da linee che mostrano la direzione del flusso di dati.\]](http://docs.aws.amazon.com/it_it/sns/latest/dg/images/sns-fork-event-search-and-analytics-pipeline.png)
Per affinare il flusso Firehose in termini di buffering, trasformazione e compressione degli eventi, puoi configurare questa pipeline.
Puoi anche configurare se la pipeline deve riutilizzare un OpenSearch dominio esistente nel tuo dominio Account AWS o crearne uno nuovo per te. Man mano che gli eventi vengono indicizzati nel dominio di ricerca, puoi utilizzare Kibana per eseguire l’analisi dei dati sugli eventi e aggiornare i pannelli di controllo visivi in tempo reale.
### Pipeline di riproduzione eventi
Il seguente diagramma mostra la [Pipeline di riproduzione eventi](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~fork-event-replay-pipeline). Per registrare gli eventi elaborati dal sistema negli ultimi 14 giorni (ad esempio quando la piattaforma deve essere ripristinata in seguito a un guasto), puoi sottoscrivere questa pipeline all'argomento Amazon SNS e rielaborare gli eventi.
Questa pipeline è composta da una coda Amazon SQS che memorizza nel buffer gli eventi forniti dall'argomento Amazon SNS e da AWS Lambda una funzione che analizza gli eventi dalla coda e li reindirizza nella normale pipeline di elaborazione degli eventi, anch'essa associata al tuo argomento.
![\[La Event Replay Pipeline in formato diagramma di flusso. Da sinistra a destra, inizia con un argomento di Amazon SNS che distribuisce gli eventi filtrati a due processi paralleli. Il flusso superiore rappresenta la normale pipeline di elaborazione degli eventi, che include una coda Amazon SQS che elabora gli eventi. Il flusso inferiore, denominato "»fork-event-replay-pipeline, include una coda di replay Amazon SQS in cui gli eventi vengono temporaneamente archiviati prima di essere elaborati da una funzione di replay Lambda. Questa funzione Lambda ha la capacità di reindirizzare gli eventi nella normale pipeline di elaborazione degli eventi o di conservarli per la riproduzione, a seconda che la funzione di replay sia abilitata o disabilitata. Il diagramma indica anche che gli operatori hanno il controllo sull'attivazione o la disabilitazione della funzionalità di riproduzione degli eventi.\]](http://docs.aws.amazon.com/it_it/sns/latest/dg/images/sns-fork-event-replay-pipeline.png)
**Nota**
Per impostazione predefinita, la funzione di riproduzione è disattivata e gli eventi non vengono reindirizzati. Se devi rielaborare gli eventi, devi abilitare la coda di riproduzione Amazon SQS come origine dell'evento per la funzione di riproduzione AWS Lambda .
## Distribuzione di Event Fork AWS Pipelines
[La [suite AWS Event Fork Pipelines](https://serverlessrepo.aws.amazon.com/applications?query=aws-event-fork-pipelines) (scegli **Show apps that create IAM roles or resource policy personalizzate**) è disponibile come gruppo di applicazioni pubbliche in AWS Serverless Application Repository, da cui è possibile distribuirle e testarle manualmente utilizzando la console.AWS Lambda](https://console.aws.amazon.com/lambda/) Per informazioni sulla distribuzione delle pipeline tramite la console, consulta. AWS Lambda [Sottoscrizione di AWS Event Fork Pipelines a un argomento di Amazon SNS](sns-subscribe-event-fork-pipelines.md)
In uno scenario di produzione, consigliamo di incorporare AWS Event Fork Pipelines nel modello SAM generale dell'applicazione. AWS La funzionalità di applicazione annidata consente di eseguire questa operazione aggiungendo la risorsa `[AWS::Serverless::Application](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template.html#serverless-sam-template-application)` al modello AWS SAM, facendo riferimento al AWS SAR `ApplicationId` e all'applicazione nidificata. `SemanticVersion`
Ad esempio, è possibile utilizzare Event Storage and Backup Pipeline come applicazione annidata aggiungendo il seguente frammento YAML alla sezione del `Resources` modello 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
```
Quando specificate i valori dei parametri, potete utilizzare le funzioni AWS CloudFormation intrinseche per fare riferimento ad altre risorse del modello. Ad esempio, nello snippet YAML riportato sopra, il `TopicArn` parametro fa riferimento alla `[AWS::SNS::Topic](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-sns-topic.html)` risorsa`MySNSTopic`, definita altrove nel modello. AWS SAM Per ulteriori informazioni, consulta la [Riferimento funzione intrinseca](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference.html) nella *AWS CloudFormation Guida per l’utente*.
**Nota**
La pagina della AWS Lambda console dell'applicazione AWS SAR include il pulsante **Copia come risorsa SAM, che copia** il codice YAML necessario per annidare un'applicazione SAR negli appunti. AWS
# Implementazione e test dell'applicazione di esempio Amazon SNS Event Fork Pipeline
Per accelerare lo sviluppo delle tue applicazioni basate sugli eventi, puoi sottoscrivere pipeline di gestione degli eventi, basate su AWS Event Fork Pipelines, agli argomenti di Amazon SNS. AWS **Event Fork Pipelines è una suite di applicazioni [annidate open source, basata sul AWS Serverless Application](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-nested-applications.html) [Model](https://aws.amazon.com/serverless/sam/) (AWS SAM), che puoi distribuire direttamente dalla suite [AWS Event](https://serverlessrepo.aws.amazon.com/applications?query=aws-event-fork-pipelines) Fork Pipelines (scegli Show apps that create IAM role o policy di risorse personalizzate) nel tuo account.** AWS Per ulteriori informazioni, consulta [Come funziona AWS Event Fork Pipelines](sns-fork-pipeline-as-subscriber.md#how-sns-fork-works).
Questa pagina mostra come utilizzare l'applicazione di esempio Event Fork Pipelines Console di gestione AWS per distribuire e testare l'applicazione di esempio. AWS
**Importante**
Per evitare di incorrere in costi indesiderati dopo aver completato la distribuzione dell'applicazione di esempio AWS Event Fork Pipelines, eliminate il relativo stack. CloudFormation Per ulteriori informazioni, vedi [Eliminazione di uno stack sulla console CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-delete-stack.html) nella *Guida per l'utente di AWS CloudFormation *.
# AWS Esempio di caso d'uso di Event Fork Pipelines
Lo scenario seguente descrive un'applicazione di e-commerce senza server e basata sugli eventi che utilizza AWS Event Fork Pipelines. È possibile utilizzare questo [esempio di applicazione di e-commerce](https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~fork-example-ecommerce-checkout-api) in AWS Serverless Application Repository e poi distribuirla Account AWS utilizzando la AWS Lambda console, dove è possibile testarla ed esaminarne il codice sorgente. GitHub
![\[L'architettura di un'applicazione di e-commerce serverless che si integra. Servizi AWS Descrive il flusso dagli utenti di e-commerce che effettuano ordini tramite un API Gateway a diverse pipeline di elaborazione tra cui archiviazione degli ordini, analisi di ricerca e replay, mostrando come gli eventi vengono gestiti e analizzati tramite Amazon SNS, Lambda, Amazon SQS, DynamoDB e Kibana.\]](http://docs.aws.amazon.com/it_it/sns/latest/dg/images/sns-fork-example-use-case.png)
Questa applicazione di e-commerce riceve gli ordini dagli acquirenti tramite un' RESTful API ospitata da API Gateway e supportata dalla AWS Lambda funzione`CheckoutApiBackendFunction`. La funzione pubblica tutti gli ordini ricevuti in un argomento Amazon SNS denominato `CheckoutEventsTopic` che, a sua volta, li distribuisce a quattro diverse pipeline.
La prima è la normale pipeline di elaborazione del checkout progettata e implementata dal proprietario dell'applicazione di E-Commerce. Questa pipeline include la `CheckoutQueue` coda Amazon SQS che memorizza nel buffer tutti gli ordini ricevuti, AWS Lambda una funzione `CheckoutFunction` denominata che esegue il polling della coda per elaborare questi ordini e la tabella DynamoDB che salva in modo sicuro tutti gli ordini effettuati. `CheckoutTable`
## Applicazione di Event Fork AWS Pipelines
La logica di business principale è gestita dai componenti dell'applicazione di E-Commerce, il cui proprietario deve comunque tenere conto anche dei seguenti fattori:
+ **Conformità**—backup protetti e compressi crittografati a riposo e sanificazione delle informazioni sensibili
+ **Resilienza**—riproduzione degli ordini più recenti in caso di interruzione del processo di evasione
+ **Searchability**—esecuzione di analisi e generazione di metriche sugli ordini effettuati
Invece di implementare questa logica di elaborazione degli eventi, il proprietario dell'applicazione può sottoscrivere AWS Event Fork Pipelines all'argomento Amazon `CheckoutEventsTopic` SNS
+ [La pipeline di archiviazione di eventi e di backup](sns-fork-pipeline-as-subscriber.md#sns-fork-event-storage-and-backup-pipeline) è configurata per trasformare i dati in modo da rimuovere i dettagli delle carte di credito, eseguire il buffer dei dati per 60 secondi, comprimerli usando GZIP e crittografarli tramite la chiave predefinita gestita dal cliente per Amazon S3. Questa chiave è gestita AWS e alimentata da (). AWS Key Management Service AWS KMS
Per ulteriori informazioni, consulta [Scegli Amazon S3 per la tua destinazione](https://docs.aws.amazon.com/firehose/latest/dev/create-destination.html#create-destination-s3), [Amazon Data Firehose Data Transformation e [Configure Settings nella](https://docs.aws.amazon.com/firehose/latest/dev/create-configure.html) Amazon *Data* Firehose](https://docs.aws.amazon.com/firehose/latest/dev/data-transformation.html) Developer Guide.
+ [La pipeline di ricerca di eventi e di analisi dei dati](sns-fork-pipeline-as-subscriber.md#sns-fork-event-search-and-analytics-pipeline) è configurata con un valore di 30 secondi per la durata dei nuovi tentativi di indice, un bucket per lo storage di ordini non indicizzati nel dominio di ricerca e una policy di filtro per limitare il set degli ordini indicizzati.
Per ulteriori informazioni, consulta [Scegli il OpenSearch servizio per la tua destinazione](https://docs.aws.amazon.com/firehose/latest/dev/create-destination.html#create-destination-elasticsearch) nella *Amazon Data Firehose Developer Guide*.
+ [Pipeline di riproduzione eventi](sns-fork-pipeline-as-subscriber.md#sns-fork-event-replay-pipeline) è configurata con la coda Amazon SQS che fa parte della normale pipeline di elaborazione degli ordini progettata e implementata dal proprietario dell'applicazione di E-Commerce.
Per ulteriori informazioni, consulta la sezione al [Nome della coda e URL](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-general-identifiers.html#queue-name-url) nella *Guida per gli sviluppatori di Amazon Simple Queue Service*.
Nella configurazione per la pipeline di ricerca di eventi e di analisi è impostata la seguente policy di filtro in formato JSON, che trova solo ordini in entrata il cui importo totale sia di 100 dollari o più. Per ulteriori informazioni, consulta [Filtraggio messaggi di Amazon SNS](sns-message-filtering.md).
```
{
"amount": [{ "numeric": [ ">=", 100 ] }]
}
```
Utilizzando il pattern AWS Event Fork Pipelines, il proprietario dell'applicazione di e-commerce può evitare il sovraccarico di sviluppo che spesso deriva dalla logica di codifica indifferenziata per la gestione degli eventi. Invece, può implementare AWS Event Fork Pipelines direttamente dal suo interno. AWS Serverless Application Repository Account AWS
# Fase 1: distribuzione dell'applicazione Amazon SNS di esempio
1. Accedi alla [console AWS Lambda](https://console.aws.amazon.com/lambda/).
1. Nel riquadro di navigazione, selezionare **Functions (Funzioni)** e quindi **Create function (Crea funzione)**.
1. Nella pagina **Create function (Crea funzione)**, procedere come segue:
1. Scegliere **Browse serverless app repository (Sfoglia repository app serverless)**, **Public applications (Applicazioni pubbliche)**, **Show apps that create custom IAM roles or resource policies (Mostra applicazioni in grado di creare ruoli IAM o policy di risorse personalizzati)**.
1. Cercare `fork-example-ecommerce-checkout-api` e scegliere l'applicazione.
1. Nella pagina **fork-example-ecommerce-checkout-api**, procedi come segue:
1. Nella sezione **Application settings (Impostazioni applicazione)**, immettere un **Application name (Nome applicazione)** (ad esempio `fork-example-ecommerce-my-app`).
**Nota**
Per trovare con facilità le risorse in un secondo momento, mantenere il prefisso `fork-example-ecommerce`.
Il nome dell'applicazione deve essere univoco per ogni distribuzione. Se riutilizzi il nome di un'applicazione, la distribuzione aggiornerà solo lo CloudFormation stack precedentemente distribuito (anziché crearne uno nuovo).
1. (Facoltativo) Immettete una delle seguenti **LogLevel**impostazioni per l'esecuzione della funzione Lambda dell'applicazione:
+ `DEBUG`
+ `ERROR`
+ `INFO` (predefinito)
+ `WARNING`
1. Scegliere **I acknowledge that this app creates custom IAM roles, resource policies and deploys nested applications. (Riconosco che questa app crea ruoli IAM e policy di risorse personalizzati e distribuisce applicazioni nidificate.)** e quindi, in fondo alla pagina, selezionare **Deploy (Distribuisci)**.
Nella *my-app* pagina **Stato di distribuzione per fork-example-ecommerce -**, Lambda visualizza lo stato L'**applicazione è in fase di distribuzione**.
Nella sezione **Risorse**, CloudFormation inizia a creare lo stack e visualizza lo stato **CREATE\$1IN\$1PROGRESS** per ogni risorsa. **Quando il processo è completo, visualizza lo stato CREATE\$1COMPLETE. CloudFormation **
**Nota**
La distribuzione di tutte le risorse può richiedere 20-30 minuti.
Al termine della distribuzione, Lambda mostra lo stato **Your application has been deployed (L'applicazione è stata distribuita)**.
# Fase 2: Esecuzione dell'applicazione di esempio collegata a SNS
1. Nella AWS Lambda console, nel pannello di navigazione, scegli **Applicazioni**.
1. Nel campo di ricerca della pagina **Applications (Applicazioni)**, cercare `serverlessrepo-fork-example-ecommerce-my-app` e quindi scegliere l'applicazione.
1. Nella sezione **Resources (Risorse)**, procedere come segue:
1. Per trovare la risorsa il cui tipo è **ApiGatewayRestApi**, ordina le risorse per **Tipo**, ad esempio`ServerlessRestApi`, e poi espandi la risorsa.
1. Vengono visualizzate due risorse annidate, di tipo **ApiGatewayDeployment** e **ApiGatewayStage**.
1. Copiare il link per **Prod API endpoint (Endpoint API prod)** e aggiungervi `/checkout`, ad esempio:
```
https://abcdefghij.execute-api.us-east-2.amazonaws.com/Prod/checkout
```
1. Copiare il JSON seguente in un file denominato `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. Per inviare una richiesta HTTPS al proprio endpoint API, passare il payload degli eventi di esempio come input eseguendo un comando `curl`, ad esempio:
```
curl -d "$(cat test_event.json)" https://abcdefghij.execute-api.us-east-2.amazonaws.com/Prod/checkout
```
L'API restituisce la seguente risposta vuota, a indicare che l'esecuzione è riuscita:
```
{ }
```
# Fase 3: verifica delle prestazioni dell'applicazione e della pipeline Amazon SNS
## Fase 1: verifica dell'esecuzione della pipeline di checkout di esempio
1. Accedi alla [console Amazon DynamoDB](https://console.aws.amazon.com/dynamodb/).
1. Nel riquadro di navigazione, selezionare **Tables (Tabelle)**.
1. Cercare `serverlessrepo-fork-example` e selezionare `CheckoutTable`.
1. Nella pagina dei dettagli della tabella, scegliere **Items (Voci)** e quindi scegliere la voce creata.
Vengono mostrati gli attributi memorizzati.
## Fase 2: Verifica dell'esecuzione della pipeline di archiviazione e backup degli eventi
1. Accedere alla [console Amazon S3](https://console.aws.amazon.com/s3/).
1. Nel riquadro di navigazione, scegliere **Buckets (Bucket)**.
1. Cercare `serverlessrepo-fork-example` e quindi selezionare `CheckoutBucket`.
1. Esaminare la gerarchia della directory fino a trovare un file con l'estensione `.gz`.
1. Per scaricare il file, scegliere prima **Actions (Azioni)** e poi **Open (Apri)**.
1. La pipeline è configurata con una funzione Lambda che sterilizza le informazioni sulle carte di credito per motivi di conformità.
Per verificare che il payload JSON archiviato non contenga informazioni sulle carte di credito, decomprimere il file.
## Fase 3: Verifica dell'esecuzione della pipeline di ricerca e analisi degli eventi
1. Accedi alla [console OpenSearch di servizio](https://console.aws.amazon.com/aos/).
1. Nel riquadro di navigazione, in **My domains (I miei domini)**, scegliere il dominio con prefisso `serverl-analyt`.
1. La pipeline viene configurata con una policy di filtro della sottoscrizione Amazon SNS che imposta una condizione di corrispondenza numerica.
****Per verificare che l'evento sia indicizzato perché si riferisce a un ordine il cui valore è superiore a 100 USD, nella *abcdefgh1ijk* pagina **serverl-analyt-**, scegli Indices, checkout\$1events.****
## Fase 4: Verifica dell'esecuzione della pipeline di riproduzione degli eventi
1. Accedere alla [console Amazon SQS](https://console.aws.amazon.com/sqs/).
1. Nell'elenco delle code, cercare `serverlessrepo-fork-example` e scegliere `ReplayQueue`.
1. Scegli **Invia e ricevi messaggi**.
1. Nella finestra di *123ABCD4E5F6* dialogo **Invia e ricevi messaggi in fork-example-ecommerce -*my-app*... ReplayP- ReplayQueue -**, scegli **Sondaggio** per i messaggi.
1. Per verificare che l'evento sia inserito nella coda, scegliere **More Details (Altri dettagli)** accanto al messaggio visualizzato nella coda.
# Fase 4: Simulazione di un problema e riproduzione degli eventi per il ripristino
## Passaggio 1: abilita il problema simulato e invia una seconda richiesta API
1. Accedi alla [console AWS Lambda](https://console.aws.amazon.com/lambda/).
1. Nel riquadro di navigazione, scegliere **Functions (Funzioni)**.
1. Cercare `serverlessrepo-fork-example` e selezionare `CheckoutFunction`.
1. Sul **fork-example-ecommerce- *my-app* - CheckoutFunction -*ABCDEF*...** **pagina, nella sezione **Variabili d'ambiente**, imposta la variabile **BUG\$1ENABLED** su **true**, quindi scegli Salva.**
1. Copiare il JSON seguente in un file denominato `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. Per inviare una richiesta HTTPS al proprio endpoint API, passare il payload degli eventi di esempio come input eseguendo un comando `curl`, ad esempio:
```
curl -d "$(cat test_event_2.json)" https://abcdefghij.execute-api.us-east-2.amazonaws.com/Prod/checkout
```
L'API restituisce la seguente risposta vuota, a indicare che l'esecuzione è riuscita:
```
{ }
```
## Fase 2: Verificare il danneggiamento simulato dei dati
1. Accedi alla [console Amazon DynamoDB](https://console.aws.amazon.com/dynamodb/).
1. Nel riquadro di navigazione, selezionare **Tables (Tabelle)**.
1. Cercare `serverlessrepo-fork-example` e selezionare `CheckoutTable`.
1. Nella pagina dei dettagli della tabella, scegliere **Items (Voci)** e quindi scegliere la voce creata.
Vengono visualizzati gli attributi archiviati, alcuni contrassegnati come **CORRUPTED\$1 (Danneggiati)**.
## Fase 3: Disattiva il problema simulato
1. Accedi alla [console AWS Lambda](https://console.aws.amazon.com/lambda/).
1. Nel riquadro di navigazione, scegliere **Functions (Funzioni)**.
1. Cercare `serverlessrepo-fork-example` e selezionare `CheckoutFunction`.
1. Sul **fork-example-ecommerce- - *my-app* CheckoutFunction - *ABCDEF***... **pagina, nella sezione **Variabili d'ambiente**, imposta la variabile **BUG\$1ENABLED** su **false** e poi scegli Salva.**
## Passaggio 4: abilita il replay per risolvere il problema
1. Nella AWS Lambda console, nel pannello di navigazione, scegli **Funzioni**.
1. Cercare `serverlessrepo-fork-example` e selezionare `ReplayFunction`.
1. Espandere la sezione **Designer**, scegliere il riquadro **SQS** e quindi, nella sezione **SQS**, scegliere **Enabled (Abilitato)**.
**Nota**
L'abilitazione del trigger dell'origine evento Amazon SQS richiede circa un minuto.
1. Seleziona **Salva**.
1. Per visualizzare gli attributi ripristinati, tornare alla console Amazon DynamoDB.
1. Per disabilitare la riproduzione, torna alla AWS Lambda console e disabilita il trigger sorgente di eventi Amazon SQS per. `ReplayFunction`
# Sottoscrizione di AWS Event Fork Pipelines a un argomento di Amazon SNS
Per accelerare lo sviluppo delle tue applicazioni basate sugli eventi, puoi sottoscrivere pipeline di gestione degli eventi, basate su AWS Event Fork Pipelines, agli argomenti di Amazon SNS. AWS **Event Fork Pipelines è una suite di applicazioni [annidate open source, basata sul AWS Serverless Application](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-nested-applications.html) [Model](https://aws.amazon.com/serverless/sam/) (AWS SAM), che puoi distribuire direttamente dalla suite [AWS Event](https://serverlessrepo.aws.amazon.com/applications?query=aws-event-fork-pipelines) Fork Pipelines (scegli Show apps that create IAM role o policy di risorse personalizzate) nel tuo account.** AWS Per ulteriori informazioni, consulta [Come funziona AWS Event Fork Pipelines](sns-fork-pipeline-as-subscriber.md#how-sns-fork-works).
Questa sezione mostra come utilizzare il Console di gestione AWS per distribuire una pipeline e quindi sottoscrivere AWS Event Fork Pipelines a un argomento di Amazon SNS. Prima di iniziare, [crea un argomento Amazon SNS](sns-create-topic.md).
****Per eliminare le risorse che compongono una pipeline, trova la pipeline nella pagina **Applicazioni** della AWS Lambda console, espandi la **sezione dei modelli SAM**, scegli stack, quindi scegli Altre azioni, Elimina **CloudFormationstack**.****
# Implementazione e sottoscrizione della Event Storage and Backup Pipeline su Amazon SNS
| |
| --- |
| Per l'archiviazione e l'analisi degli eventi, Amazon SNS ora consiglia di utilizzare la sua integrazione nativa con Amazon Data Firehose. Puoi abbonare i flussi di distribuzione Firehose agli argomenti SNS, il che ti consente di inviare notifiche a endpoint di archiviazione e analisi come i bucket Amazon Simple Storage Service (Amazon S3), le tabelle Amazon Redshift, Amazon Service (Service) e altro ancora. OpenSearch OpenSearch L'uso di Amazon SNS con i flussi di distribuzione Firehose è una soluzione completamente gestita e priva di codice che non richiede l'utilizzo di funzioni. AWS Lambda Per ulteriori informazioni, consulta [Flussi di distribuzione da Fanout a Firehose](sns-firehose-as-subscriber.md). |
Questo tutorial mostra come distribuire la [pipeline di storage di eventi e di backup](sns-fork-pipeline-as-subscriber.md#sns-fork-event-storage-and-backup-pipeline) e iscriverla a un argomento Amazon SNS. Questo processo trasforma automaticamente il AWS SAM modello associato alla pipeline in uno CloudFormation stack, quindi distribuisce lo stack nel tuo. Account AWS Il processo inoltre crea e configura il set di risorse che compongono la pipeline di storage di eventi e di backup, tra cui:
+ Coda Amazon SQS
+ funzione Lambda
+ Flussi di distribuzione Firehose
+ S3 backup bucket Amazon S3
Per ulteriori informazioni sulla configurazione di uno stream con un bucket Amazon S3 come destinazione, consulta *Amazon Data `[S3DestinationConfiguration](https://docs.aws.amazon.com/firehose/latest/APIReference/API_S3DestinationConfiguration.html)` Firehose* API Reference.
Per ulteriori informazioni sulla trasformazione degli eventi e sulla configurazione del buffering degli eventi, della compressione degli eventi e della crittografia degli eventi, consulta [Creating an Delivery Stream](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html) nella Amazon *Data Firehose* Developer Guide.
Per ulteriori informazioni su come filtrare gli eventi, consulta [Policy di filtro degli abbonamenti Amazon SNS](sns-subscription-filter-policies.md) in questa guida.
1. Accedi alla [console AWS Lambda](https://console.aws.amazon.com/lambda/).
1. Nel riquadro di navigazione, selezionare **Functions (Funzioni)** e quindi **Create function (Crea funzione)**.
1. Nella pagina **Create function (Crea funzione)**, procedere come segue:
1. Scegliere **Browse serverless app repository (Sfoglia repository app serverless)**, **Public applications (Applicazioni pubbliche)**, **Show apps that create custom IAM roles or resource policies (Mostra applicazioni in grado di creare ruoli IAM o policy di risorse personalizzati)**.
1. Cercare `fork-event-storage-backup-pipeline` e scegliere l'applicazione.
1. Nella pagina **fork-event-storage-backup-pipeline**, procedi come segue:
1. Nella sezione **Application settings (Impostazioni applicazione)**, immettere un **Application name (Nome applicazione)** (ad esempio `my-app-backup`).
**Nota**
Il nome dell'applicazione deve essere univoco per ogni distribuzione. Se riutilizzi il nome di un'applicazione, la distribuzione aggiornerà solo lo CloudFormation stack precedentemente distribuito (anziché crearne uno nuovo).
1. (Facoltativo) Per **BucketArn**, inserisci l'ARN del bucket Amazon S3 in cui vengono caricati gli eventi in entrata. Se non inserisci un valore, nel tuo account viene creato un nuovo bucket Amazon S3. AWS
1. (Facoltativo) Per **DataTransformationFunctionArn**, inserisci l'ARN della funzione Lambda attraverso la quale vengono trasformati gli eventi in entrata. In assenza di valori immessi, la trasformazione dei dati è disabilitata.
1. (Facoltativo) Immettete una delle seguenti **LogLevel**impostazioni per l'esecuzione della funzione Lambda dell'applicazione:
+ `DEBUG`
+ `ERROR`
+ `INFO` (predefinito)
+ `WARNING`
1. Per esempio **TopicArn**, inserisci l'ARN dell'argomento Amazon SNS a cui deve essere sottoscritta questa istanza della pipeline fork.
1. (Facoltativo) Per **StreamBufferingIntervalInSeconds**e **StreamBufferingSizeInMBs**, inserisci i valori per configurare il buffering degli eventi in arrivo. In assenza di valori immessi, vengono impostati 300 secondi e 5 MB.
1. (Facoltativo) Immettete una delle seguenti **StreamCompressionFormat**impostazioni per la compressione degli eventi in arrivo:
+ `GZIP`
+ `SNAPPY`
+ `UNCOMPRESSED` (predefinito)
+ `ZIP`
1. (Facoltativo) Per **StreamPrefix**, inserisci il prefisso di stringa per denominare i file archiviati nel bucket di backup Amazon S3. In assenza di valori immessi, non viene utilizzato alcun prefisso.
1. (Facoltativo) Per **SubscriptionFilterPolicy**, inserisci la politica di filtro degli abbonamenti Amazon SNS, in formato JSON, da utilizzare per filtrare gli eventi in arrivo. La politica di filtro decide quali eventi sono indicizzati nell'indice del servizio. OpenSearch In assenza di valori immessi, non viene applicato alcun filtro (tutti gli eventi vengono indicizzati).
1. (Facoltativo) Per **SubscriptionFilterPolicyScope**, inserisci la stringa `MessageBody` o per `MessageAttributes` abilitare il filtraggio dei messaggi basato sul payload o sugli attributi.
1. Scegliere **I acknowledge that this app creates custom IAM roles, resource policies and deploys nested applications. (Riconosco che questa app crea ruoli IAM e policy di risorse personalizzati e distribuisce applicazioni nidificate.)**, quindi selezionare **Deploy (Distribuisci)**.
Nella *my-app* pagina **Stato di distribuzione per**, Lambda visualizza lo stato L'**applicazione è in fase di distribuzione**.
Nella sezione **Risorse**, CloudFormation inizia a creare lo stack e visualizza lo stato **CREATE\$1IN\$1PROGRESS** per ogni risorsa. **Quando il processo è completo, visualizza lo stato CREATE\$1COMPLETE. CloudFormation **
Al termine della distribuzione, Lambda mostra lo stato **Your application has been deployed (L'applicazione è stata distribuita)**.
I messaggi pubblicati sul tuo argomento Amazon SNS vengono archiviati automaticamente nel bucket di backup Amazon S3 fornito automaticamente dalla pipeline Event Storage and Backup.
# Implementazione e sottoscrizione della Event Search and Analytics Pipeline su Amazon SNS
| |
| --- |
| Per l'archiviazione e l'analisi degli eventi, Amazon SNS ora consiglia di utilizzare la sua integrazione nativa con Amazon Data Firehose. Puoi abbonare i flussi di distribuzione Firehose agli argomenti SNS, il che ti consente di inviare notifiche a endpoint di archiviazione e analisi come i bucket Amazon Simple Storage Service (Amazon S3), le tabelle Amazon Redshift, Amazon Service (Service) e altro ancora. OpenSearch OpenSearch L'uso di Amazon SNS con i flussi di distribuzione Firehose è una soluzione completamente gestita e priva di codice che non richiede l'utilizzo di funzioni. AWS Lambda Per ulteriori informazioni, consulta [Flussi di distribuzione da Fanout a Firehose](sns-firehose-as-subscriber.md). |
Questo tutorial mostra come distribuire la [pipeline di ricerca di eventi e di analisi](sns-fork-pipeline-as-subscriber.md#sns-fork-event-search-and-analytics-pipeline) e iscriverla a un argomento Amazon SNS. Questo processo trasforma automaticamente il AWS SAM modello associato alla pipeline in uno CloudFormation stack, quindi distribuisce lo stack nel tuo. Account AWS Il processo inoltre crea e configura il set di risorse che compongono la pipeline di ricerca di eventi e di analisi, tra cui:
+ Coda Amazon SQS
+ funzione Lambda
+ Flussi di distribuzione Firehose
+ Dominio Amazon OpenSearch Service
+ Bucket di Amazon S3
Per ulteriori informazioni sulla configurazione di uno stream con un indice come destinazione, consulta `[ElasticsearchDestinationConfiguration](https://docs.aws.amazon.com/firehose/latest/APIReference/API_ElasticsearchDestinationConfiguration.html)` *Amazon Data Firehose* API Reference.
Per ulteriori informazioni sulla trasformazione degli eventi e sulla configurazione del buffering degli eventi, della compressione degli eventi e della crittografia degli eventi, consulta [Creating an Delivery Stream](https://docs.aws.amazon.com/firehose/latest/dev/basic-create.html) nella Amazon *Data Firehose* Developer Guide.
Per ulteriori informazioni su come filtrare gli eventi, consulta [Policy di filtro degli abbonamenti Amazon SNS](sns-subscription-filter-policies.md) in questa guida.
1. Accedi alla [console AWS Lambda](https://console.aws.amazon.com/lambda/).
1. Nel riquadro di navigazione, selezionare **Functions (Funzioni)** e quindi **Create function (Crea funzione)**.
1. Nella pagina **Create function (Crea funzione)**, procedere come segue:
1. Scegliere **Browse serverless app repository (Sfoglia repository app serverless)**, **Public applications (Applicazioni pubbliche)**, **Show apps that create custom IAM roles or resource policies (Mostra applicazioni in grado di creare ruoli IAM o policy di risorse personalizzati)**.
1. Cercare `fork-event-search-analytics-pipeline` e scegliere l'applicazione.
1. Nella pagina **fork-event-search-analytics-pipeline**, procedi come segue:
1. Nella sezione **Application settings (Impostazioni applicazione)**, immettere un **Application name (Nome applicazione)** (ad esempio `my-app-search`).
**Nota**
Il nome dell'applicazione deve essere univoco per ogni distribuzione. Se riutilizzi il nome di un'applicazione, la distribuzione aggiornerà solo lo CloudFormation stack precedentemente distribuito (anziché crearne uno nuovo).
1. (Facoltativo) Per **DataTransformationFunctionArn**, immettete l'ARN della funzione Lambda utilizzata per trasformare gli eventi in entrata. In assenza di valori immessi, la trasformazione dei dati è disabilitata.
1. (Facoltativo) Immettete una delle seguenti **LogLevel**impostazioni per l'esecuzione della funzione Lambda dell'applicazione:
+ `DEBUG`
+ `ERROR`
+ `INFO` (predefinito)
+ `WARNING`
1. (Facoltativo) Per **SearchDomainArn**, inserisci l'ARN del dominio del OpenSearch servizio, un cluster che configura le funzionalità di elaborazione e archiviazione necessarie. In assenza di valori immessi, viene creato un nuovo dominio con la configurazione predefinita.
1. Per esempio **TopicArn**, inserisci l'ARN dell'argomento Amazon SNS a cui deve essere sottoscritta questa istanza della pipeline fork.
1. Per **SearchIndexName**, inserisci il nome dell'indice dei OpenSearch servizi per la ricerca e l'analisi degli eventi.
**Nota**
I seguenti limiti si applicano ai nomi degli indici:
Non possono includere lettere maiuscole
Non possono includere i seguenti caratteri: `\ / * ? " < > | ` , #`
Non possono iniziare con i seguenti caratteri: `- + _`
Non possono corrispondere a: `. ..`
Non possono essere più lunghi di 80 caratteri
Non possono essere più lunghi di 255 byte
Non può contenere due punti (da OpenSearch Service 7.0)
1. (Facoltativo) Immettete una delle seguenti **SearchIndexRotationPeriod**impostazioni per il periodo di rotazione dell'indice di OpenSearch servizio:
+ `NoRotation` (predefinito)
+ `OneDay`
+ `OneHour`
+ `OneMonth`
+ `OneWeek`
La rotazione dell'indice aggiunge un timestamp al nome dell'indice, facilitando così la scadenza dei dati meno recenti.
1. Per **SearchTypeName**, inserisci il nome del tipo di OpenSearch servizio per l'organizzazione degli eventi in un indice.
**Nota**
OpenSearch I nomi dei tipi di servizio possono contenere qualsiasi carattere (eccetto i byte nulli) ma non possono iniziare con. `_`
Per OpenSearch Service 6.x, può esistere un solo tipo per indice. Se si specifica un nuovo tipo per un indice esistente che ha già un altro tipo, Firehose restituisce un errore di runtime.
1. (Facoltativo) Per **StreamBufferingIntervalInSeconds**e **StreamBufferingSizeInMBs**, inserite i valori per configurare il buffering degli eventi in entrata. In assenza di valori immessi, vengono impostati 300 secondi e 5 MB.
1. (Facoltativo) Immettete una delle seguenti **StreamCompressionFormat**impostazioni per la compressione degli eventi in arrivo:
+ `GZIP`
+ `SNAPPY`
+ `UNCOMPRESSED` (predefinito)
+ `ZIP`
1. (Facoltativo) Per **StreamPrefix**, inserisci il prefisso di stringa per denominare i file archiviati nel bucket con lettera morta di Amazon S3. In assenza di valori immessi, non viene utilizzato alcun prefisso.
1. (Facoltativo) Per **StreamRetryDurationInSecons**, inserire la durata dei nuovi tentativi nei casi in cui Firehose non è in grado di indicizzare gli eventi nell'indice OpenSearch dei servizi. In assenza di valori immessi, viene utilizzato un valore di 300 secondi.
1. (Facoltativo) Per **SubscriptionFilterPolicy**, inserisci la politica di filtro degli abbonamenti Amazon SNS, in formato JSON, da utilizzare per filtrare gli eventi in arrivo. La politica di filtro decide quali eventi sono indicizzati nell'indice del servizio. OpenSearch In assenza di valori immessi, non viene applicato alcun filtro (tutti gli eventi vengono indicizzati).
1. Scegliere **I acknowledge that this app creates custom IAM roles, resource policies and deploys nested applications. (Riconosco che questa app crea ruoli IAM e policy di risorse personalizzati e distribuisce applicazioni nidificate.)**, quindi selezionare **Deploy (Distribuisci)**.
Nella *my-app-search* pagina **Stato di distribuzione per**, Lambda visualizza lo stato L'**applicazione è in fase di distribuzione**.
Nella sezione **Risorse**, CloudFormation inizia a creare lo stack e visualizza lo stato **CREATE\$1IN\$1PROGRESS** per ogni risorsa. **Quando il processo è completo, visualizza lo stato CREATE\$1COMPLETE. CloudFormation **
Al termine della distribuzione, Lambda mostra lo stato **Your application has been deployed (L'applicazione è stata distribuita)**.
I messaggi pubblicati sul tuo argomento Amazon SNS vengono indicizzati automaticamente nell'indice dei OpenSearch servizi fornito dalla pipeline Event Search and Analytics. Se la pipeline non è in grado di indicizzare un evento, lo archivia in un bucket con lettera morta di Amazon S3.
# Implementazione della Event Replay Pipeline con l'integrazione di Amazon SNS
Questoa pagina mostra come distribuire la [pipeline di riproduzione eventi](sns-fork-pipeline-as-subscriber.md#sns-fork-event-replay-pipeline) e iscriverla a un argomento Amazon SNS. Questo processo trasforma automaticamente il AWS SAM modello associato alla pipeline in uno CloudFormation stack, quindi distribuisce lo stack nel tuo. Account AWS Il processo inoltre crea e configura il set di risorse che compongono la pipeline di riproduzione eventi, tra cui una coda Amazon SQS e una funzione Lambda.
Per ulteriori informazioni su come filtrare gli eventi, consulta [Policy di filtro degli abbonamenti Amazon SNS](sns-subscription-filter-policies.md) in questa guida.
1. Accedi alla [console AWS Lambda](https://console.aws.amazon.com/lambda/).
1. Nel riquadro di navigazione, selezionare **Functions (Funzioni)** e quindi **Create function (Crea funzione)**.
1. Nella pagina **Create function (Crea funzione)**, procedere come segue:
1. Scegliere **Browse serverless app repository (Sfoglia repository app serverless)**, **Public applications (Applicazioni pubbliche)**, **Show apps that create custom IAM roles or resource policies (Mostra applicazioni in grado di creare ruoli IAM o policy di risorse personalizzati)**.
1. Cercare `fork-event-replay-pipeline` e scegliere l'applicazione.
1. Nella **fork-event-replay-pipeline**pagina, procedi come segue:
1. Nella sezione **Application settings (Impostazioni applicazione)**, immettere un **Application name (Nome applicazione)** (ad esempio `my-app-replay`).
**Nota**
Il nome dell'applicazione deve essere univoco per ogni distribuzione. Se riutilizzate il nome di un'applicazione, la distribuzione aggiornerà solo lo CloudFormation stack precedentemente distribuito (anziché crearne uno nuovo).
1. (Facoltativo) Immettete una delle seguenti **LogLevel**impostazioni per l'esecuzione della funzione Lambda dell'applicazione:
+ `DEBUG`
+ `ERROR`
+ `INFO` (predefinito)
+ `WARNING`
1. (Facoltativo) Per **ReplayQueueRetentionPeriodInSeconds**, inserisci il periodo di tempo, in secondi, per il quale la coda di replay di Amazon SQS conserva il messaggio. In assenza di valori immessi, viene utilizzato un valore di 1.209.600 secondi (14 giorni).
1. Per esempio **TopicArn**, inserisci l'ARN dell'argomento Amazon SNS a cui deve essere sottoscritta questa istanza della pipeline fork.
1. Per **DestinationQueueName**, inserisci il nome della coda Amazon SQS a cui la funzione di replay Lambda inoltra i messaggi.
1. (Facoltativo) Per **SubscriptionFilterPolicy**, inserisci la politica di filtro degli abbonamenti Amazon SNS, in formato JSON, da utilizzare per filtrare gli eventi in arrivo. Tale policy definisce quali eventi vengono aggiunti al buffer per la riproduzione. In assenza di valori immessi, non viene applicato alcun filtro (tutti gli eventi vengono aggiunti al buffer per la riproduzione).
1. Scegliere **I acknowledge that this app creates custom IAM roles, resource policies and deploys nested applications. (Riconosco che questa app crea ruoli IAM e policy di risorse personalizzati e distribuisce applicazioni nidificate.)**, quindi selezionare **Deploy (Distribuisci)**.
Nella *my-app-replay* pagina **Stato di distribuzione per**, Lambda visualizza lo stato L'**applicazione è in fase di distribuzione**.
Nella sezione **Risorse**, CloudFormation inizia a creare lo stack e visualizza lo stato **CREATE\$1IN\$1PROGRESS** per ogni risorsa. **Quando il processo è completo, visualizza lo stato CREATE\$1COMPLETE. CloudFormation **
Al termine della distribuzione, Lambda mostra lo stato **Your application has been deployed (L'applicazione è stata distribuita)**.
I messaggi pubblicati nell'argomento Amazon SNS vengono aggiunti al buffer per la riproduzione nella coda Amazon SQS assegnata automaticamente dalla pipeline di riproduzione eventi.
**Nota**
La riproduzione è disabilitata per impostazione predefinita. Per abilitarla, accedi alla pagina della funzione sulla console Lambda, espandi la sezione **Designer**, seleziona il riquadro **SQS** e quindi, nella sezione **SQS**, scegli **Enabled (Abilitata)**.