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à.
# Utilizzo di archivi di file .zip per le funzioni Lambda in Python
Il codice della AWS Lambda funzione comprende un file.py contenente il codice del gestore della funzione, insieme a tutti i pacchetti e i moduli aggiuntivi da cui dipende il codice. Per implementare questo codice della funzione in Lambda, utilizza un *pacchetto di implementazione*. Questo pacchetto può essere un archivio di file .zip o un'immagine di container. Per ulteriori informazioni sull'uso delle immagini di container con Python, consulta la sezione [Implementazione di funzioni Lambda in Python con immagini di container](https://docs.aws.amazon.com/lambda/latest/dg/python-image.html).
Per creare un pacchetto di implementazione come archivio di file .zip, puoi utilizzare l'utilità di archiviazione di file .zip incorporata del tuo strumento della linea di comando o qualsiasi altra utilità file .zip, come ad esempio [7zip](https://www.7-zip.org/download.html). Gli esempi mostrati nelle sezioni seguenti presuppongono che tu stia utilizzando uno strumento della linea di comando `zip` in un ambiente Linux o MacOS. Per utilizzare gli stessi comandi in Windows, puoi [installare il sottosistema Windows per Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) per ottenere una versione di Ubuntu e Bash integrata con Windows.
Nota che Lambda utilizza le autorizzazioni dei file POSIX, quindi potresti aver bisogno di [impostare le autorizzazioni per la cartella del pacchetto di implementazione](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-deployment-package-errors/) prima di creare l'archivio di file .zip.
**Topics**
+ [
## Dipendenze di runtime in Python
](#python-package-dependencies)
+ [
## Creazione di un pacchetto di implementazione .zip senza dipendenze
](#python-package-create-no-dependencies)
+ [
## Creazione di un pacchetto di implementazione .zip con dipendenze
](#python-package-create-dependencies)
+ [
## Percorso di ricerca delle dipendenze e librerie incluse nel runtime
](#python-package-searchpath)
+ [
## Utilizzo delle cartelle \$1\$1pycache\$1\$1
](#python-package-pycache)
+ [
## Creazione di un pacchetto di implementazione .zip con librerie native
](#python-package-native-libraries)
+ [
## Creazione e aggiornamento delle funzioni Lambda di Python utilizzando file .zip
](#python-package-create-update)
## Dipendenze di runtime in Python
Per le funzioni Lambda che utilizzano il runtime Python, una dipendenza può essere qualsiasi pacchetto o modulo Python. Se implementi la funzione utilizzando un archivio .zip, puoi aggiungere queste dipendenze al file .zip con il tuo codice della funzione o utilizzare un [livello Lambda](chapter-layers.md). Un livello è un file .zip separato che può contenere codice aggiuntivo o altri contenuti. Per ulteriori informazioni sull'uso dei livelli Lambda in Python, consulta [Utilizzo dei livelli per le funzioni Lambda in Python](python-layers.md).
I runtime Lambda Python includono e le relative dipendenze. AWS SDK per Python (Boto3) Lambda fornisce l'SDK nel runtime per scenari di implementazione in cui non è possibile aggiungere le proprie dipendenze. Questi scenari includono la creazione di funzioni nella console utilizzando l'editor di codice integrato o l'utilizzo di funzioni inline in AWS Serverless Application Model () o modelli.AWS SAM CloudFormation
Lambda aggiorna periodicamente le librerie nel runtime Python per includere gli aggiornamenti e le patch di sicurezza più recenti. Se la funzione utilizza la versione dell'SDK Boto3 inclusa nel runtime ma il pacchetto di implementazione include dipendenze SDK, ciò può causare problemi di disallineamento delle versioni. Ad esempio, il pacchetto di implementazione potrebbe includere la dipendenza SDK urllib3. Quando Lambda aggiorna l'SDK nel runtime, i problemi di compatibilità tra la nuova versione del runtime e la versione di urllib3 nel pacchetto di implementazione possono causare il fallimento della funzione.
**Importante**
Per mantenere il pieno controllo sulle dipendenze ed evitare possibili problemi di disallineamento delle versioni, si consiglia di aggiungere tutte le dipendenze della funzione al pacchetto di implementazione, anche se le relative versioni sono incluse nel runtime Lambda. Ciò include l'SDK Boto3.
Per scoprire quale versione dell'SDK per Python (Boto3) è inclusa nel runtime che stai utilizzando, consulta [Versioni SDK incluse nel runtime](lambda-python.md#python-sdk-included).
In base al [modello di responsabilità condivisa di AWS](https://docs.aws.amazon.com/whitepapers/latest/aws-risk-and-compliance/shared-responsibility-model.html), è tua responsabilità gestire eventuali dipendenze nei pacchetti di implementazione delle tue funzioni. Ciò include l'applicazione di aggiornamenti e patch di sicurezza. Per aggiornare le dipendenze nel pacchetto di implementazione della funzione, crea prima un nuovo file .zip e poi caricalo su Lambda. Per ulteriori informazioni, consulta [Creazione di un pacchetto di implementazione .zip con dipendenze](#python-package-create-dependencies) e [Creazione e aggiornamento delle funzioni Lambda di Python utilizzando file .zip](#python-package-create-update).
## Creazione di un pacchetto di implementazione .zip senza dipendenze
Se il codice della funzione non ha dipendenze, il file .zip contiene solo il file .py con il codice del gestore della funzione. Usa la tua utilità zip preferita per creare un file .zip con il file .py nella directory principale. Se il file .py non si trova nella directory principale del file .zip, Lambda non sarà in grado di eseguire il codice.
Per informazioni su come implementare il file .zip per creare una nuova funzione Lambda o aggiornarne una esistente, consulta la sezione [Creazione e aggiornamento delle funzioni Lambda di Python utilizzando file .zip](#python-package-create-update).
## Creazione di un pacchetto di implementazione .zip con dipendenze
Se il tuo codice della funzione dipende da pacchetti o moduli aggiuntivi, puoi aggiungere queste dipendenze al file .zip con il codice della funzione oppure [utilizzare un livello Lambda](python-layers.md). Le istruzioni in questa sezione mostrano come includere le dipendenze nel pacchetto di implementazione .zip. Affinché Lambda esegua il codice, il file .py contenente il codice del gestore e tutte le dipendenze della funzione deve essere installato nella radice del file .zip.
Supponiamo che il codice della funzione sia salvato in un file denominato `lambda_function.py`. I seguenti comandi della CLI di esempio creano un file .zip denominato `my_deployment_package.zip` contenente il codice della funzione e le relative dipendenze. Puoi installare le tue dipendenze direttamente in una cartella nella directory del tuo progetto o utilizzare un ambiente virtuale Python.
**Creazione del pacchetto di implementazione (directory del progetto)**
1. Passa alla directory del progetto contenente il file del codice sorgente `lambda_function.py`. In questo esempio, la directory è denominata `my_function`.
```
cd my_function
```
1. Crea una nuova directory denominata "pacchetto" in cui installare le tue dipendenze.
```
mkdir package
```
Tieni presente che per un pacchetto di implementazione .zip, Lambda prevede che il codice sorgente e le relative dipendenze siano tutti nella directory principale del file .zip. Tuttavia, l'installazione delle dipendenze direttamente nella directory del progetto può introdurre un gran numero di nuovi file e cartelle e rendere difficile la navigazione nell'IDE. Qui crei una directory `package` separata per mantenere le dipendenze separate dal codice sorgente.
1. Installa le dipendenze nella directory `package`. L'esempio seguente installa l'SDK Boto3 da Python Package Index utilizzando pip. Se il codice della funzione utilizza pacchetti Python creati da te, salvali nella directory `package`.
```
pip install --target ./package boto3
```
1. Crea un file .zip con le librerie installate nella directory principale.
```
cd package
zip -r ../my_deployment_package.zip .
```
Verrà generato un file `my_deployment_package.zip` nella directory del progetto.
1. Aggiunta del file lambda\$1function.py alla directory principale del file .zip
```
cd ..
zip my_deployment_package.zip lambda_function.py
```
Il tuo file .zip dovrebbe avere una struttura di directory semplice, con il codice del gestore della funzione e tutte le cartelle delle dipendenze installate nella directory principale come segue.
```
my_deployment_package.zip
|- bin
| |-jp.py
|- boto3
| |-compat.py
| |-data
| |-docs
...
|- lambda_function.py
```
Se il file .py contenente il codice del gestore della funzione non si trova nella directory principale del file .zip, Lambda non sarà in grado di eseguire il codice.
**Creazione del pacchetto di implementazione (ambiente virtuale)**
1. Crea e attiva un ambiente virtuale nella directory del progetto. In questo esempio, la directory del progetto è denominata `my_function`.
```
~$ cd my_function
~/my_function$ python3.14 -m venv my_virtual_env
~/my_function$ source ./my_virtual_env/bin/activate
```
1. Installa le librerie richieste utilizzando pip. Nell'esempio seguente viene installato l'SDK Boto3
```
(my_virtual_env) ~/my_function$ pip install boto3
```
1. Utilizza `pip show` per trovare la posizione, all'interno del tuo ambiente virtuale, in cui pip ha installato le tue dipendenze.
```
(my_virtual_env) ~/my_function$ pip show
```
La cartella in cui pip installa le tue librerie può essere denominata `site-packages` oppure `dist-packages`. Questa cartella può trovarsi nella directory `lib/python3.x` oppure `lib64/python3.x` (dove python3.x rappresenta la versione di Python che stai utilizzando).
1. Disattivazione dell'ambiente virtuale
```
(my_virtual_env) ~/my_function$ deactivate
```
1. Accedi alla directory contenente le dipendenze che hai installato con pip e crea un file .zip nella directory principale del tuo progetto, nella quale sono installate le dipendenze. In questo esempio, pip ha installato le tue dipendenze nella directory `my_virtual_env/lib/python3.14/site-packages`.
```
~/my_function$ cd my_virtual_env/lib/python3.14/site-packages
~/my_function/my_virtual_env/lib/python3.14/site-packages$ zip -r ../../../../my_deployment_package.zip .
```
1. Vai alla directory principale del tuo progetto, in cui si trova il file .py contenente il codice del gestore, e aggiungi quel file alla directory principale del tuo pacchetto .zip. In questo esempio, il file di codice della funzione è denominato `lambda_function.py`.
```
~/my_function/my_virtual_env/lib/python3.14/site-packages$ cd ../../../../
~/my_function$ zip my_deployment_package.zip lambda_function.py
```
## Percorso di ricerca delle dipendenze e librerie incluse nel runtime
Quando utilizzi un'istruzione `import` nel codice, il runtime Python cerca nelle directory del suo percorso di ricerca finché non trova il modulo o il pacchetto. Per impostazione predefinita, la prima posizione cercata dal runtime è la directory in cui il pacchetto di implementazione .zip viene decompresso e montato (`/var/task`). Se includi una versione di una libreria inclusa nel runtime nel tuo pacchetto di implementazione, questa versione avrà la precedenza sulla versione inclusa nel runtime. Le dipendenze nel pacchetto di implementazione hanno la precedenza anche sulle dipendenze nei livelli.
Quando aggiungi una dipendenza a un livello, Lambda la estrae in `/opt/python/lib/python3.x/site-packages`, dove `python3.x` rappresenta la versione del runtime che stai utilizzando, o `/opt/python`. Nel percorso di ricerca, queste directory hanno la precedenza sulle directory contenenti le librerie incluse nel runtime e le librerie installate con pip (`/var/runtime` e `/var/lang/lib/python3.x/site-packages`). Le librerie nei livelli di funzione hanno quindi la precedenza sulle versioni incluse nel runtime.
**Nota**
Nel runtime gestito e nell'immagine di base di Python 3.11, l' AWS SDK e le sue dipendenze sono installati nella directory. `/var/lang/lib/python3.11/site-packages`
Puoi visualizzare il percorso di ricerca completo per la tua funzione Lambda aggiungendo il seguente frammento di codice.
```
import sys
search_path = sys.path
print(search_path)
```
**Nota**
Poiché le dipendenze nei livelli o nel pacchetto di implementazione hanno la precedenza sulle librerie incluse nel runtime, ciò può causare problemi di disallineamento delle versioni se si include una dipendenza SDK come urllib3 nel pacchetto senza includere anche l'SDK. Se implementi la tua versione di una dipendenza Boto3, devi anche implementare Boto3 come dipendenza nel tuo pacchetto di implementazione. Ti consigliamo di impacchettare tutte le dipendenze della tua funzione, anche se le rispettive versioni sono già incluse nel runtime.
Puoi anche aggiungere dipendenze in una cartella separata all'interno del tuo pacchetto .zip. Ad esempio, potresti aggiungere una versione dell'SDK Boto3 a una cartella del tuo pacchetto .zip chiamata `common`. Quando il pacchetto .zip viene decompresso e montato, questa cartella viene inserita nella directory `/var/task`. Per utilizzare nel codice una dipendenza da una cartella del pacchetto di implementazione .zip, utilizza un'istruzione `import from`. Ad esempio, per utilizzare una versione di Boto3 da una cartella denominata `common` nel tuo pacchetto .zip, usa la seguente istruzione.
```
from common import boto3
```
## Utilizzo delle cartelle \$1\$1pycache\$1\$1
È consigliabile non includere cartelle `__pycache__` nel pacchetto di implementazione della funzione. Il bytecode Python compilato su un computer di compilazione con un'architettura o un sistema operativo diverso potrebbe non essere compatibile con l'ambiente di esecuzione Lambda.
## Creazione di un pacchetto di implementazione .zip con librerie native
Se la tua funzione utilizza solo pacchetti e moduli Python puri, puoi usare il comando `pip install` per installare le tue dipendenze su qualsiasi computer di compilazione locale e creare il file .zip. Molte librerie Python popolari, tra cui NumPy e Pandas, non sono Python puro e contengono codice scritto in C o C\$1\$1. Quando aggiungi librerie contenenti codice C/C\$1\$1 al pacchetto di implementazione, devi creare il pacchetto correttamente per assicurarti che sia compatibile con l'ambiente di esecuzione Lambda.
La maggior parte dei pacchetti disponibili nel Python Package Index ([PyPI](https://pypi.org/)) sono disponibili come "wheel" (file .whl). Un file .whl è un tipo di file ZIP che contiene una distribuzione compilata con file binari precompilati per un particolare sistema operativo e un'architettura di set di istruzioni. Per rendere il pacchetto di implementazione compatibile con Lambda, è necessario installare il wheel per i sistemi operativi Linux e l'architettura del set di istruzioni della funzione.
Alcuni pacchetti possono essere disponibili solo come distribuzioni di origine. Per questi pacchetti, è necessario compilare e creare personalmente i componenti C/C\$1\$1.
Per vedere quali distribuzioni sono disponibili per il pacchetto richiesto, procedi come segue:
1. Cerca il nome del pacchetto nella [pagina principale di Python Package Index](https://pypi.org/).
1. Seleziona la versione del pacchetto da utilizzare.
1. Scegli **Scarica file**.
### Utilizzo di distribuzioni integrate (wheel)
Per scaricare un wheel compatibile con Lambda, utilizza l'opzione `--platform` in pip.
Se la tua funzione Lambda utilizza l'architettura del set di istruzioni **x86\$164**, esegui il comando `pip install` seguente per installare un wheel compatibile nella tua directory `package`. Sostituisci `--python 3.x` con la versione del runtime Python che stai utilizzando.
```
pip install \
--platform manylinux2014_x86_64 \
--target=package \
--implementation cp \
--python-version 3.x \
--only-binary=:all: --upgrade \
```
Se la funzione utilizza l'architettura del set di istruzioni **arm64**, esegui il seguente comando. Sostituisci `--python 3.x` con la versione del runtime Python che stai utilizzando.
```
pip install \
--platform manylinux2014_aarch64 \
--target=package \
--implementation cp \
--python-version 3.x \
--only-binary=:all: --upgrade \
```
### Utilizzo delle distribuzioni di origine
Se il tuo pacchetto è disponibile solo come distribuzione di origine, la creazione delle librerie C/C\$1\$1 spetta a te. Per rendere il pacchetto compatibile con l'ambiente di esecuzione Lambda, è necessario crearlo in un ambiente che utilizzi lo stesso sistema operativo Amazon Linux. Puoi farlo creando il tuo pacchetto in un'istanza Amazon Elastic Compute Cloud (Amazon EC2) Linux.
Per informazioni su come avviare e connettersi a un'istanza Amazon EC2 Linux, consulta la Guida [introduttiva ad Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html) nella *Amazon EC2 User Guide*.
## Creazione e aggiornamento delle funzioni Lambda di Python utilizzando file .zip
Dopo aver creato il pacchetto di implementazione .zip, puoi utilizzarlo per creare una nuova funzione Lambda o aggiornarne una esistente. Puoi distribuire il tuo pacchetto.zip utilizzando la console Lambda, l'API Lambda AWS Command Line Interface e l'API Lambda. Puoi anche creare e aggiornare le funzioni Lambda usando AWS Serverless Application Model (AWS SAM) e CloudFormation.
La dimensione massima per un pacchetto di implementazione .zip per Lambda è di 250 MB (dopo l'estrazione). Nota che questo limite si applica alla dimensione combinata di tutti i file caricati, inclusi eventuali livelli Lambda.
Il runtime Lambda necessita dell'autorizzazione per leggere i file nel pacchetto di distribuzione. Nella notazione ottale delle autorizzazioni Linux, Lambda richiede 644 permessi per i file non eseguibili (rw-r--r--) e 755 permessi () per le directory e i file eseguibili. rwxr-xr-x
In Linux e macOS, utilizza il comando `chmod` per modificare le autorizzazioni file su file e directory nel pacchetto di implementazione. Ad esempio, per assegnare a un file non eseguibile le autorizzazioni corrette, utilizza il comando seguente.
```
chmod 644
```
Per modificare le autorizzazioni file in Windows, consulta [Set, View, Change, or Remove Permissions on an Object](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc731667(v=ws.10)) nella documentazione di Microsoft Windows.
**Nota**
Se non concedi a Lambda le autorizzazioni necessarie per accedere alle directory nel pacchetto di distribuzione, Lambda imposta le autorizzazioni per tali directory su 755 (). rwxr-xr-x
### Creazione e aggiornamento delle funzioni con file .zip utilizzando la console
Per creare una nuova funzione, devi prima creare la funzione nella console, quindi devi caricare il tuo archivio .zip. Per aggiornare una funzione esistente, apri la pagina relativa alla funzione, quindi segui la stessa procedura per aggiungere il file .zip aggiornato.
Se il file .zip ha dimensioni inferiori a 50 MB, è possibile creare o aggiornare una funzione caricando il file direttamente dal computer locale. Per i file .zip di dimensioni superiori a 50 MB, prima è necessario caricare il pacchetto in un bucket Amazon S3. Per istruzioni su come caricare un file in un bucket Amazon S3 utilizzando il Console di gestione AWS, consulta la [Guida introduttiva ad Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html). *Per caricare file utilizzando la AWS CLI, consulta [Move objects](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) nella Guida per l'AWS CLI utente.*
**Nota**
Non è possibile modificare il [tipo di pacchetto di implementazione](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip o immagine di container) per una funzione esistente. Ad esempio, non è possibile convertire una funzione di immagine di container esistente per utilizzare un archivio di file .zip. È necessario creare una nuova funzione.
**Creazione di una nuova funzione (console)**
1. Apri la [pagina Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda e scegli **Crea funzione**.
1. Scegli **Author from scratch** (Crea da zero).
1. In **Basic information (Informazioni di base)** eseguire queste operazioni:
1. In **Nome funzione**, inserisci il nome della funzione.
1. Per **Runtime**, seleziona il runtime che desideri utilizzare.
1. (Facoltativo) Per **Architettura**, scegli l'architettura del set di istruzioni per la funzione. L'architettura predefinita è x86\$164. Assicurati che il pacchetto di implementazione per la tua funzione sia compatibile con l'architettura del set di istruzioni scelta.
1. (Opzionale) In **Autorizzazioni** espandere **Modifica ruolo di esecuzione predefinito**. Puoi creare un nuovo **ruolo di esecuzione** o utilizzare un ruolo esistente.
1. Scegli **Crea funzione**. Lambda crea una funzione di base "Hello world" utilizzando il runtime scelto.
**Caricamento di un archivio .zip dal computer locale (console)**
1. Nella [pagina Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda, scegli la funzione per cui vuoi caricare il file .zip.
1. Scegli la scheda **Codice**.
1. Nel riquadro **Origine del codice**, scegli **Carica da**.
1. Scegli **File .zip**.
1. Per caricare il file .zip, procedi come segue:
1. Seleziona **Carica**, quindi seleziona il tuo file .zip nel selettore di file.
1. Seleziona **Apri**.
1. Scegli **Save** (Salva).
**Caricamento di un archivio .zip da un bucket Amazon S3 (console)**
1. Nella [pagina Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda, scegli la funzione per cui vuoi caricare un nuovo file .zip.
1. Scegli la scheda **Codice**.
1. Nel riquadro **Origine del codice**, scegli **Carica da**.
1. Scegli **Posizione Amazon S3**.
1. Incolla l'URL del link Amazon S3 del tuo file .zip e scegli **Salva**.
### Aggiornamento delle funzioni dei file .zip tramite l'editor di codice della console
Per alcune funzioni con pacchetti di implementazione .zip, puoi utilizzare l'editor di codice integrato nella console Lambda per aggiornare direttamente il codice della funzione. Per utilizzare questa funzione, la funzione deve soddisfare i seguenti criteri:
+ La funzione deve utilizzare uno dei runtime del linguaggio interpretato (Python, Node.js o Ruby)
+ Il pacchetto di implementazione della funzione deve avere dimensioni inferiori a 50 MB (non compresso).
Il codice della funzione per le funzioni con pacchetti di implementazione di immagini di container non può essere modificato direttamente nella console.
**Aggiornamento del codice della funzione utilizzando l'editor di codice della console**
1. Apri la [pagina Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda e scegli la tua funzione.
1. Scegli la scheda **Codice**.
1. Nel riquadro **Origine del codice**, seleziona il tuo file di codice sorgente e modificalo nell'editor di codice integrato.
1. Nella sezione **DEPLOY**, scegli **Implementa** per aggiornare il codice della tua funzione:
![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
### Creazione e aggiornamento di funzioni con file.zip utilizzando AWS CLI
È possibile utilizzare la [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) per creare una nuova funzione o aggiornare una funzione esistente mediante un file .zip. Usa la funzione [create-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) e [update-function-code](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html)i comandi per distribuire il tuo pacchetto .zip. Se il file .zip ha dimensioni inferiori a 50 MB, è possibile caricare il pacchetto .zip da una posizione di file nella macchina di compilazione locale. Per i file di dimensioni maggiori, è necessario caricare il pacchetto .zip da un bucket Amazon S3. *Per istruzioni su come caricare un file su un bucket Amazon S3 utilizzando AWS CLI, consulta [Move objects](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) nella User Guide.AWS CLI *
**Nota**
Se carichi il tuo file.zip da un bucket Amazon S3 utilizzando AWS CLI il, il bucket deve trovarsi nella stessa posizione della Regione AWS tua funzione.
Per creare una nuova funzione utilizzando un file.zip con AWS CLI, devi specificare quanto segue:
+ Il nome della funzione (`--function-name`)
+ Il runtime della tua funzione (`--runtime`)
+ Il nome della risorsa Amazon (ARN) del [ruolo di esecuzione](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) della funzione (`--role`)
+ Il nome del metodo del gestore nel codice della funzione (`--handler`)
È inoltre necessario specificare la posizione del file .zip. Se il file .zip si trova in una cartella sulla macchina di compilazione locale, utilizza l'opzione `--zip-file` per specificare il percorso del file, come mostrato nel seguente comando di esempio.
```
aws lambda create-function --function-name myFunction \
--runtime python3.14 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--zip-file fileb://myFunction.zip
```
Per specificare la posizione del file .zip in un bucket Amazon S3, utilizza l'opzione `--code` illustrata nel seguente comando di esempio. È necessario utilizzare il parametro `S3ObjectVersion` solo per gli oggetti con controllo delle versioni.
```
aws lambda create-function --function-name myFunction \
--runtime python3.14 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion
```
Per aggiornare una funzione esistente mediante la CLI, specifica il nome della funzione utilizzando il parametro `--function-name`. È inoltre necessario specificare la posizione del file .zip che desideri utilizzare per aggiornare il codice della funzione. Se il file .zip si trova in una cartella sulla macchina di compilazione locale, utilizza l'opzione `--zip-file` per specificare il percorso del file, come mostrato nel seguente comando di esempio.
```
aws lambda update-function-code --function-name myFunction \
--zip-file fileb://myFunction.zip
```
Per specificare la posizione del file .zip in un bucket Amazon S3, utilizza le opzioni `--s3-bucket` e `--s3-key` come illustrato nel seguente comando di esempio. È necessario utilizzare il parametro `--s3-object-version` solo per gli oggetti con controllo delle versioni.
```
aws lambda update-function-code --function-name myFunction \
--s3-bucket amzn-s3-demo-bucket --s3-key myFileName.zip --s3-object-version myObject Version
```
### Creazione e aggiornamento delle funzioni con file .zip utilizzando l'API Lambda
Per creare e aggiornare le funzioni mediante un archivio di file .zip, utilizza le seguenti operazioni API:
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)
### Creazione e aggiornamento di funzioni con file.zip utilizzando AWS SAM
Il AWS Serverless Application Model (AWS SAM) è un toolkit che aiuta a semplificare il processo di creazione ed esecuzione di applicazioni serverless su. AWS Definisci le risorse per la tua applicazione in un modello YAML o JSON e utilizzi l'interfaccia a riga di AWS SAM comando (AWS SAM CLI) per creare, impacchettare e distribuire le tue applicazioni. Quando crei una funzione Lambda da un AWS SAM modello, crea AWS SAM automaticamente un pacchetto di distribuzione.zip o un'immagine del contenitore con il codice della funzione e le eventuali dipendenze specificate. Per ulteriori informazioni sull'utilizzo AWS SAM per creare e distribuire funzioni Lambda, [consulta la Guida introduttiva AWS Serverless Application Model](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) *alla AWS SAM* Developer Guide.
È inoltre possibile utilizzare AWS SAM per creare una funzione Lambda utilizzando un archivio di file.zip esistente. Per creare una funzione Lambda utilizzando AWS SAM, puoi salvare il tuo file.zip in un bucket Amazon S3 o in una cartella locale sulla tua macchina di compilazione. *Per istruzioni su come caricare un file su un bucket Amazon S3 utilizzando AWS CLI, consulta [Move objects](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) nella User Guide.AWS CLI *
Nel AWS SAM modello, la `AWS::Serverless::Function` risorsa specifica la funzione Lambda. In questa risorsa, imposta le seguenti proprietà per creare una funzione utilizzando un archivio di file .zip:
+ `PackageType`: imposta il valore su `Zip`
+ `CodeUri`- impostato sull'URI Amazon S3 del codice della funzione, sul percorso della cartella locale o sull'oggetto [FunctionCode](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html)
+ `Runtime`: imposta il runtime prescelto
Inoltre AWS SAM, se il tuo file.zip è più grande di 50 MB, non è necessario caricarlo prima in un bucket Amazon S3. AWS SAM puoi caricare pacchetti.zip fino alla dimensione massima consentita di 250 MB (decompressi) da una posizione sulla macchina di compilazione locale.
*Per ulteriori informazioni sulla distribuzione delle funzioni utilizzando il file.zip in AWS SAM, consulta la Guida per gli sviluppatori. [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)AWS SAM *
### Creazione e aggiornamento di funzioni con file.zip utilizzando CloudFormation
È possibile utilizzare CloudFormation per creare una funzione Lambda utilizzando un archivio di file.zip. Per creare una funzione Lambda da un file .zip, devi prima caricare il file su un bucket Amazon S3. *Per istruzioni su come caricare un file su un bucket Amazon S3 utilizzando AWS CLI, consulta [Move objects](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) nella User Guide.AWS CLI *
Per i runtime di Node.js e Python, puoi anche fornire codice sorgente in linea nel tuo modello. CloudFormation CloudFormation quindi crea un file.zip contenente il codice quando crei la funzione.
**Utilizzo di un file .zip esistente**
Nel CloudFormation modello, la `AWS::Lambda::Function` risorsa specifica la funzione Lambda. In questa risorsa, imposta le seguenti proprietà per creare una funzione utilizzando un archivio di file .zip:
+ `PackageType`: imposta il valore su `Zip`
+ `Code`: inserisci il nome del bucket Amazon S3 e il nome del file .zip nei campi `S3Bucket` e `S3Key`
+ `Runtime`: imposta il runtime prescelto
**Creazione di un file .zip da codice inline**
È possibile dichiarare semplici funzioni scritte in Python o Node.js in linea in un modello. CloudFormation Poiché il codice è incorporato in YAML o JSON, non puoi aggiungere dipendenze esterne al tuo pacchetto di implementazione. Ciò significa che la funzione deve utilizzare la versione dell' AWS SDK inclusa nel runtime. I requisiti del modello, come la necessità di evitare determinati caratteri, rendono anche più difficile l'utilizzo delle funzionalità di controllo della sintassi e di completamento del codice dell'IDE. Ciò significa che il tuo modello potrebbe richiedere test aggiuntivi. A causa di queste limitazioni, la dichiarazione di funzioni in linea è più adatta per codice molto semplice che cambia raramente.
Per creare un file .zip dal codice inline per i runtime Node.js e Python, imposta le seguenti proprietà nella risorsa del modello `AWS::Lambda::Function`:
+ `PackageType`: imposta il valore su `Zip`
+ `Code`: inserisci il codice della funzione nel campo `ZipFile`
+ `Runtime`: imposta il runtime prescelto
Il file.zip che CloudFormation genera non può superare i 4 MB. *Per ulteriori informazioni sulla distribuzione delle funzioni utilizzando il file.zip in CloudFormation, [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)consultate la Guida per l'utente.CloudFormation *