

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à.

# Elabora gli eventi in modo asincrono con Amazon API Gateway e Amazon DynamoDB Streams
<a name="processing-events-asynchronously-with-amazon-api-gateway-and-amazon-dynamodb-streams"></a>

*Andrea Meroni, Mariem Kthiri, Nadim Majed, Alessandro Trisolini e Michael Wallner, Amazon Web Services*

## Riepilogo
<a name="processing-events-asynchronously-with-amazon-api-gateway-and-amazon-dynamodb-streams-summary"></a>

[Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) è un servizio completamente gestito che gli sviluppatori possono utilizzare per creare, pubblicare, mantenere, monitorare e proteggere APIs su qualsiasi scala. Gestisce le attività legate all'accettazione e all'elaborazione di fino a centinaia di migliaia di chiamate API simultanee.

Una quota di servizio importante di API Gateway è il timeout di integrazione. Il timeout è il tempo massimo in cui un servizio di backend deve restituire una risposta prima che l'API REST restituisca un errore. Il limite rigido di 29 secondi è generalmente accettabile per i carichi di lavoro sincroni. Tuttavia, tale limite rappresenta una sfida per gli sviluppatori che desiderano utilizzare API Gateway con carichi di lavoro asincroni.

Questo modello mostra un'architettura di esempio per l'elaborazione asincrona degli eventi utilizzando API Gateway, Amazon DynamoDB Streams e. AWS Lambda L'architettura supporta l'esecuzione di processi di elaborazione parallela con gli stessi parametri di input e utilizza un'API REST di base come interfaccia. In questo esempio, l'utilizzo di Lambda come backend limita la durata dei processi a 15 minuti. È possibile evitare questo limite utilizzando un servizio alternativo per elaborare gli eventi in arrivo (ad esempio,). AWS Fargate

