"}}'`esempio:`aws dynamodb put-item --table-name SourceData_table --item '{"SourceDataId": {"S": "123"},"MessageData":{"S": "Hello World"}}'`Per impostazione predefinita, `put-item` non restituisce alcun valore come output se l'operazione ha esito positivo. Se l'operazione non riesce, restituisce un errore. I dati vengono archiviati in DynamoDB e quindi inviati a Kinesis Data Streams e Firehose. Utilizzate approcci diversi per aggiungere dati in una tabella DynamoDB. Per ulteriori informazioni, consulta [Caricare i dati nelle tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SampleData.LoadData.html) nella documentazione di DynamoDB. | Sviluppatore di app |
| Verifica che venga creato un nuovo oggetto nel bucket S3. | Accedi Console di gestione AWS e monitora il bucket S3 per verificare che sia stato creato un nuovo oggetto con i dati che hai inviato. Per ulteriori informazioni, [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)consulta la documentazione di Amazon S3. | Sviluppatore di app, General AWS |
### Eseguire la pulizia delle risorse
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Eliminare le risorse. | Esegui il `cdk destroy` comando per eliminare tutte le risorse utilizzate da questo modello. | Sviluppatore di app, General AWS |
## Risorse correlate
+ [s-3 static-site-stack .ts (repository](https://github.com/awslabs/aws-solutions-constructs/blob/main/source/use_cases/aws-s3-static-website/lib/s3-static-site-stack.ts#L25)) GitHub
+ [aws-apigateway-dynamodb modulo](https://github.com/awslabs/aws-solutions-constructs/tree/main/source/patterns/%40aws-solutions-constructs/aws-apigateway-dynamodb) (repository) GitHub
+ [aws-kinesisstreams-kinesisfirehose-smodulo 3](https://github.com/awslabs/aws-solutions-constructs/tree/main/source/patterns/%40aws-solutions-constructs/aws-kinesisstreams-kinesisfirehose-s3) (GitHub repository)
+ [Modifica l'acquisizione dei dati per DynamoDB Streams (documentazione DynamoDB)](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html)
+ [Utilizzo di Kinesis Data Streams per acquisire le modifiche a DynamoDB (documentazione DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/kds.html))
# Implementa il controllo delle versioni delle API basato sul percorso utilizzando domini personalizzati in Amazon API Gateway
*Corey Schnedl, Marcelo Barbosa, Mario López Martínez, Anbazhagan Ponnuswamy, Gaurav Samudra e Abhilash Vinod, Amazon Web Services*
## Riepilogo
Questo modello dimostra come utilizzare la funzionalità di [mappatura delle API](https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-mappings.html) dei [domini personalizzati](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-custom-domains.html) per implementare una soluzione di controllo delle versioni delle API basata sul percorso per Amazon API Gateway.
Amazon API Gateway è un servizio completamente gestito che puoi utilizzare per creare, pubblicare, mantenere, monitorare e proteggere APIs su qualsiasi scala. Utilizzando la funzionalità di dominio personalizzato del servizio, puoi creare nomi di dominio personalizzati più semplici e intuitivi URLs da fornire agli utenti delle API. Puoi utilizzare le mappature delle API per connettere le fasi dell'API a un nome di dominio personalizzato. Dopo aver creato un nome di dominio e configurato i record DNS, utilizzi le mappature delle API per inviare traffico al tuo utente APIs tramite il tuo nome di dominio personalizzato.
Dopo che un'API diventa disponibile pubblicamente, i consumatori la utilizzano. Con l'evoluzione di un'API pubblica, anche il suo contratto di servizio si evolve per riflettere nuove funzionalità e capacità. Tuttavia, non è consigliabile modificare o rimuovere le funzionalità esistenti. Eventuali modifiche sostanziali potrebbero influire sulle applicazioni del consumatore e interromperle in fase di esecuzione. Il controllo delle versioni delle API è importante per evitare l'interruzione della compatibilità con le versioni precedenti e l'interruzione del contratto.
È necessaria una strategia chiara per il controllo delle versioni delle API per aiutare i consumatori ad adottarle. Il controllo delle versioni APIs tramite path-based URLs è l'approccio più semplice e comunemente usato. In questo tipo di controllo delle versioni, le versioni sono definite esplicitamente come parte dell'API. URIs L'esempio seguente URLs mostra come un consumatore può utilizzare l'URI per specificare una versione dell'API per la propria richiesta:
`https://api.example.com/api/v1/orders `
`https://api.example.com/api/v2/orders `
`https://api.example.com/api/vX/orders`
Questo modello utilizza AWS Cloud Development Kit (AWS CDK) per creare, distribuire e testare un'implementazione di esempio di una soluzione di versioning scalabile basata su percorsi per l'API. AWS CDK è un framework di sviluppo software open source per modellare e fornire le risorse delle applicazioni cloud utilizzando linguaggi di programmazione familiari.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un attivo Account AWS.
+ La proprietà di un dominio è necessaria per utilizzare l'archivio di esempio di questo pattern e per utilizzare la funzionalità di dominio personalizzato di Amazon API Gateway. Puoi usare Amazon Route 53 per creare e gestire i domini per la tua organizzazione. Per informazioni su come registrare o trasferire un dominio con Route 53, consulta [Registrazione di nuovi domini](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/domain-register-update.html) nella documentazione di Route 53.
+ Prima di configurare un nome di dominio personalizzato per un'API, è necessario disporre di un certificato [SSL/TLS](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-specify-certificate-for-custom-domain-name.html). AWS Certificate Manager
+ È necessario creare o aggiornare il record di risorse del provider DNS per eseguire la mappatura all'endpoint API. Senza tale mappatura, le richieste API associate al nome di dominio personalizzato non possono raggiungere API Gateway.
**Limitazioni**
+ Un nome di dominio personalizzato deve essere unico all'interno di Regione AWS tutti Account AWS.
+ Per configurare le mappature API con più livelli, è necessario utilizzare un nome di dominio personalizzato regionale e la policy di sicurezza TLS 1.2.
+ In una mappatura API, il nome di dominio personalizzato e il mapping APIs devono coincidere. Account AWS
+ Le mappature API devono contenere solo lettere, numeri e i seguenti caratteri: `$-_.+!*'()/`
+ La lunghezza massima per il percorso in una mappatura API è di 300 caratteri.
+ È possibile disporre di 200 mappature API con più livelli per ogni nome di dominio.
+ È possibile mappare HTTP solo APIs a un nome di dominio personalizzato regionale con la politica di sicurezza TLS 1.2.
+ Non è possibile eseguire il WebSocket APIs mapping allo stesso nome di dominio personalizzato di un'API HTTP o di un'API REST.
+ Alcuni Servizi AWS non sono disponibili in tutti Regioni AWS. Per la disponibilità regionale, vedi [AWS Servizi per regione](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Per endpoint specifici, consulta [Endpoints and quotas del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e scegli il link relativo al servizio.
**Versioni del prodotto**
+ [Questa implementazione di esempio utilizza la AWS CDK TypeScript versione 2.149.0.](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-typescript.html)
## Architecture
Il diagramma seguente mostra il flusso di lavoro dell'architettura.
![\[Flusso di lavoro che utilizza mappature API e domini personalizzati per implementare una soluzione di controllo delle versioni delle API basata sul percorso.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/e1b32d2b-410f-4ace-967e-f0b8aaf0304c/images/fa9f04f1-efa6-4fb1-a541-ae3da4076b00.png)
Il diagramma illustra quanto segue:
1. L'utente API invia una richiesta ad Amazon API Gateway con un nome di dominio personalizzato.
1. API Gateway indirizza dinamicamente la richiesta dell'utente verso un'istanza e una fase appropriate di API Gateway, in base al percorso indicato nell'URL della richiesta. La tabella seguente mostra un esempio di come i diversi percorsi basati su URL possono essere instradati verso fasi specifiche per diverse istanze di API Gateway.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/implement-path-based-api-versioning-by-using-custom-domains.html)
1. L'istanza API Gateway di destinazione elabora la richiesta e restituisce il risultato all'utente.
**Automazione e scalabilità**
Ti consigliamo di utilizzare AWS CloudFormation stack separati per ogni versione della tua API. Con questo approccio, puoi avere un isolamento completo tra i backend a APIs cui può essere indirizzato la funzionalità di mappatura dell'API di dominio personalizzata. Un vantaggio di questo approccio è che diverse versioni dell'API possono essere distribuite o rimosse indipendentemente senza comportare il rischio di modificare un'altra API. Questo approccio aumenta la resilienza attraverso l'isolamento degli stack. CloudFormation Inoltre, offre diverse opzioni di back-end per l'API AWS Lambda AWS Fargate, come endpoint HTTP e azioni di. Servizi AWS
Puoi utilizzare strategie di ramificazione Git, come [Gitflow](https://docs.aws.amazon.com/prescriptive-guidance/latest/choosing-git-branch-approach/gitflow-branching-strategy.html), in combinazione con CloudFormation stack isolati per gestire il codice sorgente distribuito in diverse versioni dell'API. Utilizzando questa opzione, puoi mantenere diverse versioni della tua API senza la necessità di duplicare il codice sorgente per le nuove versioni. Con Gitflow, puoi aggiungere tag ai commit all'interno del tuo repository git man mano che vengono eseguiti i rilasci. Di conseguenza, hai un'istantanea completa del codice sorgente relativo a una versione specifica. Poiché è necessario eseguire gli aggiornamenti, è possibile estrarre il codice di una versione specifica, apportare aggiornamenti e quindi distribuire il codice sorgente aggiornato CloudFormation nello stack che si allinea alla versione principale corrispondente. Questo approccio riduce il rischio di violare un'altra versione dell'API perché ogni versione dell'API ha un codice sorgente isolato e viene distribuita in stack separati. CloudFormation
## Tools (Strumenti)
**Servizi AWS**
+ [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) ti aiuta a creare, pubblicare, gestire, monitorare e proteggere REST, HTTP e WebSocket APIs su qualsiasi scala.
+ [AWS Certificate Manager (ACM)](https://docs.aws.amazon.com/acm/latest/userguide/acm-overview.html) ti aiuta a creare, archiviare e rinnovare certificati e chiavi SSL/TLS X.509 pubblici e privati che proteggono i tuoi siti Web e le tue AWS applicazioni.
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html)è un framework di sviluppo software open source per definire l'infrastruttura cloud in codice e fornirla tramite. CloudFormation[L'implementazione di esempio di questo pattern utilizza in.AWS CDK TypeScript](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-typescript.html) L'utilizzo di AWS CDK in TypeScript utilizza strumenti familiari, tra cui il TypeScript compilatore Microsoft (`tsc`), [Node.js](https://nodejs.org/) e il gestore di pacchetti del nodo (`npm`). Se preferisci, puoi usare [Yarn](https://yarnpkg.com/) anche se gli esempi di questo modello lo usano. `npm` [I moduli che compongono la [AWS Construct Library](https://docs.aws.amazon.com/cdk/v2/guide/libraries.html#libraries-construct) sono distribuiti tramite il `npm ` repository npmjs.org.](https://docs.npmjs.com/)
+ [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)ti aiuta a configurare AWS le risorse, a fornirle in modo rapido e coerente e a gestirle durante tutto il loro ciclo di vita in e. Account AWS Regioni 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 elaborazione che utilizzi.
+ [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) è un servizio Web DNS altamente scalabile e disponibile.
+ [AWS WAF](https://docs.aws.amazon.com/waf/latest/developerguide/what-is-aws-waf.html)è un firewall per applicazioni Web che consente di monitorare le richieste HTTP e HTTPS inoltrate alle risorse protette delle applicazioni Web.
**Altri strumenti**
+ [Bruno](https://www.usebruno.com/) è un client di test API open source e compatibile con git.
+ [cdk-nag](https://github.com/cdklabs/cdk-nag) è un'utilità open source che verifica AWS CDK le migliori pratiche delle applicazioni utilizzando pacchetti di regole.
**Archivio di codice**
Il codice per questo pattern è disponibile nel repository GitHub [path-based-versioning-with-api-gateway](https://github.com/aws-samples/path-based-versioning-with-api-gateway).
## Best practice
+ Utilizza una solida pipeline di integrazione e distribuzione continua (CI/CD) per automatizzare il test e l'implementazione degli stack creati con. CloudFormation AWS CDK Per ulteriori informazioni relative a questa raccomandazione, consulta la [AWS DevOps Well-Architected Guidance](https://docs.aws.amazon.com/wellarchitected/latest/devops-guidance/devops-guidance.html).
+ AWS WAF è un firewall gestito che si integra facilmente con servizi come Amazon API Gateway. Sebbene AWS WAF non sia un componente necessario per il funzionamento di questo modello di versione, come best practice di sicurezza consigliamo di includerlo AWS WAF con API Gateway.
+ Incoraggia gli utenti delle API a eseguire regolarmente l'aggiornamento alla versione più recente dell'API in modo che le versioni precedenti dell'API possano essere obsolete e rimosse in modo efficiente.
+ Prima di utilizzare questo approccio in un ambiente di produzione, implementate un firewall e una strategia di autorizzazione per la vostra API.
+ Implementate l'accesso alla gestione delle AWS risorse della vostra azienda Account AWS utilizzando il modello di accesso con [privilegi minimi](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege).
+ [Per applicare le migliori pratiche e i consigli di sicurezza per le applicazioni create con AWS CDK, si consiglia di utilizzare l'utilità cdk-nag.](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/check-aws-cdk-applications-or-cloudformation-templates-for-best-practices-by-using-cdk-nag-rule-packs.html)
## Epiche
### Prepara il tuo ambiente locale
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clonare il repository. | Per clonare il repository di applicazioni di esempio, esegui il seguente comando:git clone https://github.com/aws-samples/path-based-versioning-with-api-gateway
| Sviluppatore di app |
| Accedere al repository clonato. | Per accedere alla posizione della cartella del repository clonata, esegui il seguente comando: cd api-gateway-custom-domain-versioning
| Sviluppatore di app |
| Installare le dipendenze richieste. | Per installare le dipendenze richieste, esegui il comando seguente:npm install
| Sviluppatore di app |
### Implementa lo stack di routing CloudFormation
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Avvia l'implementazione dello stack di routing. | Per avviare la distribuzione dello stack di CloudFormation routing`CustomDomainRouterStack`, esegui il comando seguente, sostituendolo `example.com` con il nome del dominio di tua proprietà:npx cdk deploy CustomDomainRouterStack --parameters PrerequisiteDomainName=example.com
La distribuzione dello stack non avrà esito positivo finché la seguente attività di convalida DNS del dominio non verrà eseguita correttamente. | Sviluppatore di app |
### Verifica della proprietà del dominio
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Verifica la proprietà del tuo dominio. | Il certificato rimarrà in stato di **convalida in sospeso** fino a quando non dimostrerai la proprietà del dominio associato. Per dimostrare la proprietà, aggiungi i record CNAME alla zona ospitata associata al dominio. Per ulteriori informazioni, consulta la [convalida DNS nella documentazione](https://docs.aws.amazon.com/acm/latest/userguide/dns-validation.html). AWS Certificate Manager L'aggiunta dei record appropriati consente la corretta `CustomDomainRouterStack` implementazione. | Sviluppatore di app, amministratore di sistema AWS, amministratore di rete |
| Crea un record di alias che punti al tuo dominio personalizzato API Gateway. | Dopo che il certificato è stato emesso e convalidato con successo, [crea un record DNS](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.html#apigateway-regional-api-custom-domain-dns-record) che punti all'URL del tuo dominio personalizzato Amazon API Gateway. L'URL del dominio personalizzato viene generato in modo univoco dal provisioning del dominio personalizzato e viene specificato come parametro di output. CloudFormation Di seguito è riportato un [esempio del record](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resource-record-sets-values-basic.html): **Politica di routing**: routing semplice**Nome del record**: `demo.api-gateway-custom-domain-versioning.example.com`**Alias**: Yes (Sì)**Tipo di record**: un record DNS di tipo «A» che punta a una risorsa AWS **Value (Valore)**: `d-xxxxxxxxxx.execute-api.xx-xxxx-x.amazonaws.com`**TTL (secondi)**: 300 | Sviluppatore di app, amministratore di sistema AWS, amministratore di rete |
### Distribuisci gli CloudFormation stack e richiama l'API
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Distribuisci lo `ApiStackV1` stack. | Per distribuire lo `ApiStackV1` stack, usa il seguente comando:npm run deploy-v1
Il seguente codice CDK aggiunge la mappatura delle API:var apiMapping = new CfnApiMapping(this, "ApiMapping", {
apiId: this.lambdaRestApi.restApiId,
domainName: props.customDomainName.domainName,
stage: "api",
apiMappingKey: "api/v1",
}); | Sviluppatore di app |
| Implementa lo stack. `ApiStackV2` | Per distribuire lo `ApiStackV2` stack, usa il seguente comando:npm run deploy-v2
| Sviluppatore di app |
| Invoca l'API. | [Per richiamare l'API e testare gli endpoint dell'API utilizzando Bruno, consulta le istruzioni in Informazioni aggiuntive.](#implement-path-based-api-versioning-by-using-custom-domains-additional) | Sviluppatore di app |
### Eseguire la pulizia delle risorse
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Eliminare le risorse. | Per distruggere le risorse associate a questa applicazione di esempio, utilizzate il seguente comando:npx cdk destroy --all
Assicurati di pulire tutti i record DNS di Route 53 che sono stati aggiunti manualmente per il processo di verifica della proprietà del dominio. | Sviluppatore di app |
## Risoluzione dei problemi
| Problema | Soluzione |
| --- | --- |
| La distribuzione è `CustomDomainRouterStack` scaduta perché il certificato non può essere convalidato. | Assicurati di aver aggiunto i record CNAME di convalida DNS appropriati, come descritto nell'attività precedente. Il nuovo certificato potrebbe continuare a mostrare lo stato **In attesa di convalida** per un massimo di 30 minuti dopo l'aggiunta dei record di convalida DNS. Per ulteriori informazioni, consulta la sezione Convalida [DNS](https://docs.aws.amazon.com/acm/latest/userguide/dns-validation.html) nella documentazione. AWS Certificate Manager |
## Risorse correlate
+ [Implementazione del controllo delle versioni di API Gateway basato su header con Amazon CloudFront](https://aws.amazon.com/blogs/compute/implementing-header-based-api-gateway-versioning-with-amazon-cloudfront/): questo post di AWS Compute Blog offre una strategia di versioning basata sugli header come alternativa alla strategia di versioning basata sul percorso delineata in questo modello.
+ [AWS CDK Workshop](https://cdkworkshop.com/20-typescript.html): questo workshop introduttivo si concentra sulla creazione e la distribuzione di applicazioni utilizzando il. AWS AWS Cloud Development Kit (AWS CDK) Questo workshop supporta Go, Python e. TypeScript
## Informazioni aggiuntive
**Testare la tua API con Bruno**
Ti consigliamo di utilizzare [Bruno, uno](https://www.usebruno.com/) strumento di test delle API open source, per verificare che il routing basato sui percorsi funzioni correttamente per l'applicazione di esempio. Questo modello fornisce una raccolta di esempi per facilitare il test dell'API di esempio.
Per richiamare e testare la tua API, utilizza i seguenti passaggi:
1. [Installa Bruno.](https://www.usebruno.com/downloads)
1. Apri Bruno.
1. Nel [repository di codice](https://github.com/aws-samples/path-based-versioning-with-api-gateway) di questo pattern, seleziona **Bruno/Sample-API-** e apri la raccolta. Gateway-Custom-Domain-Versioning
1. Per visualizzare il menu a discesa **Ambienti** in alto a destra dell'interfaccia utente (UI), seleziona una richiesta nella raccolta.
1. **Nel menu a discesa **Ambienti**, seleziona Configura.**
1. Sostituisci il `REPLACE_ME_WITH_YOUR_DOMAIN` valore con il tuo dominio personalizzato.
1. Scegli **Salva**, quindi chiudi la sezione **Configurazione**.
1. Per **Sandbox Environment**,**** verificate che l'opzione **Attivo** sia selezionata.
1. Richiama l'API utilizzando il pulsante **->** per la richiesta selezionata.
1. Prendi nota di come viene gestita la convalida (passaggio di valori non numerici) in V1 rispetto a V2.
[Per vedere schermate di esempio di invocazione dell'API e confronto delle convalide V1 e V2, vedi **Testare l'API di esempio nel file dell'archivio di codice di questo pattern**. `README.md`](https://github.com/aws-samples/path-based-versioning-with-api-gateway)
# Importa la libreria psycopg2 per interagire con il tuo AWS Lambda database PostgreSQL
*Louis Hourcade, Amazon Web Services*
## Riepilogo
[Psycopg](https://www.psycopg.org/docs/) è un adattatore di database PostgressSQL per Python. Gli sviluppatori utilizzano la `psycopg2` libreria per scrivere applicazioni Python che interagiscono con i database PostgreSQL.
Su Amazon Web Services (AWS), gli sviluppatori lo utilizzano anche [AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)per eseguire codice per applicazioni o servizi di backend. Lambda è un servizio di elaborazione senza server e basato sugli eventi che esegue codice senza la necessità di fornire o gestire server.
Per impostazione predefinita, quando crei una nuova funzione che utilizza un [runtime Python supportato da Lambda, l'ambiente di runtime Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.html) viene creato da [un'immagine](https://github.com/aws/aws-lambda-base-images) di base per Lambda fornita da. AWS Le librerie, come `pandas` or`psycopg2`, non sono incluse nell'immagine di base. Per utilizzare una libreria, devi raggrupparla in un pacchetto personalizzato e collegarla a Lambda.
Esistono diversi modi per raggruppare e collegare una libreria, inclusi i seguenti:
+ Implementa la tua funzione Lambda da [un archivio di file.zip.](https://docs.aws.amazon.com/lambda/latest/dg/configuration-function-zip.html)
+ Implementa la tua funzione Lambda da un'immagine di contenitore personalizzata.
+ Crea un [layer Lambda](https://docs.aws.amazon.com/lambda/latest/dg/chapter-layers.html#lambda-layer-versions) e collegalo alla tua funzione Lambda.
Questo modello illustra le prime due opzioni.
Con un pacchetto di distribuzione.zip, aggiungere la `pandas` libreria alla funzione Lambda è relativamente semplice. Crea una cartella sulla tua macchina Linux, aggiungi lo script Lambda insieme alla `pandas` libreria e alle dipendenze della libreria alla cartella, comprimi la cartella e forniscila come sorgente per la tua funzione Lambda.
Sebbene l'utilizzo di un pacchetto di distribuzione.zip sia una pratica comune, questo approccio non funziona per la libreria. `psycopg2` Questo modello mostra innanzitutto l'errore che si ottiene se si utilizza un pacchetto di distribuzione.zip per aggiungere la `psycopg2` libreria alla funzione Lambda. Il modello mostra quindi come distribuire Lambda da un Dockerfile e modificare l'immagine Lambda per far funzionare la libreria. `psycopg2`
[Per informazioni sulle tre risorse distribuite dal pattern, consultate la sezione Informazioni aggiuntive.](#import-psycopg2-library-lambda-additional)
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un attivo Account AWS con autorizzazioni sufficienti per distribuire le AWS risorse utilizzate da questo modello
+ AWS Cloud Development Kit (AWS CDK) installato a livello globale eseguendo `npm install -g aws-cdk`
+ Un client Git
+ Python
+ Docker
**Limitazioni**
+ Alcune Servizi AWS non sono disponibili in tutte Regioni AWS. Per la disponibilità per regione, vedi [Servizi AWS per regione](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Per endpoint specifici, consulta la pagina [Endpoint e quote del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e scegli il link relativo al servizio.
**Versioni del prodotto**
+ Versione runtime di Python [supportata da Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.html)
+ Psycopg2 versione 2.9.3
+ Pandas versione 1.5.2
## Architecture
**Panoramica della soluzione**
Per illustrare le sfide che potresti dover affrontare quando utilizzi la `psycopg2` libreria in Lambda, il pattern implementa due funzioni Lambda:
+ Una funzione Lambda con il runtime Python creata da un file.zip. [Le `pandas` librerie `psycopg2` and vengono installate in questo pacchetto di distribuzione.zip utilizzando pip.](https://pypi.org/project/pip/)
+ Una funzione Lambda con il runtime Python creato da un Dockerfile. Il Dockerfile installa le `pandas` librerie `psycopg2` and nell'immagine del contenitore Lambda.
La prima funzione Lambda installa la `pandas` libreria e le sue dipendenze in un file.zip e Lambda può utilizzare tale libreria.
La seconda funzione Lambda dimostra che, creando un'immagine contenitore per la funzione Lambda, è possibile eseguire le librerie and `pandas` in Lambda. `psycopg2`
## Tools (Strumenti)
**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.
+ [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 elaborazione che utilizzi.
**Altri strumenti**
+ [Docker](https://www.docker.com/) è un insieme di prodotti Platform as a Service (PaaS) che utilizzano la virtualizzazione a livello di sistema operativo per fornire software in container.
+ [pandas](https://pandas.pydata.org/) è uno strumento open source basato su Python per l'analisi e la manipolazione dei dati.
+ [Psycopg](https://www.psycopg.org/docs/) è un adattatore di database PostgreSQL per il linguaggio Python progettato per applicazioni multithread. Questo modello utilizza Psycopg 2.
+ [Python](https://www.python.org/) è un linguaggio di programmazione per computer generico.
**Deposito di codice**
Il codice per questo pattern è disponibile nel repository [import-psycopg2](https://github.com/aws-samples/import-psycopg2-in-lambda-to-interact-with-postgres-database) - - su. in-lambda-to-interact with-postgres-database GitHub
## Best practice
Questo modello fornisce un esempio funzionante di utilizzo AWS CDK per creare una funzione Lambda da un Dockerfile. Se riutilizzi questo codice nella tua applicazione, assicurati che le risorse distribuite soddisfino tutti i requisiti di sicurezza. Utilizza strumenti come [Checkov](https://www.checkov.io/), che analizza le configurazioni dell'infrastruttura cloud per individuare eventuali errori di configurazione prima che l'infrastruttura venga implementata.
## Epiche
### Clona il repository e configura la distribuzione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clonare il repository. | Per clonare il GitHub repository sul computer locale, esegui i seguenti comandi:git clone https://github.com/aws-samples/import-psycopg2-in-lambda-to-interact-with-postgres-database.git
cd AWS-lambda-psycopg2
| Informazioni generali su AWS |
| Configura la tua distribuzione. | Modifica il `app.py` file con informazioni su Account AWS:aws_acccount = "AWS_ACCOUNT_ID"
region = "AWS_REGION"
# Select the CPU architecture you are using to build the image (ARM or X86)
architecture = "ARM"
| Informazioni generali su AWS |
### Avvia il tuo account AWS e distribuisci l'applicazione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Bootstrap il tuo. Account AWS | Se non hai ancora [avviato il tuo ambiente AWS](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html), esegui i seguenti comandi con le AWS credenziali del tuo account: AWS cdk bootstrap aws:///
| Informazioni generali su AWS |
| Implementa il codice. | Per distribuire l' AWS CDK applicazione, esegui il comando seguente:cdk deploy AWSLambdaPyscopg2
| Informazioni generali su AWS |
### Testa le funzioni Lambda dalla Console di gestione AWS
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Prova la funzione Lambda creata dal file.zip. | Per testare la funzione Lambda creata dal file.zip, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/import-psycopg2-library-lambda.html)Poiché Lambda non trova le librerie PostgreSQL richieste nell'immagine predefinita, non può utilizzare la libreria. `psycopg2` | Informazioni generali su AWS |
| Prova la funzione Lambda creata dal Dockerfile. | Per utilizzare la `psycopg2` libreria all'interno della tua funzione Lambda, devi modificare l'Amazon Machine Image (AMI) Lambda.Per testare la funzione Lambda creata dal Dockerfile, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/import-psycopg2-library-lambda.html)Il codice seguente mostra il Dockerfile creato dal AWS CDK modello:# Start from lambda Python3.13 image
FROM public.ecr.aws/lambda/python:3.13
# Copy the lambda code, together with its requirements
COPY lambda/requirements.txt ${LAMBDA_TASK_ROOT}
COPY lambda/lambda_code.py ${LAMBDA_TASK_ROOT}
# Install postgresql-devel in your image
RUN yum install -y gcc postgresql-devel
# install the requirements for the Lambda code
RUN pip3 install -r requirements.txt --target "${LAMBDA_TASK_ROOT}"
# Command can be overwritten by providing a different command in the template directly.
CMD ["lambda_code.handler"]
Il Dockerfile prende l'immagine AWS Lambda fornita per il runtime Python e installa [postgresql-devel](https://yum-info.contradodigital.com/view-package/updates/postgresql-devel/), che contiene le librerie necessarie per compilare applicazioni che interagiscono direttamente con il server di gestione PostgreSQL. Il Dockerfile installa anche le librerie and, indicate nel file. `pandas` `psycopg2` `requirements.txt` | Informazioni generali su AWS |
## Risorse correlate
+ [AWS CDK documentazione](https://docs.aws.amazon.com/cdk/v2/guide/home.html)
+ [AWS Lambda documentazione](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)
## Informazioni aggiuntive
In questo modello, il AWS CDK modello fornisce uno AWS stack con tre risorse:
+ Un [ruolo AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) per le funzioni Lambda.
+ Una funzione Lambda con un runtime Python. La funzione viene distribuita dal pacchetto di distribuzione. `Constructs/lambda/lambda_deploy.zip`
+ Una funzione Lambda con un runtime Python. La funzione viene distribuita dal Dockerfile nella cartella `Constructs`
Lo script per entrambe le funzioni Lambda verifica se le `psycopg2` librerie `pandas` and sono state importate correttamente:
```
import pandas
print("pandas successfully imported")
import psycopg2
print("psycopg2 successfully imported")
def handler(event, context):
"""Function that checks whether psycopg2 and pandas are successfully imported or not"""
return {"Status": "psycopg2 and pandas successfully imported"}
```
Il pacchetto `lambda_deploy.zip` di distribuzione è creato con lo script `Constructs/lambda/build.sh` bash. Questo script crea una cartella, copia lo script Lambda, installa le `psycopg2` librerie `pandas` and e genera il file.zip. Per generare tu stesso il file.zip, esegui questo script bash e ridistribuisci lo stack. AWS CDK
Il Dockerfile inizia con l'immagine di base AWS fornita per Lambda con un runtime Python. Il Dockerfile installa le `psycopg2` librerie `pandas` and sopra l'immagine predefinita.
# Integra Amazon API Gateway con Amazon SQS per gestire REST asincrono APIs
*Natalia Colantonio Favero e Gustavo Martim, Amazon Web Services*
## Riepilogo
Quando si distribuisce REST APIs, a volte è necessario esporre una coda di messaggi che le applicazioni client possono pubblicare. Ad esempio, potreste avere problemi con la latenza di terze parti APIs e i ritardi nelle risposte, oppure potreste voler evitare i tempi di risposta delle query del database o evitare il ridimensionamento del server quando il numero di richieste simultanee è elevato. APIs In questi scenari, le applicazioni client che pubblicano nella coda devono solo sapere che l'API ha ricevuto i dati, non cosa accade dopo la ricezione dei dati.
Questo modello crea un endpoint API REST utilizzando [Amazon API Gateway](https://aws.amazon.com/api-gateway/) per inviare un messaggio ad [Amazon Simple Queue Service (Amazon SQS)](https://aws.amazon.com/sqs/). Crea un' easy-to-implementintegrazione tra i due servizi che evita l'accesso diretto alla coda SQS.
## Prerequisiti e limitazioni
+ [Un account attivo AWS](https://portal.aws.amazon.com/billing/signup/iam)
## Architecture
![\[Architettura per l'integrazione di API Gateway con Amazon SQS\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/70984dee-e49f-4446-9d52-49ce826c3909/images/737ba0b2-da8f-4478-8c54-0a4835fd69f9.png)
Il diagramma illustra questi passaggi:
1. Richiedi un endpoint dell'API POST REST utilizzando uno strumento come Postman, un'altra API o altre tecnologie.
1. API Gateway pubblica un messaggio, che viene ricevuto nel corpo della richiesta, sulla coda.
1. Amazon SQS riceve il messaggio e invia una risposta ad API Gateway con un codice di successo o di errore.
## Tools (Strumenti)
+ [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) ti aiuta a creare, pubblicare, gestire, monitorare e proteggere REST, HTTP e WebSocket APIs su qualsiasi scala.
+ [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ti aiuta a gestire in modo sicuro l'accesso alle tue AWS risorse controllando chi è autenticato e autorizzato a utilizzarle.
+ [Amazon Simple Queue Service (Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html)) fornisce una coda ospitata sicura, durevole e disponibile che ti aiuta a integrare e disaccoppiare sistemi e componenti software distribuiti.
## Epiche
### Crea una coda SQS
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea una coda. | Per creare una coda SQS che riceva i messaggi dall'API REST:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/integrate-amazon-api-gateway-with-amazon-sqs-to-handle-asynchronous-rest-apis.html) | Sviluppatore di app |
### Fornisci l'accesso ad Amazon SQS
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un ruolo IAM. | Questo ruolo IAM offre alle risorse API Gateway l'accesso completo ad Amazon SQS.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/integrate-amazon-api-gateway-with-amazon-sqs-to-handle-asynchronous-rest-apis.html) | Sviluppatore di app, amministratore AWS |
### Crea un'API REST
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un'API REST. | Questa è l'API REST a cui vengono inviate le richieste HTTP.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/integrate-amazon-api-gateway-with-amazon-sqs-to-handle-asynchronous-rest-apis.html) | Sviluppatore di app |
| Connetti API Gateway ad Amazon SQS. | Questo passaggio consente al messaggio di fluire dall'interno del corpo della richiesta HTTP ad Amazon SQS.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/integrate-amazon-api-gateway-with-amazon-sqs-to-handle-asynchronous-rest-apis.html) | Sviluppatore di app |
### Prova l'API REST
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Prova l'API REST. | Esegui un test per verificare la configurazione mancante:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/integrate-amazon-api-gateway-with-amazon-sqs-to-handle-asynchronous-rest-apis.html) | Sviluppatore di app |
| Modifica l'integrazione dell'API per inoltrare correttamente la richiesta ad Amazon SQS. | Completa la configurazione per correggere l'errore di integrazione:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/integrate-amazon-api-gateway-with-amazon-sqs-to-handle-asynchronous-rest-apis.html) | Sviluppatore di app |
| Testa e convalida il messaggio in Amazon SQS. | Esegui un test per confermare che il test è stato completato con successo:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/integrate-amazon-api-gateway-with-amazon-sqs-to-handle-asynchronous-rest-apis.html) | Sviluppatore di app |
| Prova API Gateway con un carattere speciale. | Esegui un test che includa caratteri speciali (come &) che non sono accettabili in un messaggio:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/integrate-amazon-api-gateway-with-amazon-sqs-to-handle-asynchronous-rest-apis.html)Questo perché i caratteri speciali non sono supportati per impostazione predefinita nel corpo del messaggio. Nel passaggio successivo, configurerai API Gateway per supportare i caratteri speciali. Per ulteriori informazioni sulle conversioni dei tipi di contenuto, consulta la [documentazione di API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-payload-encodings-workflow.html). | Sviluppatore di app |
| Modifica la configurazione dell'API per supportare i caratteri speciali. | Modifica la configurazione per accettare caratteri speciali nel messaggio:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/integrate-amazon-api-gateway-with-amazon-sqs-to-handle-asynchronous-rest-apis.html)Il nuovo messaggio deve includere il carattere speciale. | Sviluppatore di app |
### Implementa l'API REST
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Implementa l'API. | Per distribuire l'API REST:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/integrate-amazon-api-gateway-with-amazon-sqs-to-handle-asynchronous-rest-apis.html) | Sviluppatore di app |
| Esegui il test con uno strumento esterno. | Esegui un test con uno strumento esterno per confermare che il messaggio sia stato ricevuto correttamente:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/integrate-amazon-api-gateway-with-amazon-sqs-to-handle-asynchronous-rest-apis.html) | Sviluppatore di app |
### Pulizia
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Eliminare l'API. | Nella [console API Gateway](https://console.aws.amazon.com/apigateway/), scegli l'API che hai creato, quindi scegli **Elimina**. | Sviluppatore di app |
| Elimina il ruolo IAM. | Sulla [console IAM](https://console.aws.amazon.com/iam/), nel riquadro **Ruoli**, seleziona **AWSGatewayRoleForSQS**, quindi scegli **Elimina**. | Sviluppatore di app |
| Elimina la coda SQS. | **Sulla [console Amazon SQS](https://console.aws.amazon.com/sqs/), nel riquadro Code, scegli la **coda** SQS che hai creato, quindi scegli Elimina.** | Sviluppatore di app |
## Risorse correlate
+ [SQS- SendMessage](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-aws-services-reference.html#SQS-SendMessage) (documentazione API Gateway)
+ [Conversioni dei tipi di contenuto in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-payload-encodings-workflow.html) (documentazione API Gateway)
+ [variabili \$1util (documentazione](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html#util-template-reference) API Gateway)
+ [Come posso integrare un'API REST di API Gateway con Amazon SQS e risolvere gli errori più comuni?](https://repost.aws/knowledge-center/api-gateway-rest-api-sqs-errors) (AWS Re:post articolo)
# Elabora gli eventi in modo asincrono con Amazon API Gateway e AWS Lambda
*Andrea Meroni, Mariem Kthiri, Nadim Majed e Michael Wallner, Amazon Web Services*
## Riepilogo
[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 elaborare gli eventi in modo asincrono utilizzando API Gateway e. AWS Lambda L'architettura supporta l'esecuzione di processi di elaborazione della durata fino a 15 minuti e utilizza un'API REST di base come interfaccia.
[Projen](https://pypi.org/project/projen/) [viene utilizzato per configurare l'ambiente di sviluppo locale e per distribuire l'architettura di esempio su un target Account AWS, in combinazione con [AWS Cloud Development Kit (AWS CDK) Toolkit](https://docs.aws.amazon.com/cdk/v2/guide/cli.html), [Docker](https://docs.docker.com/get-docker/) e Node.js.](https://nodejs.org/en/download/) 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.](#process-events-asynchronously-with-amazon-api-gateway-and-aws-lambda-tools)
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un attivo Account AWS
+ I seguenti strumenti installati sulla workstation:
+ [AWS Cloud Development Kit (AWS CDK) Toolkit versione 2.85.0](https://docs.aws.amazon.com/cdk/v2/guide/cli.html)
+ [Docker versione 20.10.21](https://docs.docker.com/get-docker/)
+ [Node.js versione 18.13.0](https://nodejs.org/en/download/)
+ [Versione del progetto 0.71.111](https://pypi.org/project/projen/)
+ [Python versione 3.9.16](https://www.python.org/downloads/)
**Limitazioni**
+ 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 della funzione Lambda.
## Architecture
Il diagramma seguente mostra l'interazione dell'API jobs con le funzioni Lambda di elaborazione degli eventi e gestione degli errori, con gli eventi archiviati in un archivio di eventi Amazon. EventBridge
![\[Cloud AWS architecture showing user interaction with jobs API, Lambda functions, and EventBridge.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/e027130c-44c1-41ab-bbe9-f196a49bd9ac/images/3c437b65-48e3-477d-aeea-6ff938cc3285.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, che è un'API REST di API Gateway, ti restituisce una risposta HTTP che contiene l'identificatore del lavoro.
1. L'API jobs richiama in modo asincrono la funzione Lambda di elaborazione degli eventi.
1. La funzione di elaborazione degli eventi elabora l'evento e quindi inserisce i risultati del lavoro nella tabella dei job Amazon DynamoDB.
1. 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` 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 funzione di elaborazione degli eventi invia l'evento alla funzione di gestione degli errori.
1. La funzione di gestione degli errori inserisce i parametri del lavoro nella tabella DynamoDB`jobs`.
1. È 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 di eventi. EventBridge
È possibile riprodurre gli eventi archiviati utilizzando. EventBridge
## Tools (Strumenti)
**Servizi AWS**
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html)è un framework di sviluppo software che consente di definire e fornire l' Cloud AWS infrastruttura nel codice.
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) è uno strumento open source che ti aiuta a interagire con i servizi AWS tramite comandi nella shell della riga di comando.
+ [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 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 elaborazione che utilizzi.
**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 nell'archivio GitHub [Asynchronous Event Processing with API Gateway e Lambda](https://github.com/aws-samples/asynchronous-event-processing-api-gateway-lambda-cdk).
## Best practice
+ 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:
+ Amazon 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 dell'input e un maggiore livello di sicurezza, valuta [l'utilizzo di AWS WAF per proteggere](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-control-access-aws-waf.html) la tua API.
## Epiche
### Configura l'ambiente
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clonare il repository. | Per clonare il repository localmente, esegui il seguente comando:git clone https://github.com/aws-samples/asynchronous-event-processing-api-gateway-lambda-cdk.git
| 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)cd asynchronous-event-processing-api-gateway-api-gateway-lambda-cdk
npx projen
| 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/process-events-asynchronously-with-amazon-api-gateway-and-aws-lambda.html) | DevOps ingegnere |
### Implementa l'architettura di esempio
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Bootstrap. AWS CDK | Per eseguire il bootstrap AWS CDK in tuo Account AWS, esegui il seguente comando:AWS_PROFILE=$YOUR_AWS_PROFILE npx projen bootstrap
| AWS DevOps |
| Implementa l'architettura di esempio. | Per implementare l'architettura di esempio nella tua Account AWS, esegui il seguente comando:AWS_PROFILE=$YOUR_AWS_PROFILE npx projen deploy
| AWS DevOps |
### Testa l'architettura
| 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/)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 Version 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](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-export-api.html) l'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 comando deploy:CREDENTIALS=$(AWS_PROFILE=$ aws sts assume-role \
--no-cli-pager \
--role-arn $ \
--role-session-name JobsAPIInvoke)
export AWS_ACCESS_KEY_ID=$(cat $CREDENTIALS | jq ‘.Credentials’’.AccessKeyId’)
export AWS_SECRET_ACCESS_KEY=$(cat $CREDENTIALS | jq ‘.Credentials’’.SecretAccessKey’)
export AWS_SESSION_TOKEN==$(cat $CREDENTIALS | jq ‘.Credentials’’.SessionToken’)
| AWS DevOps |
| Configura Postman. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/process-events-asynchronously-with-amazon-api-gateway-and-aws-lambda.html) | AWS DevOps |
| Prova l'architettura di esempio. | Per testare l'architettura di esempio, [invia le richieste](https://learning.postman.com/docs/sending-requests/requests/#next-steps) 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
| 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/process-events-asynchronously-with-amazon-api-gateway-and-aws-lambda.html) |
## Risorse correlate
+ [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)
+ [Imposta la chiamata asincrona della funzione Lambda di backend](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-integration-async.html)
# Elabora gli eventi in modo asincrono con Amazon API Gateway e Amazon DynamoDB Streams
*Andrea Meroni, Mariem Kthiri, Nadim Majed, Alessandro Trisolini e Michael Wallner, Amazon Web Services*
## Riepilogo
[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
**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
**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)
**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
+ 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
### Configura l'ambiente
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clonare il repository. | Per clonare il repository localmente, esegui il seguente comando:git clone https://github.com/aws-samples/asynchronous-event-processing-api-gateway-dynamodb-streams-cdk.git
| 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)cd asynchronous-event-processing-api-gateway-api-gateway-dynamodb-streams-cdk
npx projen
| 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
| 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:AWS_PROFILE=$YOUR_AWS_PROFILE npx projen bootstrap
| AWS DevOps |
| Implementa l'architettura di esempio. | Per implementare l'architettura di esempio nella tua Account AWS, esegui il seguente comando:AWS_PROFILE=$YOUR_AWS_PROFILE npx projen deploy
| AWS DevOps |
### Testa l'architettura
| 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/)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:CREDENTIALS=$(AWS_PROFILE=$ aws sts assume-role \
--no-cli-pager \
--role-arn $ \
--role-session-name JobsAPIInvoke)
export AWS_ACCESS_KEY_ID=$(cat $CREDENTIALS | jq ‘.Credentials’’.AccessKeyId’)
export AWS_SECRET_ACCESS_KEY=$(cat $CREDENTIALS | jq ‘.Credentials’’.SecretAccessKey’)
export AWS_SESSION_TOKEN==$(cat $CREDENTIALS | jq ‘.Credentials’’.SessionToken’)
| 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
| 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
+ [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)
# Elabora gli eventi in modo asincrono con Amazon API Gateway, Amazon SQS e AWS Fargate
*Andrea Meroni, Mariem Kthiri, Nadim Majed, Alessandro Trisolini e Michael Wallner, Amazon Web Services*
## Riepilogo
[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à necessarie per accettare ed elaborare 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 elaborare gli eventi in modo asincrono utilizzando API Gateway, Amazon Simple Queue Service (Amazon SQS) e. AWS Fargate L'architettura supporta l'esecuzione di processi di elaborazione senza restrizioni di durata e utilizza un'API REST di base come interfaccia.
[Projen](https://pypi.org/project/projen/) [viene utilizzato per configurare l'ambiente di sviluppo locale e per distribuire l'architettura di esempio su una destinazione Account AWS, in combinazione con [Docker](https://docs.docker.com/get-docker/) e Node.js. [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/cli.html)](https://nodejs.org/en/download/) 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.](#process-events-asynchronously-with-amazon-api-gateway-amazon-sqs-and-aws-fargate-tools)
## Prerequisiti e limitazioni
**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**
+ I lavori simultanei sono limitati a 500 attività al minuto, che è il numero massimo di attività che Fargate può fornire.
## Architecture
Il diagramma seguente mostra l'interazione dell'API jobs con la tabella `jobs` Amazon DynamoDB, il servizio Fargate di elaborazione degli eventi e la funzione di gestione degli errori. AWS Lambda Gli eventi vengono archiviati in un archivio di EventBridge eventi Amazon.
![\[Diagramma di architettura con descrizione che segue il diagramma.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/8a03149c-8f34-4593-84d5-accc1800a0a2/images/5e1071aa-4fbc-495c-bc22-8e62a32a136b.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, che è un'API REST di API Gateway, ti restituisce una risposta HTTP che contiene l'identificatore del lavoro.
1. L'API jobs invia un messaggio alla coda SQS.
1. Fargate estrae il messaggio dalla coda SQS, elabora l'evento e quindi inserisce i risultati del lavoro nella tabella DynamoDB. `jobs`
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` 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 coda SQS invia l'evento alla coda di lettere morte (DLQ).
1. Un EventBridge evento avvia la funzione di gestione degli errori.
1. La funzione di gestione degli errori inserisce i parametri del lavoro nella tabella DynamoDB`jobs`.
1. È 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. EventBridge
È possibile riprodurre gli eventi archiviati utilizzando. EventBridge
## Tools (Strumenti)
**Servizi AWS**
+ [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/home.html)è un framework di sviluppo software che consente di definire e fornire l' Cloud AWS infrastruttura nel 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.
+ [AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/userguide/what-is-fargate.html)ti aiuta a eseguire contenitori senza dover gestire server o istanze Amazon Elastic Compute Cloud EC2 (Amazon). Viene utilizzato insieme ad Amazon Elastic Container Service (Amazon ECS).
+ [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 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 elaborazione che utilizzi.
+ [Amazon Simple Queue Service (Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html)) fornisce una coda ospitata sicura, durevole e disponibile che ti aiuta a integrare e disaccoppiare sistemi e componenti software distribuiti.
**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 nell'archivio GitHub [Asynchronous Processing with API Gateway e](https://github.com/aws-samples/asynchronous-event-processing-api-gateway-sqs-cdk) SQS.
## Best practice
+ 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.
## Epiche
### Configura l'ambiente
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clonare il repository. | Per clonare il repository localmente, esegui il seguente comando:git clone https://github.com/aws-samples/asynchronous-event-processing-api-gateway-sqs-cdk.git
| 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)cd asynchronous-event-processing-api-gateway-api-gateway-sqs-cdk
npx projen
| 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/process-events-asynchronously-with-amazon-api-gateway-amazon-sqs-and-aws-fargate.html) | DevOps ingegnere |
### Implementa l'architettura di esempio
| 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:AWS_PROFILE=$YOUR_AWS_PROFILE npx projen bootstrap
| AWS DevOps |
| Implementa l'architettura di esempio. | Per implementare l'architettura di esempio nella tua Account AWS, esegui il seguente comando:AWS_PROFILE=$YOUR_AWS_PROFILE npx projen deploy
| AWS DevOps |
### Testa l'architettura
| 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/)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 Version 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](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-export-api.html) l'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:CREDENTIALS=$(AWS_PROFILE=$ aws sts assume-role \
--no-cli-pager \
--role-arn $ \
--role-session-name JobsAPIInvoke)
export AWS_ACCESS_KEY_ID=$(cat $CREDENTIALS | jq ‘.Credentials’’.AccessKeyId’)
export AWS_SECRET_ACCESS_KEY=$(cat $CREDENTIALS | jq ‘.Credentials’’.SecretAccessKey’)
export AWS_SESSION_TOKEN==$(cat $CREDENTIALS | jq ‘.Credentials’’.SessionToken’)
| AWS DevOps |
| Configura Postman. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/process-events-asynchronously-with-amazon-api-gateway-amazon-sqs-and-aws-fargate.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
| 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/process-events-asynchronously-with-amazon-api-gateway-amazon-sqs-and-aws-fargate.html) |
| La distruzione e la successiva ridistribuzione dell'architettura di esempio non riescono perché il gruppo di [log CloudWatch Logs esiste già.](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) `/aws/ecs/EventProcessingServiceLogs` | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/process-events-asynchronously-with-amazon-api-gateway-amazon-sqs-and-aws-fargate.html) |
## Risorse correlate
+ [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)
+ [Come posso integrare un'API REST di API Gateway con Amazon SQS e risolvere gli errori più comuni?](https://aws.amazon.com/premiumsupport/knowledge-center/api-gateway-rest-api-sqs-errors/)
# Esegui le attività di AWS Systems Manager Automation in modo sincrono da AWS Step Functions
*Elie El Khoury, Amazon Web Services*
## Riepilogo
Questo modello spiega come eseguire l'integrazione con. AWS Step Functions AWS Systems Manager Utilizza le integrazioni dei servizi AWS SDK per chiamare l'**startAutomationExecution**API Systems Manager con un token di attività da un flusso di lavoro di una macchina a stati e si interrompe fino a quando il token non restituisce una chiamata riuscita o non riuscita. Per dimostrare l'integrazione, questo modello implementa un wrapper di documenti di automazione (runbook) attorno al documento or e lo utilizza per chiamare `AWS-RunShellScript` o in modo `AWS-RunPowerShellScript` sincrono. `.waitForTaskToken` `AWS-RunShellScript` `AWS-RunPowerShellScript` Per ulteriori informazioni sulle integrazioni dei servizi AWS SDK in Step Functions, consulta la Guida per gli [AWS Step Functions sviluppatori](https://docs.aws.amazon.com/step-functions/latest/dg/supported-services-awssdk.html).
Step Functions**** è un servizio di flusso di lavoro visivo a basso codice che puoi utilizzare per creare applicazioni distribuite, automatizzare i processi IT e aziendali e creare pipeline di dati e apprendimento automatico utilizzando i servizi. AWS I flussi di lavoro gestiscono gli errori, i nuovi tentativi, la parallelizzazione, le integrazioni dei servizi e l'osservabilità in modo da poterti concentrare su una logica aziendale di maggior valore.
L'automazione, una funzionalità di AWS Systems Manager, semplifica le attività comuni di manutenzione, distribuzione e riparazione per Servizi AWS Amazon Elastic Compute Cloud (Amazon EC2), Amazon Relational Database Service (Amazon RDS), Amazon Redshift e Amazon Simple Storage Service (Amazon S3). L'automazione ti offre un controllo granulare sulla concomitanza delle tue automazioni. Ad esempio, è possibile specificare quante risorse indirizzare contemporaneamente e quanti errori possono verificarsi prima che un'automazione venga interrotta.
Per i dettagli di implementazione, inclusi i passaggi del runbook, i parametri e gli esempi, consulta la sezione [Informazioni aggiuntive](#run-aws-systems-manager-automation-tasks-synchronously-from-aws-step-functions-additional).
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un account attivo AWS
+ AWS Identity and Access Management Autorizzazioni (IAM) per accedere a Step Functions and Systems Manager
+ Un' EC2 istanza con Systems Manager Agent (SSM Agent) [installato](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-install-ssm-agent.html) sull'istanza
+ [Un profilo di istanza IAM per Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/setup-instance-profile.html) collegato all'istanza in cui intendi eseguire il runbook
+ Un ruolo Step Functions con le seguenti autorizzazioni IAM (che seguono il principio del privilegio minimo):
```
{
"Effect": "Allow",
"Action": "ssm:StartAutomationExecution",
"Resource": "*"
}
```
**Versioni del prodotto**
+ Schema del documento SSM versione 0.3 o successiva
+ SSM Agent versione 2.3.672.0 o successiva
## Architecture
**Stack tecnologico Target**
+ AWS Step Functions
+ Automazione di AWS Systems Manager
**Architettura di destinazione**
![\[Architettura per l'esecuzione sincrona delle attività di automazione di Systems Manager da Step Functions\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/47c19e4f-d68d-4f91-bb68-202098757529/images/2d248aae-d858-4565-8af2-593cde0da780.png)
**Automazione e scalabilità**
+ Questo modello fornisce un AWS CloudFormation modello che è possibile utilizzare per distribuire i runbook su più istanze. (Vedi l'archivio di [implementazione di GitHub Step Functions and Systems Manager](https://github.com/aws-samples/amazon-stepfunctions-ssm-waitfortasktoken).)
## Tools (Strumenti)
**Servizi AWS**
+ [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)ti aiuta a configurare AWS le risorse, fornirle in modo rapido e coerente e gestirle durante tutto il loro ciclo di vita in tutte le regioni Account AWS .
+ [AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html) ti aiuta a gestire in modo sicuro l'accesso alle tue AWS risorse controllando chi è autenticato e autorizzato a utilizzarle.
+ [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html)è un servizio di orchestrazione senza server che consente di combinare AWS Lambda funzioni e altro Servizi AWS per creare applicazioni aziendali critiche.
+ [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html)consente di gestire le applicazioni e l'infrastruttura in esecuzione in. Cloud AWS Semplifica la gestione delle applicazioni e delle risorse, riduce i tempi di rilevamento e risoluzione dei problemi operativi e aiuta a gestire le AWS risorse in modo sicuro su larga scala.
**Codice**
Il codice per questo modello è disponibile nell'archivio di [implementazione di GitHub Step Functions and Systems Manager](https://github.com/aws-samples/amazon-stepfunctions-ssm-waitfortasktoken).
## Epiche
### Crea runbook
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Scarica il CloudFormation modello. | Scarica il `ssm-automation-documents.cfn.json` modello dalla `cloudformation ` cartella del GitHub repository. | AWS DevOps |
| Crea runbook. | Accedi a Console di gestione AWS, apri la [CloudFormation console](https://console.aws.amazon.com/cloudformation/) e distribuisci il modello. Per ulteriori informazioni sulla distribuzione dei CloudFormation modelli, consulta [Creazione di uno stack sulla CloudFormation console nella documentazione](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-create-stack.html). CloudFormation Il CloudFormation modello distribuisce tre risorse:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/run-aws-systems-manager-automation-tasks-synchronously-from-aws-step-functions.html) | AWS DevOps |
### Crea un esempio di macchina a stati
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea una macchina a stati di test. | Segui le istruzioni contenute nella [Guida per gli AWS Step Functions sviluppatori](https://docs.aws.amazon.com/step-functions/latest/dg/getting-started-with-sfn.html) per creare ed eseguire una macchina a stati. Per la definizione, utilizzate il codice seguente. Assicurati di aggiornare il `InstanceIds` valore con l'ID di un'istanza valida abilitata per Systems Manager nel tuo account.{
"Comment": "A description of my state machine",
"StartAt": "StartAutomationWaitForCallBack",
"States": {
"StartAutomationWaitForCallBack": {
"Type": "Task",
"Resource": "arn:aws:states:::aws-sdk:ssm:startAutomationExecution.waitForTaskToken",
"Parameters": {
"DocumentName": "SfnRunCommandByInstanceIds",
"Parameters": {
"InstanceIds": [
"i-1234567890abcdef0"
],
"taskToken.$": "States.Array($$.Task.Token)",
"workingDirectory": [
"/home/ssm-user/"
],
"Commands": [
"echo \"This is a test running automation waitForTaskToken\" >> automation.log",
"sleep 100"
],
"executionTimeout": [
"10800"
],
"deliveryTimeout": [
"30"
],
"shell": [
"Shell"
]
}
},
"End": true
}
}
}Questo codice richiama il runbook per eseguire due comandi che dimostrano la `waitForTaskToken` chiamata a Systems Manager Automation.Il valore del `shell` parametro (`Shell`o`PowerShell`) determina se il documento di automazione viene eseguito `AWS-RunShellScript` o`AWS-RunPowerShellScript`.L'attività scrive «Questo è un waitForTask token di automazione in esecuzione di test» nel `/home/ssm-user/automation.log` file, quindi rimane inattiva per 100 secondi prima di rispondere con il token dell'attività e rilasciare l'attività successiva del flusso di lavoro.Se invece vuoi chiamare il `SfnRunCommandByTargets` runbook, sostituisci la `Parameters` sezione del codice precedente con la seguente:"Parameters": {
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE",
"i-0471e04240EXAMPLE"
]
}
], | AWS DevOps |
| Aggiorna il ruolo IAM per la macchina a stati. | Il passaggio precedente crea automaticamente un ruolo IAM dedicato per la macchina a stati. Tuttavia, non concede le autorizzazioni per chiamare il runbook. Aggiorna il ruolo aggiungendo le seguenti autorizzazioni:{
"Effect": "Allow",
"Action": "ssm:StartAutomationExecution",
"Resource": "*"
} | AWS DevOps |
| Convalida le chiamate sincrone. | Esegui la macchina a stati per convalidare la chiamata sincrona tra Step Functions e Systems Manager Automation. Per un esempio di output, vedere la sezione [Informazioni aggiuntive](#run-aws-systems-manager-automation-tasks-synchronously-from-aws-step-functions-additional). | AWS DevOps |
## Risorse correlate
+ [Guida introduttiva a AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/getting-started-with-sfn.html) (*Guida per AWS Step Functions sviluppatori*)
+ [Attendi una richiamata con il task token](https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token) (*Guida per AWS Step Functions gli sviluppatori*, modelli di integrazione dei servizi)
+ [chiamate API send\$1task\$1success e send\$1task\$1failure](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/stepfunctions/client/send_task_success.html) [(documentazione Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/stepfunctions/client/send_task_failure.html)
+ [AWS Systems Manager Automazione (guida AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-automation.html) *per l'utente)*
## Informazioni aggiuntive
**Dettagli di implementazione**
Questo modello fornisce un CloudFormation modello che implementa due runbook di Systems Manager:
+ `SfnRunCommandByInstanceIds`esegue il `AWS-RunPowerShellScript` comando `AWS-RunShellScript` or utilizzando instance. IDs
+ `SfnRunCommandByTargets`esegue il `AWS-RunPowerShellScript` comando `AWS-RunShellScript` or utilizzando target.
Ogni runbook implementa quattro passaggi per eseguire una chiamata sincrona quando si utilizza l'`.waitForTaskToken`opzione in Step Functions.
|
|
| Fase | Azione | Description |
| --- |--- |--- |
| **1** | `Branch` | Controlla il valore del `shell` parametro (`Shell`o`PowerShell`) per decidere se eseguire per Linux o `AWS-RunShellScript` `AWS-RunPowerShellScript` per Windows. |
| **2** | `RunCommand_Shell` o `RunCommand_PowerShell` | Accetta diversi input ed esegue il `RunPowerShellScript` comando `RunShellScript` or. Per ulteriori informazioni, consulta la scheda **Dettagli** per il documento `RunCommand_Shell` o `RunCommand_PowerShell` Automation nella console Systems Manager. |
| **3** | `SendTaskFailure` | Viene eseguito quando il passaggio 2 viene interrotto o annullato. Richiama l'API [send\$1task\$1failure](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/stepfunctions/client/send_task_failure.html) di Step Functions, che accetta tre parametri come input: il token passato dalla macchina a stati, l'errore di errore e una descrizione della causa dell'errore. |
| **4** | `SendTaskSuccess` | Viene eseguito quando il passaggio 2 ha esito positivo. Chiama l'API Step Functions [send\$1task\$1success](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/stepfunctions/client/send_task_success.html), che accetta il token passato dalla macchina a stati come input. |
**Parametri del runbook**
`SfnRunCommandByInstanceIds`runbook:
|
|
| Nome del parametro | Tipo | Facoltativo o richiesto | Description |
| --- |--- |--- |--- |
| `shell` | Stringa | Richiesto | La shell delle istanze per decidere se eseguire `AWS-RunShellScript` per Linux o `AWS-RunPowerShellScript` per Windows. |
| `deliveryTimeout` | Numero intero | Facoltativo | Il tempo, in secondi, di attesa per l'invio di un comando all'agente SSM su un'istanza. Questo parametro ha un valore minimo di 30 (0,5 minuti) e un valore massimo di 2592000 (720 ore). |
| `executionTimeout` | Stringa | Facoltativo | Il tempo, in secondi, necessario per il completamento di un comando prima che venga considerato non riuscito. Il valore predefinito è 3600 (1 ora). Il valore massimo è 172800 (48 ore). |
| `workingDirectory` | Stringa | Facoltativo | Il percorso alla directory di lavoro nell'istanza. |
| `Commands` | StringList | Richiesto | Lo script o il comando di shell da eseguire. |
| `InstanceIds` | StringList | Richiesto | Le IDs istanze in cui si desidera eseguire il comando. |
| `taskToken` | Stringa | Richiesto | Il token di attività da utilizzare per le risposte di callback. |
`SfnRunCommandByTargets`runbook:
|
|
| Name | Tipo | Facoltativo o richiesto | Description |
| --- |--- |--- |--- |
| `shell` | Stringa | Richiesto | La shell delle istanze per decidere se eseguire `AWS-RunShellScript` per Linux o `AWS-RunPowerShellScript` per Windows. |
| `deliveryTimeout` | Numero intero | Facoltativo | Il tempo, in secondi, di attesa per l'invio di un comando all'agente SSM su un'istanza. Questo parametro ha un valore minimo di 30 (0,5 minuti) e un valore massimo di 2592000 (720 ore). |
| `executionTimeout` | Numero intero | Facoltativo | Il tempo, in secondi, necessario per il completamento di un comando prima che venga considerato non riuscito. Il valore predefinito è 3600 (1 ora). Il valore massimo è 172800 (48 ore). |
| `workingDirectory` | Stringa | Facoltativo | Il percorso alla directory di lavoro nell'istanza. |
| `Commands` | StringList | Richiesto | Lo script o il comando di shell da eseguire. |
| `Targets` | MapList | Richiesto | Una matrice di criteri di ricerca che identifica le istanze utilizzando coppie chiave-valore specificate dall'utente. Ad esempio: `[{"Key":"InstanceIds","Values":["i-02573cafcfEXAMPLE","i-0471e04240EXAMPLE"]}]` |
| `taskToken` | Stringa | Richiesto | Il token di attività da utilizzare per le risposte di callback. |
**Esempio di output**
La tabella seguente fornisce un esempio di output della funzione step. Mostra che il tempo di esecuzione totale è superiore a 100 secondi tra il passaggio 5 (`TaskSubmitted`) e il passaggio 6 (`TaskSucceeded`). Ciò dimostra che la funzione step ha atteso il completamento del `sleep 100` comando prima di passare all'attività successiva del flusso di lavoro.
|
|
| ID | Tipo | Fase | Risorsa | Tempo trascorso (ms) | Time stamp |
| --- |--- |--- |--- |--- |--- |
| **1** | `ExecutionStarted` | | - | 0 | 11 marzo 2022 14:50:34.303 |
| **2** | `TaskStateEntered` | `StartAutomationWaitForCallBack` | - | 40 | 11 marzo 2022 14:50:34.343 |
| **3** | `TaskScheduled` | `StartAutomationWaitForCallBack` | - | 40 | 11 marzo 2022 14:50:34.343 |
| **4** | `TaskStarted` | `StartAutomationWaitForCallBack` | - | 154 | 11 marzo 2022 14:50:34.457 |
| **5** | `TaskSubmitted` | `StartAutomationWaitForCallBack` | - | 657 | 11 marzo 2022 14:50:34.960 |
| **6** | `TaskSucceeded` | `StartAutomationWaitForCallBack` | - | 103835 | 11 marzo 2022 14:52:18.138 |
| **7** | `TaskStateExited` | `StartAutomationWaitForCallBack` | - | 103860 | 11 marzo 2022 02:52:18.163 |
| **8** | `ExecutionSucceeded` | | - | 103897 | 11 marzo 2022 14:52:18.200 |
# Esegui letture parallele di oggetti S3 usando Python in una funzione AWS Lambda
*Eduardo Bortoluzzi, Amazon Web Services*
## Riepilogo
Puoi utilizzare questo modello per recuperare e riepilogare un elenco di documenti dai bucket Amazon Simple Storage Service (Amazon S3) in tempo reale. Il modello fornisce codice di esempio per oggetti di lettura parallela dai bucket S3 su Amazon Web Services ()AWS. Il modello mostra come eseguire in modo efficiente attività I/O associate con AWS Lambda funzioni utilizzando Python.
Una società finanziaria ha utilizzato questo modello in una soluzione interattiva per approvare o rifiutare manualmente le transazioni finanziarie correlate in tempo reale. I documenti relativi alle transazioni finanziarie sono stati archiviati in un bucket S3 relativo al mercato. Un operatore ha selezionato un elenco di documenti dal bucket S3, ha analizzato il valore totale delle transazioni calcolate dalla soluzione e ha deciso di approvare o rifiutare il batch selezionato.
Le attività legate all'I/O supportano più thread. [In questo codice di esempio, concurrent.futures. ThreadPoolExecutor](https://docs.python.org/3.13/library/concurrent.futures.html#concurrent.futures.ThreadPoolExecutor)viene utilizzato con un massimo di 30 thread simultanei, anche se le funzioni Lambda supportano fino a 1.024 thread (uno di questi thread è il processo principale). Questo limite è dovuto al fatto che troppi thread creano problemi di latenza dovuti al cambio di contesto e all'utilizzo delle risorse di elaborazione. È inoltre necessario aumentare il numero massimo di connessioni al pool in `botocore` modo che tutti i thread possano eseguire il download dell'oggetto S3 contemporaneamente.
Il codice di esempio utilizza un oggetto da 8,3 KB, con dati JSON, in un bucket S3. L'oggetto viene letto più volte. Dopo che la funzione Lambda ha letto l'oggetto, i dati JSON vengono decodificati in un oggetto Python. Nel dicembre 2024, il risultato dopo l'esecuzione di questo esempio è stato di 1.000 letture elaborate in 2,3 secondi e 10.000 letture elaborate in 27 secondi utilizzando una funzione Lambda configurata con 2.304 MB di memoria. AWS Lambda supporta configurazioni di memoria da 128 MB a 10.240 MB (10 GB), tuttavia l'aumento della memoria Lambda oltre 2.304 MB non ha contribuito a ridurre il tempo di esecuzione di questa particolare attività legata all'I/O.
Lo strumento [AWS Lambda Power Tuning](https://github.com/alexcasalboni/aws-lambda-power-tuning) è stato utilizzato per testare diverse configurazioni di memoria Lambda e verificare il rapporto performance-to-cost migliore per l'attività. Per i risultati dei test, consulta la sezione Informazioni [aggiuntive](#run-parallel-reads-of-s3-objects-by-using-python-in-an-aws-lambda-function-additional).
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un attivo Account AWS
+ Competenza nello sviluppo di Python
**Limitazioni**
+ Una funzione Lambda può avere al massimo [1.024 processi o thread di esecuzione](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html#function-configuration-deployment-and-execution).
+ Account AWS I nuovi hanno un limite di memoria Lambda di 3.008 MB. Regola lo strumento AWS Lambda Power Tuning di conseguenza. Per ulteriori informazioni, consulta la sezione [Risoluzione dei problemi](#run-parallel-reads-of-s3-objects-by-using-python-in-an-aws-lambda-function-troubleshooting).
+ Amazon S3 ha un limite di [5.500 GET/HEAD richieste al secondo per](https://docs.aws.amazon.com/AmazonS3/latest/userguide/optimizing-performance.html) prefisso partizionato.
**Versioni del prodotto**
+ Python 3.9 o versioni successive
+ AWS Cloud Development Kit (AWS CDK) v2
+ AWS Command Line Interface (AWS CLI) versione 2
+ AWS Lambda Power Tuning 4.3.6 (opzionale)
## Architecture
**Stack tecnologico Target**
+ AWS Lambda
+ Simple Storage Service (Amazon S3)
+ AWS Step Functions (se è AWS Lambda installato Power Tuning)
**Architettura di destinazione**
Il diagramma seguente mostra una funzione Lambda che legge gli oggetti da un bucket S3 in parallelo. Il diagramma presenta anche un flusso di lavoro Step Functions per lo strumento AWS Lambda Power Tuning per ottimizzare la memoria delle funzioni Lambda. Questa messa a punto aiuta a raggiungere un buon equilibrio tra costi e prestazioni.
![\[Diagramma che mostra la funzione Lambda, il bucket S3 e AWS Step Functions.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/b46e9b16-9842-4291-adfa-3ef012b89aec/images/828696e2-6df7-4536-9205-951c99449f4e.png)
**Automazione e scalabilità**
Le funzioni Lambda si scalano rapidamente quando necessario. Per evitare errori 503 Slow Down da Amazon S3 in caso di forte domanda, consigliamo di porre alcuni limiti alla scalabilità.
## Tools (Strumenti)
**Servizi AWS**
+ [AWS Cloud Development Kit (AWS CDK) v2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html) è un framework di sviluppo software che consente di definire e fornire Cloud AWS l'infrastruttura in codice. L'infrastruttura di esempio è stata creata per essere implementata con. AWS CDK
+ [AWS Command Line InterfaceAWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)è uno strumento open source che consente di interagire Servizi AWS tramite comandi nella shell della riga di comando. In questo modello, la AWS CLI versione 2 viene utilizzata per caricare un file JSON di esempio.
+ [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 elaborazione che utilizzi.
+ [Amazon Simple Storage Service Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) è un servizio di storage di oggetti basato sul cloud che consente di archiviare, proteggere e recuperare qualsiasi quantità di dati.
+ [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html)è un servizio di orchestrazione serverless che ti aiuta a combinare AWS Lambda funzioni e altri servizi AWS per creare applicazioni aziendali critiche.
**Altri strumenti**
+ [Python](https://www.python.org/) è un linguaggio di programmazione per computer generico. Il [riutilizzo dei thread di lavoro inattivi è stato introdotto](https://docs.python.org/3.8/library/concurrent.futures.html#concurrent.futures.ThreadPoolExecutor) nella versione 3.8 di Python e il codice della funzione Lambda in questo modello è stato creato per Python versione 3.9 e successive.
**Archivio di codice**
Il codice per questo pattern è disponibile nel [aws-lambda-parallel-download](https://github.com/aws-samples/aws-lambda-parallel-download) GitHub repository.
## Best practice
+ Questo AWS CDK costrutto si basa sulle autorizzazioni utente Account AWS dell'utente per implementare l'infrastruttura. [Se prevedi di utilizzare AWS CDK Pipelines o distribuzioni tra account, consulta i sintetizzatori Stack.](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html#bootstrapping-synthesizers)
+ Questa applicazione di esempio non ha i log di accesso abilitati nel bucket S3. È consigliabile abilitare i log di accesso nel codice di produzione.
## Epiche
### Prepara l'ambiente di sviluppo
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Controlla la versione installata di Python. | Questo codice è stato testato specificamente su Python 3.9 e Python 3.13 e dovrebbe funzionare su tutte le versioni tra queste versioni. Per verificare la tua versione di Python, esegui `python3 -V` nel tuo terminale e installa una versione più recente, se necessario.Per verificare che i moduli richiesti siano installati, esegui. `python3 -c "import pip, venv"` Nessun messaggio di errore indica che i moduli sono installati correttamente e che sei pronto per eseguire questo esempio. | Architetto del cloud |
| Installa AWS CDK. | Per installare il, AWS CDK se non è già installato, segui le istruzioni in [Guida introduttiva a AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html). Per confermare che la AWS CDK versione installata è 2.0 o successiva, esegui`cdk –version`. | Architetto del cloud |
| Avvia il tuo ambiente. | Per avviare il tuo ambiente, se non l'hai già fatto, segui le istruzioni riportate in [Bootstrap your environment per l'utilizzo](https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping-env.html) con. AWS CDK | Architetto del cloud |
### Clona il repository di esempio
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clonare il repository. | Per clonare l'ultima versione del repository, esegui il seguente comando:git clone --depth 1 --branch v1.2.0 \
git@github.com:aws-samples/aws-lambda-parallel-download.git
| Architetto del cloud |
| Cambia la directory di lavoro nel repository clonato. | Esegui il comando seguente:cd aws-lambda-parallel-download
| Architetto del cloud |
| Crea l'ambiente virtuale Python. | Per creare un ambiente virtuale Python, esegui il seguente comando:python3 -m venv .venv
| Architetto cloud |
| Attiva l'ambiente virtuale. | Per attivare l'ambiente virtuale, esegui il seguente comando:source .venv/bin/activate
| Architetto del cloud |
| Installa le dipendenze. | Per installare le dipendenze Python, esegui il comando: `pip`pip install -r requirements.txt
| Architetto del cloud |
| Sfoglia il codice. | (Facoltativo) Il codice di esempio che scarica un oggetto dal bucket S3 si trova in. `resources/parallel.py`Il codice dell'infrastruttura si trova nella cartella`parallel_download`. | Architetto del cloud |
### Implementa e testa l'app
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Distribuire l'app. | Esegui `cdk deploy`.Annota gli AWS CDK output:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/run-parallel-reads-of-s3-objects-by-using-python-in-an-aws-lambda-function.html) | Architetto del cloud |
| Carica un file JSON di esempio. | Il repository contiene un file JSON di esempio di circa 9 KB. Per caricare il file nel bucket S3 dello stack creato, esegui il comando seguente:aws s3 cp sample.json s3://
Sostituisci `` con il valore corrispondente dall'output. AWS CDK | Architetto del cloud |
| Esegui l'app. | Per eseguire l'app, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/run-parallel-reads-of-s3-objects-by-using-python-in-an-aws-lambda-function.html) | Architetto del cloud |
| Aggiungi il numero di download. | (Facoltativo) Per eseguire 1.500 chiamate get object, utilizzate il seguente codice JSON in **Event JSON del parametro**: `Test`{"repeat": 1500, "objectKey": "sample.json"} | Architetto del cloud |
### Opzionale: esegui AWS Lambda Power Tuning
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Esegui lo strumento AWS Lambda Power Tuning. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/run-parallel-reads-of-s3-objects-by-using-python-in-an-aws-lambda-function.html)Alla fine dell'esecuzione, il risultato sarà visualizzato nella scheda **Esecuzione input e output**. | Architetto del cloud |
| Visualizza i risultati del AWS Lambda Power Tuning in un grafico. | Nella scheda **Execution input and output**, copiate il link della `visualization` proprietà e incollatelo in una nuova scheda del browser. | Architetto del cloud |
### Eliminazione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Rimuovi gli oggetti dal bucket S3. | Prima di distruggere le risorse distribuite, rimuovi tutti gli oggetti dal bucket S3:aws s3 rm s3:// \
--recursive
Ricordati di sostituirlo `` con il valore delle uscite. AWS CDK | Architetto del cloud |
| Distruggi le risorse. | Per distruggere tutte le risorse create per questo programma pilota, esegui il seguente comando:cdk destroy
| Architetto del cloud |
## risoluzione dei problemi
| Problema | Soluzione |
| --- | --- |
| `'MemorySize' value failed to satisfy constraint: Member must have value less than or equal to 3008` | Per i nuovi account, potresti non essere in grado di configurare più di 3.008 MB nelle tue funzioni Lambda. Per testare l'utilizzo AWS Lambda di Power Tuning, aggiungi la seguente proprietà all'input JSON quando avvii l'esecuzione di Step Functions:"powerValues": [
512,
1024,
1536,
2048,
2560,
3008
]
|
## Risorse correlate
+ [Python — concurrent.futures. ThreadPoolExecutor](https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ThreadPoolExecutor)
+ [Quote Lambda: configurazione, distribuzione ed esecuzione delle funzioni](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html#function-configuration-deployment-and-execution)
+ [Lavorare con il AWS CDK in Python](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-python.html)
+ [Funzioni di profilazione con AWS Lambda Power Tuning](https://docs.aws.amazon.com/lambda/latest/operatorguide/profile-functions.html)
## Informazioni aggiuntive
**Codice**
Il seguente frammento di codice esegue l'elaborazione I/O parallela:
```
with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
for result in executor.map(a_function, (the_arguments)):
...
```
`ThreadPoolExecutor`Riutilizza i thread quando diventano disponibili.
**Test e risultati**
Questi test sono stati condotti nel dicembre 2024.
Il primo test ha elaborato 2.500 letture di oggetti, con il seguente risultato.
![\[Il tempo di invocazione diminuisce e il costo di invocazione aumenta con l'aumentare della memoria.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/b46e9b16-9842-4291-adfa-3ef012b89aec/images/f6743412-1e52-4c4c-a51c-ac0f75b3b998.png)
A partire da 3.009 MB, il livello di tempo di elaborazione è rimasto pressoché invariato per ogni aumento di memoria, ma il costo è aumentato all'aumentare delle dimensioni della memoria.
Un altro test ha analizzato l'intervallo tra 1.536 MB e 3.072 MB di memoria, utilizzando valori multipli di 256 MB ed elaborando 10.000 letture di oggetti, con i seguenti risultati.
![\[Riduzione della differenza tra la diminuzione del tempo di invocazione e l'aumento dei costi di invocazione.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/b46e9b16-9842-4291-adfa-3ef012b89aec/images/c75d4443-74d8-4b93-9b4d-b2640869381e.png)
Il performance-to-cost rapporto migliore è stato ottenuto con la configurazione Lambda da 2.304 MB di memoria.
A titolo di confronto, un processo sequenziale di 2.500 letture di oggetti ha richiesto 47 secondi. Il processo parallelo che utilizza la configurazione Lambda da 2.304 MB ha richiesto 7 secondi, ovvero l'85% in meno.
![\[Grafico che mostra la diminuzione del tempo quando si passa dall'elaborazione sequenziale a quella parallela.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/b46e9b16-9842-4291-adfa-3ef012b89aec/images/f3dcc44d-ac20-4b75-897d-1d71f0d59781.png)
# Invia dati di telemetria da AWS Lambda a OpenSearch per analisi e visualizzazione in tempo reale
*Tabby Ward, Guy Bachar e David Kilzer, Amazon Web Services*
## Riepilogo
Le applicazioni moderne stanno diventando sempre più distribuite e basate sugli eventi, il che rafforza la necessità di monitoraggio e osservabilità in tempo reale. AWS Lambda è un servizio di elaborazione serverless che svolge un ruolo cruciale nella creazione di architetture scalabili e basate sugli eventi. Tuttavia, il monitoraggio e la risoluzione dei problemi delle funzioni Lambda possono essere difficili se ci si affida esclusivamente ad Amazon CloudWatch Logs, che può introdurre latenza e periodi di conservazione limitati.
Per affrontare questa sfida, AWS ha introdotto l'API Lambda Telemetry, che consente alle funzioni Lambda di inviare dati di telemetria direttamente a strumenti di monitoraggio e osservabilità di terze parti. Questa API supporta lo streaming in tempo reale di log, metriche e tracce e fornisce una visione completa e tempestiva delle prestazioni e dello stato delle funzioni Lambda.
Questo modello spiega come integrare l'API Lambda Telemetry con [OpenSearch](https://opensearch.org/docs/latest/), un motore di ricerca e analisi distribuito open source. OpenSearch offre una piattaforma potente e scalabile per l'acquisizione, l'archiviazione e l'analisi di grandi volumi di dati, che la rende la scelta ideale per i dati di telemetria Lambda. In particolare, questo modello dimostra come inviare i log da una funzione Lambda scritta in Python direttamente a un cluster OpenSearch utilizzando un'estensione Lambda fornita da. AWS Questa soluzione è flessibile e personalizzabile, quindi puoi creare la tua estensione Lambda o modificare il codice sorgente di esempio per modificare il formato di output come desideri.
Il modello spiega come impostare e configurare l'integrazione dell'API Lambda Telemetry e include le migliori pratiche per la sicurezza OpenSearch, l'ottimizzazione dei costi e la scalabilità. L'obiettivo è aiutarti a ottenere informazioni più approfondite sulle tue funzioni Lambda e migliorare l'osservabilità complessiva delle tue applicazioni serverless.
|
|
| Nota: questo modello si concentra sull'integrazione dell'API di telemetria Lambda con managed. OpenSearch Tuttavia, i principi e le tecniche discussi sono applicabili anche all'autogestione e a Elasticsearch. OpenSearch |
| --- |
## Prerequisiti e limitazioni
Prima di iniziare il processo di integrazione, assicurati di avere i seguenti prerequisiti:
**Account AWS**: Un attivo Account AWS con le autorizzazioni appropriate per creare e gestire le seguenti risorse: AWS
+ AWS Lambda
+ AWS Identity and Access Management (IAM)
+ Amazon OpenSearch Service (se utilizzi un OpenSearch cluster gestito)
**OpenSearch cluster**:
+ È possibile utilizzare un OpenSearch cluster autogestito esistente o un servizio gestito come OpenSearch Service.
+ Se utilizzi OpenSearch Service, configura il OpenSearch cluster seguendo le istruzioni in [Getting started with Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/gsg.html) nella documentazione del OpenSearch Servizio.
+ Assicurati che il OpenSearch cluster sia accessibile dalla tua funzione Lambda e sia configurato con le impostazioni di sicurezza necessarie, come le politiche di accesso, la crittografia e l'autenticazione.
+ Configura il OpenSearch cluster con le mappature degli indici e le impostazioni necessarie per importare i dati di telemetria Lambda. Per ulteriori informazioni, consulta [Caricamento di dati di streaming in Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/integrations.html) nella documentazione del OpenSearch servizio.
**Connettività di rete**:
+ Assicurati che la tua funzione Lambda disponga della connettività di rete necessaria per accedere al OpenSearch cluster. Per indicazioni su come configurare le impostazioni del cloud privato virtuale (VPC), consulta [Avvio dei domini Amazon OpenSearch Service all'interno di un VPC](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/vpc.html) nella documentazione del servizio. OpenSearch
Ruoli e **politiche IAM**:
+ Crea un ruolo IAM con le autorizzazioni necessarie affinché la tua funzione Lambda possa accedere al cluster e accedere OpenSearch alle tue credenziali archiviate in. Gestione dei segreti AWS
+ Allega le policy IAM appropriate al ruolo, ad esempio la `AWSLambdaBasicExecutionRole` policy e le eventuali autorizzazioni aggiuntive necessarie per interagire con. OpenSearch
+ Verifica che le autorizzazioni IAM concesse alla tua funzione Lambda consentano di scrivere OpenSearch dati nel cluster. Per informazioni sulla gestione delle autorizzazioni IAM, consulta [Definizione delle autorizzazioni della funzione Lambda con un ruolo di esecuzione](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) nella documentazione Lambda.
**Conoscenza del linguaggio di programmazione:**
+ Avrai bisogno di una conoscenza di base di Python (o del linguaggio di programmazione di tua scelta) per comprendere e modificare il codice di esempio per la funzione Lambda e l'estensione Lambda.
**Ambiente di sviluppo:**
+ Configura un ambiente di sviluppo locale con gli strumenti e le dipendenze necessari per creare e distribuire funzioni ed estensioni Lambda.
**AWS CLI oppure: Console di gestione AWS**
+ Installa e configura il [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) o usalo Console di gestione AWS con le credenziali appropriate per interagire con quello richiesto. Servizi AWS
**Monitoraggio e registrazione**:
+ Acquisisci familiarità con le migliori pratiche di monitoraggio e registrazione su AWS servizi come Amazon CloudWatch e AWS CloudTrail per scopi di monitoraggio e controllo.
+ Controlla CloudWatch i log per la tua funzione Lambda per identificare eventuali errori o eccezioni relativi all'integrazione dell'API Lambda Telemetry. Per una guida alla risoluzione dei problemi, consulta la documentazione dell'[API Lambda Telemetry](https://docs.aws.amazon.com/lambda/latest/dg/telemetry-api.html).
## Architecture
Questo modello utilizza OpenSearch Service per archiviare registri e dati di telemetria generati dalle funzioni Lambda. Questo approccio consente di trasmettere rapidamente i log direttamente al OpenSearch cluster, riducendo la latenza e i costi associati all'utilizzo di Logs come intermediario. CloudWatch
|
|
| [Il codice di estensione Lambda può inviare telemetria a OpenSearch Service, utilizzando direttamente l' OpenSearch API o utilizzando una libreria client. OpenSearch ](https://opensearch.org/docs/latest/clients/index/) L'estensione Lambda può utilizzare le operazioni di massa supportate dall' OpenSearch API per raggruppare gli eventi di telemetria in batch e inviarli a OpenSearch Service in un'unica richiesta. |
| --- |
Il seguente diagramma del flusso di lavoro illustra il flusso di lavoro di registro per le funzioni Lambda quando si utilizza un OpenSearch cluster come endpoint.
![\[Flusso di lavoro per l'invio di dati di telemetria a un cluster. OpenSearch\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/57fe8796-9f36-46cf-8304-f506242b9f04/images/283ccdcd-a0e1-40a2-a95a-3bd046bfa8ca.png)
L'architettura include i seguenti componenti:
+ Funzione Lambda: la funzione serverless che genera log e dati di telemetria durante l'esecuzione.
+ Estensione Lambda: un'estensione basata su Python che utilizza l'API Lambda Telemetry per l'integrazione diretta con il cluster. OpenSearch Questa estensione viene eseguita insieme alla funzione Lambda nello stesso ambiente di esecuzione.
+ API di telemetria Lambda: l'API che consente alle estensioni Lambda di inviare dati di telemetria, inclusi log, metriche e tracce, direttamente a strumenti di monitoraggio e osservabilità di terze parti.
+ Cluster Amazon OpenSearch Service: un OpenSearch cluster gestito ospitato su AWS. Questo cluster è responsabile dell'acquisizione, dell'archiviazione e dell'indicizzazione dei dati di registro trasmessi dalla funzione Lambda tramite l'estensione Lambda.
Il flusso di lavoro prevede i seguenti passaggi:
1. La funzione Lambda viene chiamata e genera log e dati di telemetria durante la sua esecuzione.
1. L'estensione Lambda funziona insieme alla funzione per acquisire i log e i dati di telemetria utilizzando l'API Lambda Telemetry.
1. L'estensione Lambda stabilisce una connessione sicura con il cluster di OpenSearch servizi e trasmette i dati di registro in tempo reale.
1. Il cluster di OpenSearch servizi inserisce, indicizza e archivia i dati di registro per renderli disponibili per la ricerca, l'analisi e la visualizzazione tramite l'uso di strumenti come Kibana o altre applicazioni compatibili.
Evitando CloudWatch i log e inviando i dati di log direttamente al cluster, questa soluzione offre diversi vantaggi: OpenSearch
+ Streaming e analisi dei log in tempo reale, che consentono una risoluzione dei problemi più rapida e una migliore osservabilità.
+ Latenza ridotta e potenziali limitazioni di conservazione associate CloudWatch ai log.
+ Flessibilità di personalizzare l'estensione Lambda o creare un'estensione personalizzata per formati di output specifici o elaborazioni aggiuntive.
+ Integrazione con le funzionalità di ricerca, analisi e visualizzazione di OpenSearch Service per l'analisi e il monitoraggio dei log.
La sezione [Epics](#send-telemetry-data-from-lambda-to-opensearch-for-analytics-visualization-epics) fornisce step-by-step istruzioni per configurare l'estensione Lambda, configurare la funzione Lambda e integrare con il cluster di servizi. OpenSearch [Per considerazioni sulla sicurezza, strategie di ottimizzazione dei costi e suggerimenti per il monitoraggio e la risoluzione dei problemi della soluzione, consulta la sezione Best practice.](#send-telemetry-data-from-lambda-to-opensearch-for-analytics-visualization-best-practices)
## Tools (Strumenti)
**Servizi AWS**
+ [AWS Lambda](https://aws.amazon.com/lambda/) è un servizio di elaborazione che consente di eseguire del codice senza la necessità di effettuare il provisioning o la gestione dei server. Lambda esegue il codice solo quando è necessario e si dimensiona automaticamente, da poche richieste al giorno a migliaia al secondo.
+ [Amazon OpenSearch Service](https://aws.amazon.com/opensearch-service/) è un servizio completamente gestito fornito da AWS che semplifica la distribuzione, il funzionamento e la scalabilità OpenSearch dei cluster nel cloud.
+ [Le estensioni Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-extensions.html) estendono la funzionalità delle funzioni Lambda eseguendo codice personalizzato insieme a esse. Puoi utilizzare le estensioni Lambda per integrare Lambda con vari strumenti di monitoraggio, osservabilità, sicurezza e governance.
+ AWS Lambda L'[API di telemetria](https://docs.aws.amazon.com/lambda/latest/dg/telemetry-api.html) ti consente di utilizzare le estensioni per acquisire dati avanzati di monitoraggio e osservabilità direttamente da Lambda e inviarli a una destinazione di tua scelta.
+ [CloudFormation](https://aws.amazon.com/cloudformation/)ti aiuta a modellare e configurare AWS le tue risorse in modo da dedicare meno tempo alla gestione di tali risorse e più tempo a concentrarti sulle tue applicazioni.
**Archivi di codice**
+ [AWS Lambda Extensions](https://github.com/aws-samples/aws-lambda-extensions) include demo e progetti di AWS esempio di AWS partner per aiutarti a iniziare a creare le tue estensioni.
+ [Example Lambda Telemetry Integrations for fornisce OpenSearch](https://github.com/aws-samples/aws-lambda-extensions/tree/main/python-example-telemetry-opensearch-extension) un'estensione Lambda di esempio che dimostra come inviare i log da una funzione Lambda a un cluster. OpenSearch
**Altri strumenti**
+ [OpenSearch](https://opensearch.org/faq/)è un motore di ricerca e analisi distribuito open source che fornisce una potente piattaforma per l'acquisizione, l'archiviazione e l'analisi di grandi volumi di dati.
+ Kibana è uno strumento di visualizzazione ed esplorazione dei dati open source che puoi utilizzare con. OpenSearch Nota che l'implementazione della visualizzazione e dell'analisi esula dall'ambito di questo modello. Per ulteriori informazioni, consulta la [documentazione di Kibana](https://www.elastic.co/guide/en/kibana/current/index.html) e altre risorse.
## Best practice
Quando integri l'API di telemetria Lambda con OpenSearch, prendi in considerazione le seguenti best practice.
**Sicurezza e controllo degli accessi**
+ **Comunicazione sicura**: crittografa tutte le comunicazioni tra le funzioni Lambda e OpenSearch il cluster utilizzando HTTPS. Configura le SSL/TLS impostazioni necessarie nell'estensione e OpenSearch nella configurazione Lambda.
+ **Autorizzazioni IAM:**
+ Le estensioni vengono eseguite nello stesso ambiente di esecuzione della funzione Lambda, quindi ereditano lo stesso livello di accesso a risorse come il file system, la rete e le variabili di ambiente.
+ Concedi le autorizzazioni IAM minime necessarie alle tue funzioni Lambda per accedere all'API Lambda Telemetry e scrivere dati nel cluster. OpenSearch Utilizza il [principio del privilegio minimo per limitare l'ambito delle](https://docs.aws.amazon.com/lambda/latest/operatorguide/least-privilege.html) autorizzazioni.
+ **OpenSearch controllo degli accessi**: implementa un controllo granulare degli accessi nel OpenSearch cluster per limitare l'accesso ai dati sensibili. Utilizza le funzionalità di sicurezza integrate, come l'autenticazione degli utenti, il controllo degli accessi basato sui ruoli e le autorizzazioni a livello di indice, in. OpenSearch
+ **Estensioni affidabili: installa sempre le estensioni** solo da una fonte attendibile. Utilizza strumenti Infrastructure as Code (IaC) CloudFormation per semplificare il processo di associazione della stessa configurazione di estensione, incluse le autorizzazioni IAM, a più funzioni Lambda. Gli strumenti IAc forniscono anche un registro di controllo delle estensioni e delle versioni utilizzate in precedenza.
+ **Gestione dei dati sensibili**: quando crei estensioni, evita di registrare dati sensibili. Pulisci i payload e i metadati prima di registrarli o renderli persistenti per scopi di controllo.
**Ottimizzazione dei costi**
+ **Monitoraggio e avviso: configura** meccanismi di monitoraggio e avviso per tenere traccia del volume di dati inviati dalle tue funzioni OpenSearch Lambda. Questo ti aiuterà a identificare e risolvere eventuali sforamenti dei costi.
+ **Conservazione dei dati**: valuta attentamente il periodo di conservazione dei dati appropriato per i tuoi dati di telemetria Lambda in. OpenSearch Periodi di conservazione più lunghi possono aumentare i costi di archiviazione, quindi bilancia le esigenze di osservabilità con l'ottimizzazione dei costi.
+ **Compressione e indicizzazione**: abilita la compressione dei dati e ottimizza la tua strategia di OpenSearch indicizzazione per ridurre l'ingombro di archiviazione dei dati di telemetria Lambda.
+ **Riduzione della dipendenza** da CloudWatch: integrando direttamente l'API di telemetria Lambda con OpenSearch, è possibile ridurre potenzialmente la dipendenza dai CloudWatch log, con conseguenti risparmi sui costi. Questo perché l'API Lambda Telemetry consente di inviare i log direttamente a OpenSearch, evitando così la necessità di archiviare ed elaborare i dati. CloudWatch
**Scalabilità e affidabilità**
+ Elaborazione **asincrona: utilizza modelli di elaborazione** asincroni, come Amazon Simple Queue Service (Amazon SQS) o Amazon Kinesis, per disaccoppiare l'esecuzione della funzione Lambda dall'ingestione dei dati. OpenSearch Questo aiuta a mantenere la reattività delle funzioni Lambda e migliora l'affidabilità complessiva del sistema.
+ **OpenSearch scalabilità del cluster**: monitora le prestazioni e l'utilizzo delle risorse del OpenSearch cluster e ridimensionalo verso l'alto o verso il basso secondo necessità per gestire il volume crescente di dati di telemetria Lambda.
+ **Failover e disaster recovery**: implementa una solida strategia di disaster recovery per il OpenSearch cluster, che include backup regolari e la capacità di ripristinare rapidamente i dati in caso di guasto.
**Osservabilità e monitoraggio**
+ **Dashboard e visualizzazioni**: utilizza Kibana o altri strumenti di dashboard per creare dashboard e visualizzazioni personalizzate che forniscono informazioni sulle prestazioni e sullo stato delle funzioni Lambda in base ai dati di telemetria inclusi. OpenSearch
+ Avvisi **e notifiche: configura avvisi** e notifiche per monitorare in modo proattivo anomalie, errori o problemi di prestazioni nelle funzioni Lambda. Integra questi avvisi e notifiche con i processi di gestione degli incidenti esistenti.
+ **Tracciamento e correlazione**: assicurati che i dati di telemetria Lambda includano informazioni di tracciamento pertinenti, come richieste IDs o correlazioni, per consentire end-to-end l'osservabilità e la risoluzione dei problemi tra le applicazioni IDs serverless distribuite.
Seguendo queste best practice, puoi assicurarti che l'integrazione dell'API Lambda Telemetry con OpenSearch sia sicura, economica e scalabile e fornisca un'osservabilità completa per le tue applicazioni serverless.
## Epiche
### Crea e distribuisci il livello di estensione Lambda
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Scarica il codice sorgente. | Scarica le estensioni di esempio dal repository [AWS Lambda Extensions](https://github.com/aws-samples/aws-lambda-extensions). | Sviluppatore di app, architetto cloud |
| Accedi alla cartella `python-example-telemetry-opensearch-extension`. | L'archivio delle [AWS Lambda estensioni](https://github.com/aws-samples/aws-lambda-extensions) che hai scaricato contiene numerosi esempi per diversi casi d'uso e runtime linguistici. Vai alla cartella [python-example-telemetry-opensearch-extension](https://github.com/aws-samples/aws-lambda-extensions/tree/main/python-example-telemetry-opensearch-extension) per usare l'estensione OpenSearch Python, a cui invia i log. OpenSearch | Sviluppatore di app, architetto cloud |
| Aggiungi le autorizzazioni per eseguire l'endpoint di estensione. | Esegui il comando seguente per rendere eseguibile l'endpoint dell'estensione:chmod +x python-example-telemetry-opensearch-extension/extension.py
| Sviluppatore di app, architetto cloud |
| Installa le dipendenze dell'estensione localmente. | Esegui il seguente comando per installare le dipendenze locali per il codice Python:pip3 install -r python-example-telemetry-opensearch-extension/requirements.txt -t ./python-example-telemetry-opensearch-extension/
Queste dipendenze verranno montate insieme al codice di estensione. | Sviluppatore di app, architetto cloud |
| Crea un pacchetto.zip per l'estensione per distribuirla come livello. | Il file con estensione zip deve contenere una directory principale denominata`extensions/`, in cui si trova l'eseguibile dell'estensione, e un'altra directory principale chiamata`python-example-telemetry-opensearch-extension/`, in cui si trovano la logica di base dell'estensione e le sue dipendenze.Crea il pacchetto.zip per l'estensione:chmod +x extensions/python-example-telemetry-opensearch-extension
zip -r extension.zip extensions python-example-telemetry-opensearch-extension
| Sviluppatore di app, architetto cloud |
| Implementa l'estensione come livello Lambda. | Pubblicate il layer utilizzando il file di estensione .zip e il seguente comando:aws lambda publish-layer-version \
--layer-name "python-example-telemetry-opensearch-extension" \
--zip-file "fileb://extension.zip"
| Sviluppatore di app, architetto cloud |
### Integra l'estensione nella tua funzione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Aggiungi il livello alla tua funzione. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/send-telemetry-data-from-lambda-to-opensearch-for-analytics-visualization.html)[Per ulteriori informazioni sull'aggiunta di un layer alla funzione Lambda, consulta la documentazione Lambda.](https://docs.aws.amazon.com/lambda/latest/dg/adding-layers.html) | Sviluppatore di app, architetto cloud |
| Imposta le variabili di ambiente per la funzione. | Nella pagina della funzione, scegliete la scheda **Configurazione** e aggiungete le seguenti variabili di ambiente alla funzione:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/send-telemetry-data-from-lambda-to-opensearch-for-analytics-visualization.html) | Sviluppatore di app, architetto cloud |
### Aggiungi istruzioni di registrazione e verifica la tua funzione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Aggiungi istruzioni di registrazione alla tua funzione. | Aggiungi istruzioni di registrazione alla tua funzione utilizzando uno dei [meccanismi di registrazione integrati](https://docs.aws.amazon.com/lambda/latest/dg/python-logging.html) o il modulo di registrazione preferito. Ecco alcuni esempi di registrazione dei messaggi in Python:print("Your Log Message Here")
logger = logging.getLogger(__name__)
logger.info("Test Info Log.")
logger.error("Test Error Log.") | Sviluppatore di app, architetto cloud |
| Prova la tua funzione . | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/send-telemetry-data-from-lambda-to-opensearch-for-analytics-visualization.html)Dovresti vedere **Esecuzione della funzione: riuscita** se tutto funziona correttamente. | Sviluppatore di app, architetto cloud |
### Visualizza i tuoi dati di accesso OpenSearch
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Interroga i tuoi indici. | In OpenSearch, esegui il comando seguente per interrogare i tuoi indici:SELECT * FROM index-name
I log dovrebbero essere visualizzati nei risultati della query. | Architetto del cloud |
## risoluzione dei problemi
| Problema | Soluzione |
| --- | --- |
| Problemi di connettività | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/send-telemetry-data-from-lambda-to-opensearch-for-analytics-visualization.html) |
| Errori di inserimento dei dati | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/send-telemetry-data-from-lambda-to-opensearch-for-analytics-visualization.html) |
## Risorse correlate
+ [Esempi di integrazioni di telemetria Lambda](https://github.com/aws-samples/aws-lambda-extensions/tree/main/python-example-telemetry-opensearch-extension) per (repository) OpenSearch GitHub
+ [Potenzia le funzioni Lambda utilizzando le estensioni Lambda (documentazione Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-extensions.html))
+ [API di telemetria Lambda (documentazione](https://docs.aws.amazon.com/lambda/latest/dg/telemetry-api.html) Lambda)
+ [Presentazione dell'API di AWS Lambda telemetria (post sul blog)](https://aws.amazon.com/blogs/compute/introducing-the-aws-lambda-telemetry-api/)AWS
+ [Integrazione dell' AWS Lambda API di telemetria con Prometheus](https://aws.amazon.com/blogs/opensource/integrating-the-aws-lambda-telemetry-api-with-prometheus-and-opensearch) e (post sul blog) OpenSearch AWS
## Informazioni aggiuntive
**Modifica della struttura dei log**
Per impostazione predefinita, l'estensione invia i log come documento annidato a OpenSearch . Ciò consente di eseguire interrogazioni annidate per recuperare i valori delle singole colonne.
Se l'output di registro predefinito non soddisfa le tue esigenze specifiche, puoi personalizzarlo modificando il codice sorgente dell'estensione Lambda fornita da. AWS AWS incoraggia i clienti ad adattare l'output alle proprie esigenze aziendali. Per modificare l'output del registro, individua la `dispatch_to_opensearch` funzione nel `telemetry_dispatcher.py` file all'interno del codice sorgente dell'estensione e apporta le modifiche necessarie.
# Configura un router cellulare serverless per un'architettura basata su celle
*Mian Tariq e Ioannis Lioupras, Amazon Web Services*
## Riepilogo
In quanto punto di accesso a un sistema globale di applicazioni basate su celle, il router cellulare è responsabile dell'assegnazione efficiente degli utenti alle celle appropriate e della fornitura degli endpoint agli utenti. Il router cellulare gestisce funzioni come la memorizzazione delle user-to-cell mappature, il monitoraggio della capacità delle celle e la richiesta di nuove celle quando necessario. È importante mantenere la funzionalità del router cellulare durante potenziali interruzioni.
Il framework di progettazione cell-router in questo modello si concentra su resilienza, scalabilità e ottimizzazione complessiva delle prestazioni. Il modello utilizza il routing statico, in cui i client memorizzano nella cache gli endpoint al momento dell'accesso iniziale e comunicano direttamente con le celle. Questo disaccoppiamento migliora la resilienza del sistema contribuendo a garantire la funzionalità ininterrotta dell'applicazione basata su celle in caso di problemi tra cellulare e router.
Questo modello AWS CloudFormation utilizza un modello per implementare l'architettura. Per informazioni dettagliate su ciò che viene distribuito dal modello o per distribuire la stessa configurazione utilizzando il Console di gestione AWS, consulta la sezione Informazioni [aggiuntive](#serverless-cell-router-architecture-additional).
**Importante**
La dimostrazione, il codice e il CloudFormation modello presentati in questo modello hanno solo scopo esplicativo. Il materiale fornito ha il solo scopo di illustrare il modello di progettazione e di facilitarne la comprensione. La demo e il codice non sono pronti per la produzione e non devono essere utilizzati per attività di produzione dal vivo. Qualsiasi tentativo di utilizzare il codice o la demo in un ambiente di produzione è fortemente sconsigliato ed è a rischio dell'utente. Consigliamo di consultare i professionisti appropriati e di eseguire test approfonditi prima di implementare questo modello o uno qualsiasi dei suoi componenti in un ambiente di produzione.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un account Amazon Web Services (AWS) attivo
+ L'ultima versione di [AWS Command Line Interface (AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html))
+ [Credenziali AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) con le autorizzazioni necessarie per creare lo CloudFormation stack, AWS Lambda le funzioni e le risorse correlate
**Versioni del prodotto**
+ Python 3.12
## Architecture
Il diagramma seguente mostra un design di alto livello del router cellulare.
![\[Il processo in cinque fasi del router cellulare.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/fd2fbf9d-9ae4-4c27-bc32-cf117350137a/images/feb90b51-dd91-483b-b5a3-b0a5359686e3.png)
Il diagramma illustra il seguente flusso di lavoro:
1. L'utente contatta Amazon API Gateway, che funge da interfaccia per gli endpoint API cell-router.
1. Amazon Cognito gestisce l'autenticazione e l'autorizzazione.
1. Il AWS Step Functions flusso di lavoro è composto dai seguenti componenti:
+ **Orchestrator** ‒ Gli `Orchestrator` usi AWS Step Functions per creare un flusso di lavoro o una macchina a stati. Il flusso di lavoro viene attivato dall'API del router cellulare. `Orchestrator`Esegue le funzioni Lambda in base al percorso della risorsa.
+ **Dispatcher** ‒ La funzione `Dispatcher` Lambda identifica e assegna una cella statica per ogni nuovo utente registrato. La funzione cerca la cella con il minor numero di utenti, la assegna all'utente e restituisce gli endpoint.
+ **Mapper** ‒ L'`Mapper`operazione gestisce le user-to-cell mappature all'interno del database `RoutingDB` Amazon DynamoDB creato dal modello. CloudFormation Quando viene attivata, la `Mapper` funzione fornisce agli utenti già assegnati i propri endpoint.
+ **Scaler** ‒ La `Scaler` funzione tiene traccia dell'occupazione delle celle e della capacità disponibile. Se necessario, la `Scaler` funzione può inviare una richiesta tramite Amazon Simple Queue Service (Amazon SQS) al livello Provision and Deploy per richiedere nuove celle.
+ **Validator** ‒ La `Validator` funzione convalida gli endpoint delle celle e rileva eventuali problemi.
1. `RoutingDB`Memorizza le informazioni e gli attributi delle celle (endpoint API, stato Regione AWS, metriche).
1. Quando la capacità disponibile delle celle supera una soglia, il router cellulare richiede servizi di provisioning e distribuzione tramite Amazon SQS per creare nuove celle.
Quando vengono create nuove celle, `RoutingDB` viene aggiornato dal livello Provision and Deploy. Tuttavia, tale processo non rientra nell'ambito di questo modello. Per una panoramica dei presupposti di progettazione dell'architettura basata su celle e dettagli sul design cell-router utilizzato in questo modello, vedere la sezione Informazioni [aggiuntive](#serverless-cell-router-architecture-additional).
## Tools (Strumenti)
**Servizi AWS**
+ [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) ti aiuta a creare, pubblicare, gestire, monitorare e proteggere REST, HTTP e WebSocket APIs su qualsiasi scala.
+ [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)ti aiuta a configurare AWS le risorse, fornirle in modo rapido e coerente e gestirle durante tutto il loro ciclo di vita attraverso Account AWS e. Regioni AWS
+ [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html) fornisce autenticazione, autorizzazione e gestione degli utenti per app Web e mobili.
+ [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.
+ [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 elaborazione che utilizzi.
+ [Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html) è un servizio di archiviazione degli oggetti basato sul cloud che consente di archiviare, proteggere e recuperare qualsiasi quantità di dati.
+ [Amazon Simple Queue Service (Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html)) fornisce una coda ospitata sicura, durevole e disponibile che ti aiuta a integrare e disaccoppiare sistemi e componenti software distribuiti.
+ [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html)è un servizio di orchestrazione serverless che consente di combinare funzioni Lambda e altro Servizi AWS per creare applicazioni aziendali critiche.
**Altri strumenti**
+ [Python](https://www.python.org/) è un linguaggio di programmazione per computer generico.
**Deposito di codice**
Il codice per questo pattern è disponibile nel repository GitHub [Serverless-Cell-Router](https://github.com/aws-samples/Serverless-Cell-Router/).
## Best practice
Per le migliori pratiche per la creazione di architetture basate su celle, consulta la seguente guida Well-Architected AWS :
+ [Ridurre l'ambito di impatto con l'architettura basata su celle](https://docs.aws.amazon.com/wellarchitected/latest/reducing-scope-of-impact-with-cell-based-architecture/reducing-scope-of-impact-with-cell-based-architecture.html)
+ [AWS Well-Architected Framework Reliability Pillar REL1: 0-BP04 Utilizza architetture bulkhead per limitare l'ambito dell'impatto](https://docs.aws.amazon.com/wellarchitected/latest/reliability-pillar/rel_fault_isolation_use_bulkhead.html)
## Epiche
### Prepara i file sorgente
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Clona il repository di codice di esempio. | Per clonare il Serverless-Cell-Router GitHub repository sul tuo computer, usa il seguente comando:git clone https://github.com/aws-samples/Serverless-Cell-Router/
| Developer |
| Imposta credenziali AWS CLI temporanee. | Configura il AWS CLI con le credenziali per il tuo. Account AWS Questa procedura dettagliata utilizza credenziali temporanee fornite dalla riga di **comando di AWS IAM Identity Center o dall'opzione di accesso programmatico**. In questo modo vengono impostate le variabili `AWS_ACCESS_KEY_ID``AWS_SECRET_ACCESS_KEY`, e di `AWS_SESSION_TOKEN` AWS ambiente con le credenziali appropriate da utilizzare con. AWS CLI | Developer |
| Crea un bucket S3. | Crea un bucket S3 che verrà utilizzato per archiviare e accedere alle funzioni Serverless-Cell-Router Lambda per la distribuzione tramite il modello. CloudFormation Per creare il bucket S3, usa il seguente comando: aws s3api create-bucket --bucket --region eu-central-1 --create-bucket-configuration LocationConstraint=eu-central-1
| Developer |
| Crea file.zip. | [Crea un file.zip per ogni funzione Lambda che si trova nella directory Functions.](https://github.com/aws-samples/Serverless-Cell-Router/tree/main/Functions) Questi file.zip verranno utilizzati per distribuire le funzioni Lambda. Su un Mac, usa i seguenti comandi: `zip`zip -j mapper-scr.zip Functions/Mapper.py
zip -j dispatcher-scr.zip Functions/Dispatcher.py
zip -j scaler-scr.zip Functions/Scaler.py
zip -j cp validator-scr.zip Functions/Validator.py
zip -j dynamodbDummyData-scr.zip Functions/DynamodbDummyData.py
| Developer |
| Copia i file.zip nel bucket S3. | Per copiare tutti i file.zip della funzione Lambda nel bucket S3, usa i seguenti comandi:aws s3 cp mapper-scr.zip s3://
aws s3 cp dispatcher-scr.zip s3://
aws s3 cp scaler-scr.zip s3://
aws s3 cp validator-scr.zip s3://
aws s3 cp dynamodbDummyData-scr.zip s3://
| Developer |
### Crea lo stack CloudFormation
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Implementa il CloudFormation modello. | Per distribuire il CloudFormation modello, esegui il comando seguente: AWS CLI aws cloudformation create-stack --stack-name serverless.cell-router \
--template-body file://Serverless-Cell-Router-Stack-v10.yaml \
--capabilities CAPABILITY_IAM \
--parameters ParameterKey=LambdaFunctionMapperS3KeyParameterSCR,ParameterValue=mapper-scr.zip \
ParameterKey=LambdaFunctionDispatcherS3KeyParameterSCR,ParameterValue=dispatcher-scr.zip \
ParameterKey=LambdaFunctionScalerS3KeyParameterSCR,ParameterValue=scaler-scr.zip \
ParameterKey=LambdaFunctionAddDynamoDBDummyItemsS3KeyParameterSCR,ParameterValue=dynamodbDummyData-scr.zip \
ParameterKey=LambdaFunctionsS3BucketParameterSCR,ParameterValue= \
ParameterKey=CognitoDomain,ParameterValue= \
--region
| Developer |
| Verifica lo stato di avanzamento. | Accedi a Console di gestione AWS, apri la CloudFormation console all'indirizzo [https://console.aws.amazon.com/cloudformation/]()e controlla lo stato di avanzamento dello sviluppo dello stack. Quando lo stato è`CREATE_COMPLETE`, lo stack è stato distribuito correttamente. | Developer |
### Valuta e verifica
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Assegna celle all'utente. | Per avviare il`Orchestrator`, esegui il seguente comando curl:curl -X POST \
-H "Authorization: Bearer {User id_token}" \
https://xxxxxx.execute-api.eu-central-1.amazonaws.com/Cell_Router_Development/cells
`Orchestrator`Attiva l'esecuzione della funzione. `Dispatcher` A sua volta, verifica l'esistenza dell'utente. `Dispatcher` Se l'utente viene trovato, `Dispatcher` restituisce l'ID della cella e l'endpoint URLs associati. Se l'utente non viene trovato, gli `Dispatcher` assegna una cella e invia l'ID della cella alla `Scaler` funzione per la valutazione della capacità residua della cella assegnata.La risposta della `Scaler` funzione è la seguente:`"cellID : cell-0002 , endPoint_1 : https://xxxxx.execute-api.eu-north-1.amazonaws.com/ , endPoint_2 : https://xxxxxxx.execute-api.eu-central-1.amazonaws.com/"` | Developer |
| Recupera le celle utente. | Per utilizzare la funzione `Orchestrator` per eseguire la `Mapper` funzione, esegui il comando seguente:curl -X POST \
-H "Authorization: Bearer {User id_token}" \
https://xxxxxxxxx.execute-api.eu-central-1.amazonaws.com/Cell_Router_Development/mapper
`Orchestrator`Cerca la cella assegnata all'utente e restituisce l'ID della cella e URLs nella seguente risposta:`"cellID : cell-0002 , endPoint_1 : https://xxxxx.execute-api.eu-north-1.amazonaws.com/ , endPoint_2 : https://xxxxxxx.execute-api.eu-central-1.amazonaws.com/"` | Developer |
### Eliminazione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Elimina le risorse. | Per evitare di incorrere in costi aggiuntivi sul tuo account, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/serverless-cell-router-architecture.html) | Sviluppatore di app |
## Risorse correlate
**Riferimenti**
+ [Stabilità statica con le zone di disponibilità](https://aws.amazon.com/builders-library/static-stability-using-availability-zones/)
+ [Limiti dell'isolamento dei guasti di AWS: stabilità statica](https://docs.aws.amazon.com/whitepapers/latest/aws-fault-isolation-boundaries/static-stability.html)
**Video**
[Physalia: architettura basata su celle per fornire una maggiore disponibilità su Amazon EBS](https://www.youtube.com/watch?v=6IknqRZMFic)
[https://www.youtube-nocookie.com/embed/6 RZMFic Iknq? controlli = 0](https://www.youtube-nocookie.com/embed/6IknqRZMFic?controls=0)
## Informazioni aggiuntive
**Premesse di progettazione dell'architettura basata su celle**
Sebbene questo modello si concentri sul router cellulare, è importante comprendere l'intero ambiente. L'ambiente è strutturato in tre livelli distinti:
+ Il livello di routing, o Thin layer, che contiene il router cellulare
+ Lo strato cellulare, che comprende varie celle
+ Il livello Provision and Deploy, che effettua il provisioning delle celle e distribuisce l'applicazione
Ogni livello mantiene la funzionalità anche in caso di alterazioni che interessano altri livelli. Account AWS fungono da limite di isolamento dei guasti.
Il diagramma seguente mostra i livelli ad alto livello. Il livello Cell e il livello Provision and Deploy non rientrano nell'ambito di questo modello.
![\[Il livello Routing, il livello Cell con più account di celle e il livello Provision and Deploy.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/fd2fbf9d-9ae4-4c27-bc32-cf117350137a/images/137ac34d-43c3-42b6-95de-a365ff611ce8.png)
Per ulteriori informazioni sull'architettura basata su celle, vedere [Riduzione dell'ambito di impatto con l'architettura basata su celle: routing delle celle](https://docs.aws.amazon.com/wellarchitected/latest/reducing-scope-of-impact-with-cell-based-architecture/cell-routing.html).
**Modello di progettazione Cell-router**
Il router cellulare è un componente condiviso tra le celle. Per mitigare i potenziali impatti, è importante che il livello di routing utilizzi un design semplicistico e scalabile orizzontalmente che sia il più sottile possibile. Il livello di routing, che funge da punto di ingresso del sistema, è costituito solo dai componenti necessari per assegnare in modo efficiente gli utenti alle celle appropriate. I componenti di questo livello non si occupano della gestione o della creazione di celle.
Questo modello utilizza il routing statico, il che significa che il client memorizza nella cache gli endpoint all'accesso iniziale e successivamente stabilisce una comunicazione diretta con la cella. Vengono avviate interazioni periodiche tra il client e il router cellulare per confermare lo stato corrente o recuperare eventuali aggiornamenti. Questo disaccoppiamento intenzionale consente operazioni ininterrotte per gli utenti esistenti in caso di inattività del router e fornisce funzionalità e resilienza continue all'interno del sistema.
In questo modello, il router cellulare supporta le seguenti funzionalità:
+ Recupero dei dati delle celle dal database delle celle nel livello Provision and Deploy e archiviazione o aggiornamento del database locale.
+ Assegnazione di una cella a ogni nuovo utente registrato dell'applicazione utilizzando l'algoritmo di assegnazione delle celle.
+ Memorizzazione della user-to-cells mappatura nel database locale.
+ Verifica della capacità delle celle durante l'assegnazione dell'utente e trasmissione di un evento per il distributore automatico al livello Provision and Deploy per creare celle.
+ Utilizzo dell'algoritmo dei criteri di creazione delle celle per fornire questa funzionalità.
+ Rispondere alle richieste degli utenti appena registrati fornendo le URLs celle statiche. Queste URLs verranno memorizzate nella cache del client con un time to live (TTL).
+ Rispondere alle richieste degli utenti esistenti di un URL non valido fornendo un URL nuovo o aggiornato.
Per comprendere meglio il router cellulare dimostrativo configurato dal CloudFormation modello, esamina i seguenti componenti e passaggi:
1. Configura e configura il pool di utenti di Amazon Cognito.
1. Configura e configura l'API API Gateway per il router cellulare.
1. Crea una tabella DynamoDB.
1. Crea e configura una coda SQS.
1. Implementa il. `Orchestrator`
1. Implementa le funzioni Lambda:`Dispatcher`,,`Scaler`,`Mapper`. `Validator`
1. Valuta e verifica.
Il presupposto è che il livello Provision and Deploy sia già stabilito. I dettagli di implementazione non rientrano nell'ambito di questo artefatto.
Poiché questi componenti sono impostati e configurati da un CloudFormation modello, i passaggi seguenti vengono presentati a un livello descrittivo e di alto livello. Il presupposto è che l'utente disponga delle AWS competenze necessarie per completare l'installazione e la configurazione.
*1. Imposta e configura il pool di utenti di Amazon Cognito*
Accedi a e apri Console di gestione AWS la console Amazon Cognito all'indirizzo. [https://console.aws.amazon.com/cognito/]() Configura e configura un pool di utenti Amazon Cognito denominato`CellRouterPool`, con integrazione di app, interfaccia utente ospitata e le autorizzazioni necessarie.
*2. Configurare e configurare l'API API Gateway per il router cellulare*
Apri la console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway/](). Configura e configura un'API denominata`CellRouter`, utilizzando un autorizzatore Amazon Cognito integrato con il pool di utenti di Amazon Cognito. `CellRouterPool` Implementa i seguenti elementi:
+ `CellRouter`Risorse API, inclusi `POST` i metodi
+ Integrazione con il flusso di lavoro Step Functions implementato nella fase 5
+ Autorizzazione tramite l'autorizzatore Amazon Cognito
+ Mappature delle richieste di integrazione e delle risposte
+ Assegnazione delle autorizzazioni necessarie
*3. Creare una tabella DynamoDB*
Apri la console DynamoDB [https://console.aws.amazon.com/dynamodb/]()all'indirizzo e crea una tabella DynamoDB standard chiamata con la seguente configurazione: `tbl_router`
+ **Chiave di partizione ‒** `marketId`
+ **Chiave di ordinamento ‒** `cellId`
+ **Modalità di capacità** ‒ Fornito
+ **Point-in-time recovery (PITR) ‒ Disattivato**
Nella scheda **Indici**, crea un indice secondario globale chiamato. `marketId-currentCapacity-index` La funzione `Scaler` Lambda utilizzerà l'indice per condurre ricerche efficienti per la cella con il minor numero di utenti assegnati.
Crea la struttura della tabella con i seguenti attributi:
+ `marketId`‒ Europa
+ `cellId`‒ cell-0002
+ `currentCapacity`‒ 2
+ `endPoint_1`‒
+ `endPoint_2`‒
+ `IsHealthy`‒ Vero
+ `maxCapacity`‒ 10
+ `regionCode_1` ‒ `eu-north-1`
+ `regionCode_2` ‒ `eu-central-1`
+ `userIds`‒
*4. Creare e configurare una coda SQS*
**Apri la console Amazon SQS all'indirizzo [https://console.aws.amazon.com/sqs/]()e crea una coda SQS standard chiamata crittografia a chiave Amazon SQS configurata con `CellProvisioning` Amazon SQS.**
*5. Implementa l'Orchestrator*
Sviluppa un flusso di lavoro Step Functions che funga da flusso di lavoro `Orchestrator` per il router. Il flusso di lavoro è richiamabile tramite l'API del router cellulare. Il flusso di lavoro esegue le funzioni Lambda designate in base al percorso della risorsa. Integra la funzione step con l'API Gateway API per il router `CellRouter` cellulare e configura le autorizzazioni necessarie per richiamare le funzioni Lambda.
Il diagramma seguente mostra il flusso di lavoro. Lo stato di scelta richiama una delle funzioni Lambda. Se la funzione Lambda ha esito positivo, il flusso di lavoro termina. Se la funzione Lambda fallisce, viene chiamato lo stato fail.
![\[Un diagramma del flusso di lavoro con le quattro funzioni e che termina con uno stato di errore.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/fd2fbf9d-9ae4-4c27-bc32-cf117350137a/images/cfe8d029-6f30-49a1-aaad-cad503bdcbae.png)
*6. Implementa le funzioni Lambda*
Implementa le `Validator` funzioni `Dispatcher` `Mapper``Scaler`,, e. Quando imposti e configuri ciascuna funzione nella dimostrazione, definisci un ruolo per la funzione e assegna le autorizzazioni necessarie per eseguire le operazioni richieste sulla tabella DynamoDB. `tbl_router` Inoltre, integra ogni funzione nel flusso di lavoro. `Orchestrator`
*Funzione Dispatcher*
La `Dispatcher` funzione è responsabile dell'identificazione e dell'assegnazione di una singola cella statica per ogni nuovo utente registrato. Quando un nuovo utente si registra con l'applicazione globale, la richiesta viene inviata alla `Dispatcher` funzione. La funzione elabora la richiesta utilizzando criteri di valutazione predefiniti come i seguenti:
1. **Regione** ‒ Seleziona la cella nel mercato in cui si trova l'utente. Ad esempio, se l'utente accede all'applicazione globale dall'Europa, seleziona una cella che utilizza Regioni AWS in Europa.
1. **Prossimità o latenza** ‒ Seleziona la cella più vicina all'utente Ad esempio, se l'utente accede all'applicazione dall'Olanda, la funzione considera una cella che utilizza Francoforte e l'Irlanda. La decisione relativa alla cella più vicina si basa su metriche come la latenza tra la posizione dell'utente e le regioni della cella. Per questo modello di esempio, le informazioni vengono alimentate staticamente dal livello Provision and Deploy.
1. **Health** ‒ La `Dispatcher` funzione verifica se la cella selezionata è integra in base allo stato della cella fornito (Healthy = true o false).
1. **Capacità** ‒ La distribuzione degli utenti si basa sul *numero minimo di utenti in una logica cellulare*, quindi l'utente viene assegnato alla cella con il minor numero di utenti.
**Nota**
Questi criteri vengono presentati solo per spiegare questo modello di esempio. Per un'implementazione di un router cellulare nella vita reale, è possibile definire criteri più raffinati e utilizzare criteri basati su casi.
`Orchestrator`Richiama la funzione Dispatcher per assegnare gli utenti alle celle. In questa funzione demo, il valore di mercato è un parametro statico definito come. `europe`
La `Dispatcher` funzione valuta se una cella è già assegnata all'utente. Se la cella è già assegnata, la `Dispatcher` funzione restituisce gli estremi della cella. Se all'utente non è assegnata alcuna cella, la funzione cerca la cella con il minor numero di utenti, la assegna all'utente e restituisce gli endpoint. L'efficienza della query di ricerca delle celle è ottimizzata utilizzando l'indice secondario globale.
*Funzione Mapper*
La `Mapper` funzione sovrintende alla memorizzazione e alla manutenzione delle user-to-cell mappature nel database. Una singola cella viene assegnata a ciascun utente registrato. Ogni cella ne ha due distinte URLs, una per ogni regione AWS. Fungendo da endpoint API ospitati su API Gateway, URLs funzionano come punti in entrata verso l'applicazione globale.
Quando la `Mapper` funzione riceve una richiesta dall'applicazione client, esegue una query sulla `tbl_router` tabella DynamoDB per recuperare user-to-cell la mappatura associata all'ID e-mail fornito. Se trova una cella assegnata, la `Mapper` funzione fornisce prontamente le due della cella. URLs La `Mapper` funzione monitora inoltre attivamente le modifiche alla cella URLs e avvia notifiche o aggiornamenti alle impostazioni dell'utente.
*Funzione Scaler*
La `Scaler` funzione gestisce la capacità residua della cella. Per ogni nuova richiesta di registrazione utente, la `Scaler` funzione valuta la capacità disponibile della cella assegnata dalla `Dispatcher` funzione all'utente. Se la cella ha raggiunto il limite predeterminato in base ai criteri di valutazione specificati, la funzione avvia una richiesta tramite una coda Amazon SQS al livello Provision and Deploy, richiedendo il provisioning e l'implementazione di nuove celle. Il ridimensionamento delle celle può essere eseguito in base a una serie di criteri di valutazione come i seguenti:
1. **Numero massimo di utenti** ‒ Ogni cella può avere un numero massimo di utenti 500.
1. **Capacità buffer** ‒ La capacità buffer di ogni cella è del 20 percento, il che significa che ogni cella può essere assegnata a 400 utenti in qualsiasi momento. Il restante 20% della capacità buffer è riservato a casi d'uso futuri e alla gestione di scenari imprevisti (ad esempio, quando i servizi di creazione e provisioning delle celle non sono disponibili).
1. **Creazione di celle** ‒ Non appena una cella esistente raggiunge il 70 percento della capacità, viene attivata una richiesta per creare una cella aggiuntiva.
**Nota**
Questi criteri vengono presentati solo per spiegare questo modello di esempio. Per un'implementazione di un router cellulare nella vita reale, è possibile definire criteri più raffinati e utilizzare criteri basati su casi.
Il `Scaler` codice dimostrativo viene eseguito da `Orchestrator` after che assegna `Dispatcher` correttamente una cella all'utente appena registrato. Al ricevimento dell'ID della cella da`Dispatcher`, valuta se la cella designata ha una capacità adeguata per ospitare utenti aggiuntivi, sulla base di criteri di valutazione predefiniti. `Scaler` Se la capacità della cella è insufficiente, la `Scaler` funzione invia un messaggio al servizio Amazon SQS. Questo messaggio viene recuperato dal servizio all'interno del livello Provision and Deploy, avviando il provisioning di una nuova cella.
**Funzione di validazione**
La `Validator` funzione identifica e risolve i problemi relativi all'accesso alle celle. Quando un utente accede all'applicazione globale, l'applicazione recupera le celle URLs dalle impostazioni del profilo utente e indirizza le richieste degli utenti a una delle due regioni assegnate all'interno della cella. Se URLs sono inaccessibili, l'applicazione può inviare una richiesta URL di convalida al router cellulare. Il `Orchestrator` cell-router richiama il. `Validator` `Validator`Avvia il processo di convalida. La convalida può includere, tra gli altri controlli, quanto segue:
+ Cella con riferimenti incrociati URLs nella richiesta e URLs memorizzata nel database per identificare ed elaborare potenziali aggiornamenti
+ Esecuzione di un controllo approfondito dello stato (ad esempio, una `HTTP GET` richiesta all'endpoint della cella)
In conclusione, la `Validator` funzione fornisce risposte alle richieste delle applicazioni dei clienti, fornendo lo stato di convalida e le eventuali misure correttive necessarie.
`Validator`È progettato per migliorare l'esperienza dell'utente. Prendiamo in considerazione uno scenario in cui alcuni utenti incontrano difficoltà ad accedere all'applicazione globale perché un incidente causa la temporanea indisponibilità delle celle. Invece di presentare errori generici, la `Validator` funzione può fornire istruzioni per la correzione. Questi passaggi potrebbero includere le seguenti azioni:
+ Informare gli utenti sull'incidente.
+ Fornisci un tempo di attesa approssimativo prima della disponibilità del servizio.
+ Fornisci un numero di contatto dell'assistenza per ottenere ulteriori informazioni.
Il codice demo della `Validator` funzione verifica che la cella fornita dall'utente URLs nella richiesta corrisponda ai record memorizzati nella `tbl_router` tabella. La `Validator` funzione verifica anche se le cellule sono sane.
# Configura l'accesso privato a un bucket Amazon S3 tramite un endpoint VPC
*Martin Maritsch, Nicolas Jacob Baer, Gabriel Rodriguez Garcia, Shukhrat Khodjaev, Mohan Gowda Purushothama e Joaquin Rinaudo, Amazon Web Services*
## Riepilogo
In Amazon Simple Storage Service (Amazon S3), le impostazioni URLs predefinite consentono di condividere file di dimensioni arbitrarie con utenti target. Per impostazione predefinita, le versioni predefinite di Amazon S3 URLs sono accessibili da Internet entro una finestra temporale di scadenza, il che le rende comode da usare. Tuttavia, gli ambienti aziendali spesso richiedono l'accesso ad Amazon S3 preimpostato URLs per essere limitato a una sola rete privata.
Questo modello presenta una soluzione serverless per interagire in modo sicuro con gli oggetti S3 utilizzando dati predefiniti da una rete privata senza attraversamento di Internet URLs . Nell'architettura, gli utenti accedono a un Application Load Balancer tramite un nome di dominio interno. Il traffico viene instradato internamente tramite Amazon API Gateway e un endpoint di cloud privato virtuale (VPC) per il bucket S3. La AWS Lambda funzione genera predefiniti URLs per il download di file tramite l'endpoint VPC privato, che aiuta a migliorare la sicurezza e la privacy dei dati sensibili.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un VPC che include una sottorete distribuita in e connessa alla rete aziendale (ad esempio, tramite). Account AWS AWS Direct Connect
**Limitazioni**
+ Il bucket S3 deve avere lo stesso nome del dominio, quindi ti consigliamo di controllare le regole di denominazione dei bucket [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html).
+ Questa architettura di esempio non include funzionalità di monitoraggio per l'infrastruttura distribuita. Se il tuo caso d'uso richiede il monitoraggio, prendi in considerazione l'aggiunta di [servizi AWS di monitoraggio](https://docs.aws.amazon.com/prescriptive-guidance/latest/implementing-logging-monitoring-cloudwatch/welcome.html).
+ Questa architettura di esempio non include la convalida dell'input. Se il tuo caso d'uso richiede la convalida degli input e un maggiore livello di sicurezza, prendi in considerazione [l'utilizzo AWS WAF per proteggere la tua API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-control-access-aws-waf.html).
+ Questa architettura di esempio non include la registrazione degli accessi con Application Load Balancer. Se il tuo caso d'uso richiede la registrazione degli accessi, valuta la possibilità di abilitare i log di accesso [del Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html).
**Versioni**
+ Python versione 3.11 o successiva
+ Terraform versione 1.6 o successiva
## Architecture
**Stack tecnologico Target**
I seguenti servizi AWS vengono utilizzati nello stack tecnologico di destinazione:
+ **Amazon S3** è il servizio di storage principale utilizzato per caricare, scaricare e archiviare file in modo sicuro.
+ **Amazon API Gateway** espone risorse ed endpoint per l'interazione con il bucket S3. Questo servizio svolge un ruolo nella generazione di dati predefiniti per il download o il caricamento. URLs
+ **AWS Lambda**genera predefiniti URLs per il download di file da Amazon S3. La funzione Lambda viene chiamata da API Gateway.
+ **Amazon VPC** distribuisce risorse all'interno di un VPC per garantire l'isolamento della rete. Il VPC include sottoreti e tabelle di routing per controllare il flusso di traffico.
+ **Application Load Balancer** indirizza il traffico in entrata verso API Gateway o verso l'endpoint VPC del bucket S3. Consente agli utenti della rete aziendale di accedere alle risorse internamente.
+ L'**endpoint VPC per Amazon S3** consente la comunicazione diretta e privata tra le risorse nel VPC e Amazon S3 senza attraversare la rete Internet pubblica.
+ **AWS Identity and Access Management (**IAM) controlla l'accesso alle risorse. AWS Le autorizzazioni sono impostate per garantire interazioni sicure con l'API e altri servizi.
**Architettura Target**
![\[Configurazione dell'accesso privato a un bucket S3 tramite un endpoint VPC\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/683ca6a1-789c-4444-bcbf-e4e80d253df3/images/1ca7ee17-d346-4eb9-bf61-ccf42528a401.png)
Il diagramma illustra quanto segue:
1. Gli utenti della rete aziendale possono accedere all'Application Load Balancer tramite un nome di dominio interno. Partiamo dal presupposto che esista una connessione tra la rete aziendale e la sottorete intranet in Account AWS (ad esempio, tramite una connessione). Direct Connect
1. L'Application Load Balancer indirizza il traffico in entrata verso API Gateway per generare dati predefiniti URLs per il download o il caricamento su Amazon S3 o verso l'endpoint VPC del bucket S3. In entrambi gli scenari, le richieste vengono instradate internamente e non devono attraversare Internet.
1. API Gateway espone risorse ed endpoint per interagire con il bucket S3. In questo esempio, forniamo un endpoint per scaricare file dal bucket S3, ma questo potrebbe essere esteso per fornire anche funzionalità di caricamento.
1. La funzione Lambda genera l'URL predefinito per scaricare un file da Amazon S3 utilizzando il nome di dominio dell'Application Load Balancer anziché il dominio pubblico Amazon S3.
1. L'utente riceve l'URL predefinito e lo utilizza per scaricare il file da Amazon S3 utilizzando Application Load Balancer. Il load balancer include un percorso predefinito per inviare il traffico non destinato all'API verso l'endpoint VPC del bucket S3.
1. L'endpoint VPC indirizza l'URL predefinito con il nome di dominio personalizzato al bucket S3. Il bucket S3 deve avere lo stesso nome del dominio.
**Automazione e scalabilità**
Questo modello utilizza Terraform per distribuire l'infrastruttura dal repository di codice in un. Account AWS
## Tools (Strumenti)
**Strumenti**
+ [Python](https://www.python.org/) è un linguaggio di programmazione per computer generico.
+ [Terraform](https://www.terraform.io/) è uno strumento Infrastructure as Code (IaC) HashiCorp che ti aiuta a creare e gestire risorse cloud e locali.
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) è uno strumento open source che consente di interagire con i AWS servizi tramite comandi nella shell della riga di comando.
**Archivio di codice**
[Il codice per questo pattern è disponibile in un GitHub repository all'indirizzo https://github.com/aws-samples/ private-s3-vpce.](https://github.com/aws-samples/private-s3-vpce)
## Best practice
L'architettura di esempio per questo pattern utilizza le [autorizzazioni IAM](https://docs.aws.amazon.com/apigateway/latest/developerguide/permissions.html) per controllare l'accesso all'API. Chiunque disponga di credenziali IAM valide può chiamare l'API. Se il tuo caso d'uso richiede un modello di autorizzazione più complesso, potresti voler [utilizzare un meccanismo di controllo degli accessi diverso](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-control-access-to-api.html).
## Epiche
### Implementa la soluzione in un Account AWS
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Ottenere AWS le credenziali. | Controlla AWS le tue credenziali e il tuo accesso al tuo account. Per istruzioni, consulta [Impostazioni dei file di configurazione e credenziali](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html) nella AWS CLI documentazione. | AWS DevOps, Informazioni generali su AWS |
| Clonare il repository. | Clona il GitHub repository fornito con questo modello:git clone https://github.com/aws-samples/private-s3-vpce
| AWS DevOps, Informazioni generali su AWS |
| Configura le variabili. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/set-up-private-access-to-an-amazon-s3-bucket-through-a-vpc-endpoint.html) | AWS DevOps, Informazioni generali su AWS |
| Implementa una soluzione. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/set-up-private-access-to-an-amazon-s3-bucket-through-a-vpc-endpoint.html) | AWS DevOps, Informazioni generali su AWS |
### Test della soluzione
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea un file di test. | Carica un file su Amazon S3 per creare uno scenario di test per il download del file. Puoi utilizzare la [console Amazon S3](https://console.aws.amazon.com/s3/) o il seguente AWS CLI comando:aws s3 cp /path/to/testfile s3://your-bucket-name/testfile
| AWS DevOps, Informazioni generali su AWS |
| Prova la funzionalità degli URL predefiniti. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/set-up-private-access-to-an-amazon-s3-bucket-through-a-vpc-endpoint.html) | AWS DevOps, Informazioni generali su AWS |
| Elimina. | Assicurati di rimuovere le risorse quando non sono più necessarie:terraform destroy
| AWS DevOps, Informazioni generali su AWS |
## risoluzione dei problemi
| Problema | Soluzione |
| --- | --- |
| I nomi delle chiavi degli oggetti S3 con caratteri speciali come i segni numerici (\$1) interrompono i parametri URL e generano errori. | Codifica correttamente i parametri URL e assicurati che il nome della chiave dell'oggetto S3 segua le linee guida di [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html). |
## Risorse correlate
Amazon S3:
+ [Condivisione di oggetti con predefiniti URLs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/ShareObjectPreSignedURL.html)
+ [Controllo dell'accesso dagli endpoint VPC con policy bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies-vpc-endpoint.html)
Amazon API Gateway:
+ [Usa le policy degli endpoint VPC per uso privato APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-vpc-endpoint-policies.html)
Application Load Balancer:
+ [Hosting di siti Web statici HTTPS interni con ALB, S3 e PrivateLink (AWS post](https://aws.amazon.com/blogs/networking-and-content-delivery/hosting-internal-https-static-websites-with-alb-s3-and-privatelink/) del blog)
# Risolvi i problemi relativi agli stati AWS Step Functions utilizzando Amazon Bedrock
*Aniket Kurzadkar e Sangam Kushwaha, Amazon Web Services*
## Riepilogo
AWS Step Functions le funzionalità di gestione degli errori possono aiutarti a individuare un errore che si verifica durante uno stato di un [flusso di lavoro](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-statemachines.html), ma può comunque essere difficile individuare la causa principale di un errore ed eseguirne il debug. Questo modello affronta questa sfida e mostra come Amazon Bedrock può aiutarti a risolvere gli errori che si verificano durante gli stati di Step Functions.
Step Functions fornisce l'orchestrazione del flusso di lavoro, semplificando l'automazione dei processi per gli sviluppatori. Step Functions offre anche funzionalità di gestione degli errori che offrono i seguenti vantaggi:
+ Gli sviluppatori possono creare applicazioni più resilienti che non falliscono completamente quando qualcosa va storto.
+ I flussi di lavoro possono includere la logica condizionale per gestire diversi tipi di errori in modo diverso.
+ Il sistema può riprovare automaticamente le operazioni non riuscite, magari con un backoff esponenziale.
+ È possibile definire percorsi di esecuzione alternativi per gli scenari di errore, consentendo al flusso di lavoro di adattarsi e continuare l'elaborazione.
Quando si verifica un errore in un flusso di lavoro Step Functions, questo modello mostra come inviare il messaggio di errore e il contesto a un modello base (FM) come Claude 3 supportato da Step Functions. L'FM può analizzare l'errore, classificarlo e suggerire potenziali passaggi di correzione.
## Prerequisiti e limitazioni
**Prerequisiti**
+ Un attivo Account AWS
+ Conoscenza di base [AWS Step Functions e flussi di lavoro](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-statemachines.html)
+ Connettività dell'[API](https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api.html) Amazon Bedrock
**Limitazioni**
+ Puoi utilizzare l'approccio di questo modello per vari Servizi AWS scopi. Tuttavia, i risultati potrebbero variare in base al prompt creato e successivamente valutato da AWS Lambda Amazon Bedrock.
+ Alcuni Servizi AWS non sono disponibili in tutti. Regioni AWS Per la disponibilità regionale, consulta [i servizi AWS per regione](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/). Per endpoint specifici, consulta [Endpoints and quotas del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) e scegli il link relativo al servizio.
## Architecture
Il diagramma seguente mostra i componenti del flusso di lavoro e dell'architettura per questo modello.
![\[Flusso di lavoro per la gestione e la notifica degli errori tramite Step Functions, Amazon Bedrock e Amazon SNS.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/images/pattern-img/78f86c74-c9de-4562-adcc-105b87a77a54/images/d8eda499-ea1d-45e5-8a36-e04a44ad5c4b.png)
Il diagramma mostra il flusso di lavoro automatizzato per la gestione e la notifica degli errori in una macchina a stati Step Functions:
1. Lo sviluppatore avvia l'esecuzione di una macchina a stati.
1. La macchina a stati Step Functions inizia a elaborare i suoi stati. I risultati possibili sono due:
+ (a) Se tutti gli stati vengono eseguiti correttamente, il flusso di lavoro passa direttamente ad Amazon SNS per una notifica di successo via e-mail.
+ (b) Se uno stato fallisce, il flusso di lavoro passa alla funzione Lambda per la gestione degli errori.
1. In caso di errore, si verifica quanto segue:
+ (a) Viene attivata la funzione Lambda (gestore degli errori). La funzione Lambda estrae il messaggio di errore dai dati dell'evento che la macchina a stati Step Functions le ha passato. Quindi la funzione Lambda prepara un prompt basato su questo messaggio di errore e lo invia ad Amazon Bedrock. Il prompt richiede soluzioni e suggerimenti relativi all'errore specifico riscontrato.
+ (b) Amazon Bedrock, che ospita il modello di intelligenza artificiale generativa, elabora la richiesta di input. (Questo modello utilizza il modello di base Anthropic Claude 3 (FM), uno dei tanti supportati da FMs Amazon Bedrock.) Il modello di intelligenza artificiale analizza il contesto dell'errore. Quindi il modello genera una risposta che può includere spiegazioni del motivo per cui si è verificato l'errore, potenziali soluzioni per risolverlo e suggerimenti per evitare di ripetere gli stessi errori in futuro.
Amazon Bedrock restituisce la risposta generata dall'intelligenza artificiale alla funzione Lambda. La funzione Lambda elabora la risposta, potenzialmente formattandola o estraendo informazioni chiave. Quindi la funzione Lambda invia la risposta all'output della macchina a stati.
1. Dopo la gestione degli errori o l'esecuzione corretta, il flusso di lavoro si conclude attivando Amazon SNS per l'invio di una notifica e-mail.
## Tools (Strumenti)
**Servizi AWS**
+ [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html) è un servizio completamente gestito che rende disponibili per l'uso modelli di base ad alte prestazioni (FMs) delle principali startup di intelligenza artificiale e di Amazon tramite un'API unificata.
+ [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 elaborazione 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.
+ [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html)è un servizio di orchestrazione senza server che ti aiuta a combinare AWS Lambda funzioni e altro per creare applicazioni aziendali critiche. Servizi AWS
## Best practice
+ Poiché Amazon Bedrock è un modello di intelligenza artificiale generativo che apprende dai dati addestrati, utilizza tali dati anche per addestrare e generare contesto. Come best practice, nascondi tutte le informazioni private che potrebbero causare problemi di fuga di dati.
+ Sebbene l'intelligenza artificiale generativa possa fornire informazioni preziose, le decisioni critiche relative alla gestione degli errori dovrebbero comunque coinvolgere la supervisione umana, specialmente negli ambienti di produzione.
## Epiche
### Crea una macchina a stati per il tuo flusso di lavoro
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Crea una macchina a stati. | Per creare una macchina a stati adatta al tuo flusso di lavoro, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/troubleshooting-states-in-aws-step-functions.html) | AWS DevOps |
### Creazione di una funzione Lambda
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Creazione di una funzione Lambda. | Per creare una funzione Lambda, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/troubleshooting-states-in-aws-step-functions.html) | AWS DevOps |
| Imposta la logica richiesta nel codice Lambda. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/troubleshooting-states-in-aws-step-functions.html)client = boto3.client(
service_name="bedrock-runtime", region_name="selected-region"
)
# Invoke Claude 3 with the text prompt
model_id = "your-model-id" # Select your Model ID, Based on the Model Id, Change the body format
try:
response = client.invoke_model(
modelId=model_id,
body=json.dumps(
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 1024,
"messages": [
{
"role": "user",
"content": [{"type": "text", "text": prompt}],
}
],
}
),
)
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/troubleshooting-states-in-aws-step-functions.html) | AWS DevOps |
### Integrazione di Step Functions con Lambda
| Operazione | Description | Competenze richieste |
| --- | --- | --- |
| Configura Lambda per gestire gli errori in Step Functions. | Per configurare Step Functions in modo da gestire gli errori senza interrompere il flusso di lavoro, procedi come segue:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/patterns/troubleshooting-states-in-aws-step-functions.html) | AWS DevOps |
## Risoluzione dei problemi
| Problema | Soluzione |
| --- | --- |
| Lambda non può accedere all'API Amazon Bedrock (non autorizzata a eseguire) | Questo errore si verifica quando il ruolo Lambda non dispone dell'autorizzazione per accedere all'API Amazon Bedrock. Per risolvere questo problema, aggiungi la `AmazonBedrockFullAccess` policy per il ruolo Lambda. Per ulteriori informazioni, consulta [AmazonBedrockFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonBedrockFullAccess.html)la *AWS Managed Policy Reference Guide*. |
| Errore di timeout Lambda | A volte possono essere necessari più di 30 secondi per generare una risposta e inviarla indietro, a seconda della richiesta. Per risolvere questo problema, aumenta il tempo di configurazione. *Per ulteriori informazioni, consulta [Configura il timeout della funzione Lambda](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonBedrockFullAccess.html) nella Guida per gli AWS Lambda sviluppatori.* |
## Risorse correlate
+ [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/what-is-bedrock.html)
+ [Accesso all'API Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started-api.html)
+ [Crea la tua prima funzione Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html)
+ [Sviluppo di flussi di lavoro con Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/developing-workflows.html#development-run-debug)
+ [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html)
# Altri modelli
**Topics**
+ [Accedi, esegui query e unisciti a tabelle Amazon DynamoDB utilizzando Athena](access-query-and-join-amazon-dynamodb-tables-using-athena.md)
+ [Automatizza le CodeGuru revisioni Amazon per le applicazioni AWS CDK Python utilizzando Actions GitHub](automate-amazon-codeguru-reviews-for-aws-cdk-python-applications.md)
+ [Automatizza la valutazione delle risorse AWS](automate-aws-resource-assessment.md)
+ [Automatizza la distribuzione di applicazioni annidate utilizzando AWS SAM](automate-deployment-of-nested-applications-using-aws-sam.md)
+ [Automatizza l'implementazione dei Catena di approvvigionamento di AWS data lake in una configurazione multi-repository utilizzando GitHub Actions, Artifactory e Terraform](automate-the-deployment-of-aws-supply-chain-data-lakes.md)
+ [Automatizza la replica delle istanze Amazon RDS su Account AWS](automate-the-replication-of-amazon-rds-instances-across-aws-accounts.md)
+ [Archivia automaticamente gli elementi su Amazon S3 utilizzando DynamoDB TTL](automatically-archive-items-to-amazon-s3-using-dynamodb-ttl.md)
+ [Rileva automaticamente le modifiche e avvia diverse CodePipeline pipeline per un monorepo in CodeCommit](automatically-detect-changes-and-initiate-different-codepipeline-pipelines-for-a-monorepo-in-codecommit.md)
+ [Crea un'architettura serverless multi-tenant in Amazon Service OpenSearch](build-a-multi-tenant-serverless-architecture-in-amazon-opensearch-service.md)
+ [Crea un visualizzatore di file mainframe avanzato nel cloud AWS](build-an-advanced-mainframe-file-viewer-in-the-aws-cloud.md)
+ [Calcola il valore a rischio (VaR) utilizzando i servizi AWS](calculate-value-at-risk-var-by-using-aws-services.md)
+ [Copia i prodotti AWS Service Catalog su diversi account AWS e regioni AWS](copy-aws-service-catalog-products-across-different-aws-accounts-and-aws-regions.md)
+ [Crea automaticamente pipeline CI dinamiche per progetti Java e Python](create-dynamic-ci-pipelines-for-java-and-python-projects-automatically.md)
+ [Scomponi i monoliti in microservizi utilizzando CQRS e l'event sourcing](decompose-monoliths-into-microservices-by-using-cqrs-and-event-sourcing.md)
+ [Implementa un'applicazione a pagina singola basata su React su Amazon S3 e CloudFront](deploy-a-react-based-single-page-application-to-amazon-s3-and-cloudfront.md)
+ [Implementa un'API Amazon API Gateway su un sito Web interno utilizzando endpoint privati e un Application Load Balancer](deploy-an-amazon-api-gateway-api-on-an-internal-website-using-private-endpoints-and-an-application-load-balancer.md)
+ [Implementa e gestisci un data lake serverless sul cloud AWS utilizzando l'infrastruttura come codice](deploy-and-manage-a-serverless-data-lake-on-the-aws-cloud-by-using-infrastructure-as-code.md)
+ [Implementa uno use case RAG AWS utilizzando Terraform e Amazon Bedrock](deploy-rag-use-case-on-aws.md)
+ [Sviluppa un assistente basato su chat completamente automatizzato utilizzando gli agenti e le knowledge base di Amazon Bedrock](develop-a-fully-automated-chat-based-assistant-by-using-amazon-bedrock-agents-and-knowledge-bases.md)
+ [Sviluppa assistenti avanzati basati sull'intelligenza artificiale generativa utilizzando RAG e suggerimenti ReAct](develop-advanced-generative-ai-chat-based-assistants-by-using-rag-and-react-prompting.md)
+ [Genera dinamicamente una policy IAM con IAM Access Analyzer utilizzando Step Functions](dynamically-generate-an-iam-policy-with-iam-access-analyzer-by-using-step-functions.md)
+ [Incorpora i componenti visivi di Amazon Quick Sight nelle applicazioni Web utilizzando Amazon Cognito e l'automazione IAc](embed-quick-sight-visual-components-into-web-apps-cognito-iac.md)
+ [Assicurati che la registrazione di Amazon EMR su Amazon S3 sia abilitata al momento del lancio](ensure-amazon-emr-logging-to-amazon-s3-is-enabled-at-launch.md)
+ [Stima del costo di una tabella DynamoDB per la capacità su richiesta](estimate-the-cost-of-a-dynamodb-table-for-on-demand-capacity.md)
+ [Genera consigli personalizzati e riclassificati con Amazon Personalize](generate-personalized-and-re-ranked-recommendations-using-amazon-personalize.md)
+ [Genera dati di test utilizzando un job AWS Glue e Python](generate-test-data-using-an-aws-glue-job-and-python.md)
+ [SHA1 Implementa l'hashing per i dati PII durante la migrazione da SQL Server a PostgreSQL](implement-sha1-hashing-for-pii-data-when-migrating-from-sql-server-to-postgresql.md)
+ [Implementa il modello di saga serverless utilizzando AWS Step Functions](implement-the-serverless-saga-pattern-by-using-aws-step-functions.md)
+ [Migliora le prestazioni operative abilitando Amazon DevOps Guru su più regioni AWS, account e OUs con AWS CDK](improve-operational-performance-by-enabling-amazon-devops-guru-across-multiple-aws-regions-accounts-and-ous-with-the-aws-cdk.md)
+ [Avvia un CodeBuild progetto su più account AWS utilizzando Step Functions e una funzione proxy Lambda](launch-a-codebuild-project-across-aws-accounts-using-step-functions-and-a-lambda-proxy-function.md)
+ [Esegui la migrazione dei carichi di lavoro Apache Cassandra su Amazon Keyspaces utilizzando AWS Glue](migrate-apache-cassandra-workloads-to-amazon-keyspaces-by-using-aws-glue.md)
+ [Monitora l'uso di un'Amazon Machine Image condivisa su più Account AWS](monitor-use-of-a-shared-amazon-machine-image-across-multiple-aws-accounts.md)
+ [Ottimizza le implementazioni serverless multi-account utilizzando i flussi di lavoro e Actions AWS CDK GitHub](optimize-multi-account-serverless-deployments.md)
+ [Orchestra una pipeline ETL con convalida, trasformazione e partizionamento utilizzando AWS Step Functions](orchestrate-an-etl-pipeline-with-validation-transformation-and-partitioning-using-aws-step-functions.md)
+ [Interroga le tabelle Amazon DynamoDB con SQL utilizzando Amazon Athena](query-amazon-dynamodb-tables-sql-amazon-athena.md)
+ [Esegui carichi di lavoro pianificati e basati su eventi su larga scala con AWS Fargate](run-event-driven-and-scheduled-workloads-at-scale-with-aws-fargate.md)
+ [Invia attributi personalizzati ad Amazon Cognito e inseriscili in token](send-custom-attributes-cognito.md)
+ [Distribuisci contenuti statici in un bucket Amazon S3 tramite un VPC utilizzando Amazon CloudFront](serve-static-content-in-an-amazon-s3-bucket-through-a-vpc-by-using-amazon-cloudfront.md)
+ [Semplifica lo sviluppo e la distribuzione di bot Amazon Lex utilizzando un flusso di lavoro automatizzato](streamline-amazon-lex-bot-development-and-deployment-using-an-automated-workflow.md)
+ [Struttura un progetto Python in architettura esagonale utilizzando AWS Lambda](structure-a-python-project-in-hexagonal-architecture-using-aws-lambda.md)
+ [Traduci il linguaggio naturale in query DSL for OpenSearch ed Elasticsearch](translate-natural-language-query-dsl-opensearch-elasticsearch.md)
+ [Scarica i dati da un cluster Amazon Redshift tra più account su Amazon S3](unload-data-from-amazon-redshift-cross-accounts-to-amazon-s3.md)
+ [Coordina la dipendenza dalle risorse e l'esecuzione delle attività utilizzando il costrutto AWS Fargate WaitCondition hook](use-the-aws-fargate-waitcondition-hook-construct.md)
+ [Usa gli agenti Amazon Bedrock per automatizzare la creazione di controlli di accesso in Amazon EKS tramite istruzioni basate su testo](using-amazon-bedrock-agents-to-automate-creation-of-access-entry-controls-in-amazon-eks.md)