

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Esegui letture parallele di oggetti S3 usando Python in una funzione AWS Lambda
<a name="run-parallel-reads-of-s3-objects-by-using-python-in-an-aws-lambda-function"></a>

*Eduardo Bortoluzzi, Amazon Web Services*

## Riepilogo
<a name="run-parallel-reads-of-s3-objects-by-using-python-in-an-aws-lambda-function-summary"></a>

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
<a name="run-parallel-reads-of-s3-objects-by-using-python-in-an-aws-lambda-function-prereqs"></a>

**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
<a name="run-parallel-reads-of-s3-objects-by-using-python-in-an-aws-lambda-function-architecture"></a>

**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)
<a name="run-parallel-reads-of-s3-objects-by-using-python-in-an-aws-lambda-function-tools"></a>

**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
<a name="run-parallel-reads-of-s3-objects-by-using-python-in-an-aws-lambda-function-best-practices"></a>
+ 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
<a name="run-parallel-reads-of-s3-objects-by-using-python-in-an-aws-lambda-function-epics"></a>

### Prepara l'ambiente di sviluppo
<a name="prepare-the-development-environment"></a>


| 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
<a name="clone-the-example-repository"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Clonare il repository. | Per clonare l'ultima versione del repository, esegui il seguente comando:<pre>git clone --depth 1 --branch v1.2.0 \<br />git@github.com:aws-samples/aws-lambda-parallel-download.git</pre> | Architetto del cloud | 
| Cambia la directory di lavoro nel repository clonato. | Esegui il comando seguente:<pre>cd aws-lambda-parallel-download</pre> | Architetto del cloud | 
| Crea l'ambiente virtuale Python. | Per creare un ambiente virtuale Python, esegui il seguente comando:<pre>python3 -m venv .venv</pre> | Architetto cloud | 
| Attiva l'ambiente virtuale. | Per attivare l'ambiente virtuale, esegui il seguente comando:<pre>source .venv/bin/activate</pre> | Architetto del cloud | 
| Installa le dipendenze. | Per installare le dipendenze Python, esegui il comando: `pip`<pre>pip install -r requirements.txt</pre> | 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
<a name="deploy-and-test-the-app"></a>


| 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:<pre>aws s3 cp sample.json s3://<ParallelDownloadStack.SampleS3BucketName></pre>Sostituisci `<ParallelDownloadStack.SampleS3BucketName>` 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`<pre>{"repeat": 1500, "objectKey": "sample.json"}</pre> | Architetto del cloud | 

### Opzionale: esegui AWS Lambda Power Tuning
<a name="optional-run-lamlong-power-tuning"></a>


| 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
<a name="clean-up"></a>


| Operazione | Description | Competenze richieste | 
| --- | --- | --- | 
| Rimuovi gli oggetti dal bucket S3. | Prima di distruggere le risorse distribuite, rimuovi tutti gli oggetti dal bucket S3:<pre>aws s3 rm s3://<ParallelDownloadStack.SampleS3BucketName> \<br />--recursive</pre>Ricordati di sostituirlo `<ParallelDownloadStack.SampleS3BucketName>` 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:<pre>cdk destroy</pre> | Architetto del cloud | 

## risoluzione dei problemi
<a name="run-parallel-reads-of-s3-objects-by-using-python-in-an-aws-lambda-function-troubleshooting"></a>


| 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:<pre>"powerValues": [<br />    512,<br />    1024,<br />    1536,<br />    2048,<br />    2560,<br />    3008<br />  ]</pre> | 

## Risorse correlate
<a name="run-parallel-reads-of-s3-objects-by-using-python-in-an-aws-lambda-function-resources"></a>
+ [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
<a name="run-parallel-reads-of-s3-objects-by-using-python-in-an-aws-lambda-function-additional"></a>

**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)