[Projen](https://pypi.org/project/projen/) [https://docs.docker.com/get-docker/](https://docs.docker.com/get-docker/) Projen configura automaticamente un ambiente virtuale [Python](https://www.python.org/downloads/) [con](https://pre-commit.com/) pre-commit e gli strumenti utilizzati per il controllo della qualità del codice, la scansione di sicurezza e il test delle unità. [Per ulteriori informazioni, consulta la sezione Strumenti.](#processing-events-asynchronously-with-amazon-api-gateway-and-amazon-dynamodb-streams-tools)

## Prerequisiti e limitazioni
<a name="processing-events-asynchronously-with-amazon-api-gateway-and-amazon-dynamodb-streams-prereqs"></a>

**Prerequisiti**
+ Un attivo Account AWS
+ I seguenti strumenti installati sulla workstation:
  + [AWS Cloud Development Kit (AWS CDK) Toolkit](https://docs.aws.amazon.com/cdk/v2/guide/cli.html) versione 2.85.0 o successiva
  + [Docker versione 20.10.21 o successiva](https://docs.docker.com/get-docker/)
  + [Node.js versione 18](https://nodejs.org/en/download/) o successiva
  + Versione [Projen](https://pypi.org/project/projen/) 0.71.111 o successiva
  + [Python](https://www.python.org/downloads/) versione 3.9.16 o successiva

**Limitazioni**
+ Il numero massimo consigliato di lettori per DynamoDB Streams è due per evitare la limitazione.
+ La durata massima di un processo è limitata dalla durata massima delle funzioni Lambda (15 minuti).
+ Il numero massimo di richieste di lavoro simultanee è limitato dalla concorrenza riservata delle funzioni Lambda.

## Architecture
<a name="processing-events-asynchronously-with-amazon-api-gateway-and-amazon-dynamodb-streams-architecture"></a>

**Architettura**

Il diagramma seguente mostra l'interazione dell'API dei job con DynamoDB Streams e le funzioni Lambda di elaborazione degli eventi e gestione degli errori, con gli eventi archiviati in un archivio di eventi Amazon. EventBridge 

![Diagramma dell'architettura e del processo, con i passaggi elencati dopo il diagramma.](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/68a46501-16e5-48e4-99c6-fc67a8b4133a/images/29fe6982-ad81-4099-9c65-08b17c96e78f.png)


Un tipico flusso di lavoro include i seguenti passaggi:

1. Ci si autentica con AWS Identity and Access Management (IAM) e si ottengono le credenziali di sicurezza.

1. Si invia una `POST` richiesta HTTP all'endpoint dell'API `/jobs` jobs, specificando i parametri del processo nel corpo della richiesta.

1. L'API jobs ti restituisce una risposta HTTP che contiene l'identificatore del lavoro.

1. L'API jobs inserisce i parametri del processo nella tabella `jobs_table` Amazon DynamoDB.

1. Il flusso `jobs_table` DynamoDB della tabella DynamoDB richiama le funzioni Lambda di elaborazione degli eventi.

1. Le funzioni Lambda per l'elaborazione degli eventi elaborano l'evento e quindi inseriscono i risultati del lavoro nella tabella DynamoDB. `jobs_table` [Per garantire risultati coerenti, le funzioni di elaborazione degli eventi implementano un meccanismo di blocco ottimistico.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.OptimisticLocking.html)

1. Si invia una `GET` richiesta HTTP all'endpoint dell'API `/jobs/{jobId}` jobs, con l'identificatore del lavoro del passaggio 3 as. `{jobId}`

1. L'API jobs interroga la tabella `jobs_table` DynamoDB per recuperare i risultati del lavoro.

1. L'API jobs restituisce una risposta HTTP che contiene i risultati del lavoro.

1. Se l'elaborazione dell'evento non riesce, la mappatura dei sorgenti della funzione di elaborazione degli eventi invia l'evento all'argomento Amazon Simple Notification Service (Amazon SNS) sulla gestione degli errori.

1. L'argomento SNS sulla gestione degli errori invia l'evento in modo asincrono alla funzione di gestione degli errori.

1. La funzione di gestione degli errori inserisce i parametri del lavoro nella tabella DynamoDB`jobs_table`.

   È possibile recuperare i parametri del processo inviando una `GET` richiesta HTTP all'endpoint dell'API jobs. `/jobs/{jobId}`

1. Se la gestione degli errori fallisce, la funzione di gestione degli errori invia l'evento a un archivio Amazon EventBridge .

   Puoi riprodurre gli eventi archiviati utilizzando. EventBridge

## Tools (Strumenti)
<a name="processing-events-asynchronously-with-amazon-api-gateway-and-amazon-dynamodb-streams-tools"></a>

**Servizi AWS**
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html)è un framework di sviluppo software che ti aiuta a definire e fornire l'infrastruttura cloud AWS in codice.
+ [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) è un servizio di database NoSQL interamente gestito che offre prestazioni elevate, prevedibili e scalabili.
+ [Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-what-is.html) è un servizio di bus eventi senza server che ti aiuta a connettere le tue applicazioni con dati in tempo reale provenienti da una varietà di fonti. Ad esempio, funzioni AWS Lambda, endpoint di invocazione HTTP che utilizzano destinazioni API o bus di eventi in altri account AWS.
+ [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) è un servizio di calcolo che consente di eseguire il codice senza gestire i server o effettuarne il provisioning. Esegue il codice solo quando necessario e si ridimensiona automaticamente, quindi paghi solo per il tempo di calcolo che utilizzi.
+ [Amazon Simple Notification Service (Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/welcome.html)) ti aiuta a coordinare e gestire lo scambio di messaggi tra editori e clienti, inclusi server Web e indirizzi e-mail.

**Altri strumenti**
+ [autopep8](https://github.com/hhatto/autopep8) formatta automaticamente il codice Python in base alla guida di stile Python Enhancement Proposal (PEP) 8.
+ [Bandit](https://bandit.readthedocs.io/en/latest/) scansiona il codice Python per trovare problemi di sicurezza comuni.
+ [Commitizen](https://commitizen-tools.github.io/commitizen/) è un controllore e generatore di commit Git. `CHANGELOG`
+ [cfn-lint](https://github.com/aws-cloudformation/cfn-lint) è un linter AWS CloudFormation 
+ [Checkov](https://github.com/bridgecrewio/checkov) è uno strumento statico di analisi del codice che verifica eventuali configurazioni errate di sicurezza e conformità dell'infrastruttura come codice (IaC).
+ [jq](https://stedolan.github.io/jq/download/) è uno strumento a riga di comando per l'analisi di JSON.
+ [Postman](https://www.postman.com/) è una piattaforma API.
+ [pre-commit](https://pre-commit.com/) è un gestore di hook Git.
+ [Projen](https://github.com/projen/projen) è un generatore di progetti.
+ [pytest](https://docs.pytest.org/en/7.2.x/index.html) è un framework Python per scrivere test piccoli e leggibili.

**Archivio di codice**

Questo codice di architettura di esempio è disponibile nel repository GitHub [Asynchronous Processing with API Gateway e DynamoDB Streams](https://github.com/aws-samples/asynchronous-event-processing-api-gateway-dynamodb-streams-cdk).

## Best practice
<a name="processing-events-asynchronously-with-amazon-api-gateway-and-amazon-dynamodb-streams-best-practices"></a>
+ Questa architettura di esempio non include il monitoraggio dell'infrastruttura distribuita. Se il tuo caso d'uso richiede il monitoraggio, valuta la possibilità di aggiungere [CDK Monitoring Constructs o un'altra soluzione di monitoraggio](https://constructs.dev/packages/cdk-monitoring-constructs).
+ Questa architettura di esempio utilizza [le autorizzazioni IAM](https://docs.aws.amazon.com/apigateway/latest/developerguide/permissions.html) per controllare l'accesso all'API jobs. Chiunque sia autorizzato a presumere che `JobsAPIInvokeRole` sarà in grado di richiamare l'API jobs. Pertanto, il meccanismo di controllo degli accessi è binario. Se il tuo caso d'uso richiede un modello di autorizzazione più complesso, valuta l'utilizzo di un [meccanismo di controllo degli accessi](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-control-access-to-api.html) diverso.
+ Quando un utente invia una `POST` richiesta HTTP all'endpoint dell'API `/jobs` jobs, i dati di input vengono convalidati a due livelli diversi:
  + API Gateway è responsabile della prima [convalida della richiesta](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-method-request-validation.html).
  + La funzione di elaborazione degli eventi esegue la seconda richiesta.

    Non viene eseguita alcuna convalida quando l'utente effettua una `GET` richiesta HTTP all'endpoint dell'API `/jobs/{jobId}` jobs. Se il tuo caso d'uso richiede un'ulteriore convalida degli input e un maggiore livello di sicurezza, valuta [l'utilizzo AWS WAF per proteggere](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-control-access-aws-waf.html) la tua API.
+ Per evitare il throttling, la documentazione di [DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html#Streams.Processing) scoraggia gli utenti dal leggere con più di due consumatori dello stesso shard dello stesso stream. Per ridimensionare il numero di consumatori, consigliamo di utilizzare [Amazon Kinesis Data Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/kds.html).
+ In questo esempio è stato utilizzato [il blocco ottimistico](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.OptimisticLocking.html) per garantire aggiornamenti coerenti degli elementi nella tabella DynamoDB`jobs_table`. A seconda del requisito del caso d'uso, potrebbe essere necessario implementare meccanismi di blocco più affidabili, come il blocco pessimistico.

## Epiche
<a name="processing-events-asynchronously-with-amazon-api-gateway-and-amazon-dynamodb-streams-epics"></a>

### Configura l'ambiente
<a name="set-up-the-environment"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Clonare il repository. | Per clonare il repository localmente, esegui il seguente comando:<pre>git clone https://github.com/aws-samples/asynchronous-event-processing-api-gateway-dynamodb-streams-cdk.git</pre> | DevOps ingegnere | 
| Configura il progetto. | [Cambia la directory nella radice del repository e configura l'ambiente virtuale Python e tutti gli strumenti usando Projen:](https://github.com/projen/projen)<pre>cd asynchronous-event-processing-api-gateway-api-gateway-dynamodb-streams-cdk<br />npx projen</pre> | DevOps ingegnere | 
| Installa i ganci di pre-commit. | Per installare gli hook di pre-commit, procedi come segue:[See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/processing-events-asynchronously-with-amazon-api-gateway-and-amazon-dynamodb-streams.html) | DevOps ingegnere | 

### Implementa l'architettura di esempio
<a name="deploy-the-example-architecture"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Bootstrap. AWS CDK | Per eseguire il bootstrap [AWS CDK](https://aws.amazon.com/cdk/)in tuo Account AWS, esegui il seguente comando:<pre>AWS_PROFILE=$YOUR_AWS_PROFILE npx projen bootstrap</pre> | AWS DevOps | 
| Implementa l'architettura di esempio. | Per implementare l'architettura di esempio nella tua Account AWS, esegui il seguente comando:<pre>AWS_PROFILE=$YOUR_AWS_PROFILE npx projen deploy</pre> | AWS DevOps | 

### Testa l'architettura
<a name="test-the-architecture"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Installa i prerequisiti del test. | [Installa sulla tua workstation the [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html), [Postman](https://www.postman.com/downloads/) e jq.](https://jqlang.github.io/jq/)<br />L'uso di [Postman](https://www.postman.com/downloads/) per testare questa architettura di esempio è consigliato ma non obbligatorio. Se scegli uno strumento di test delle API alternativo, assicurati che supporti [l'autenticazione AWS Signature versione 4](https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html) e fai riferimento agli endpoint API esposti che possono essere ispezionati [esportando l'](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-export-api.html)API REST. | DevOps ingegnere | 
| Supponiamo il`JobsAPIInvokeRole`. | [Supponiamo](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/sts/assume-role.html) `JobsAPIInvokeRole` che sia stato stampato come output del `deploy` comando:<pre>CREDENTIALS=$(AWS_PROFILE=$<YOUR_AWS_PROFILE> aws sts assume-role \<br />--no-cli-pager \<br />--role-arn $<JOBS_API_INVOKE_ROLE_ARN> \<br />--role-session-name JobsAPIInvoke)<br />export AWS_ACCESS_KEY_ID=$(cat $CREDENTIALS | jq ‘.Credentials’’.AccessKeyId’)<br />export AWS_SECRET_ACCESS_KEY=$(cat $CREDENTIALS | jq ‘.Credentials’’.SecretAccessKey’)<br />export AWS_SESSION_TOKEN==$(cat $CREDENTIALS | jq ‘.Credentials’’.SessionToken’)</pre> | AWS DevOps | 
| Configura Postman. | [See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/processing-events-asynchronously-with-amazon-api-gateway-and-amazon-dynamodb-streams.html) | AWS DevOps | 
| Prova l'architettura di esempio. | Per testare l'architettura di esempio, invia le richieste all'API jobs. Per ulteriori informazioni, consulta la [documentazione di Postman](https://learning.postman.com/docs/getting-started/first-steps/sending-the-first-request/#send-an-api-request). | DevOps ingegnere | 

## risoluzione dei problemi
<a name="processing-events-asynchronously-with-amazon-api-gateway-and-amazon-dynamodb-streams-troubleshooting"></a>


| Problema | Soluzione | 
| --- | --- | 
| La distruzione e la successiva ridistribuzione dell'architettura di esempio non riescono perché il [gruppo di log di Amazon CloudWatch Logs esiste](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) `/aws/apigateway/JobsAPIAccessLogs` già. | [See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/processing-events-asynchronously-with-amazon-api-gateway-and-amazon-dynamodb-streams.html) | 

## Risorse correlate
<a name="processing-events-asynchronously-with-amazon-api-gateway-and-amazon-dynamodb-streams-resources"></a>
+ [Modello di mappatura API Gateway e riferimento alla variabile di registrazione degli accessi](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html)
+ [Modifica l'acquisizione dei dati per DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html)
+ [Blocco ottimistico con numero di versione](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.OptimisticLocking.html)
+ [Utilizzo di Kinesis Data Streams per acquisire le modifiche a DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/kds.html)