Immagini di base AWS per Python Utilizzo di un'immagine di base AWS Utilizzo di un'immagine di base non AWS

Distribuisci funzioni Lambda per Python con immagini di container

Esistono tre modi per creare un'immagine di container per una funzione Lambda in Python:

Utilizzo di un'immagine di base AWS per Python

Le immagini di base AWS sono precaricate con un runtime in linguaggio, un client di interfaccia di runtime per gestire l'interazione tra Lambda e il codice della funzione e un emulatore di interfaccia di runtime per i test locali.
Uso di un'immagine di base solo per il sistema operativo AWS

Le immagini di base solo per il sistema operativo di AWS contengono una distribuzione Amazon Linux e l'emulatore dell'interfaccia di runtime. Queste immagini vengono comunemente utilizzate per creare immagini di container per linguaggi compilati, come Go e Rust, e per un linguaggio o una versione di linguaggio per cui Lambda non fornisce un'immagine di base, come Node.js 19. Puoi anche utilizzare immagini di base solo per il sistema operativo per implementare un runtime personalizzato. Per rendere l'immagine compatibile con Lambda, devi includere il client di interfaccia di runtime per Python nell'immagine.
Utilizzo di un'immagine di base non AWS

È possibile utilizzare un'immagine di base alternativa da un altro registro del container, come ad esempio Alpine Linux o Debian. Puoi anche utilizzare un'immagine personalizzata creata dalla tua organizzazione. Per rendere l'immagine compatibile con Lambda, devi includere il client di interfaccia di runtime per Python nell'immagine.

Suggerimento

Per ridurre il tempo necessario all'attivazione delle funzioni del container Lambda, consulta Utilizzo di compilazioni a più fasi nella documentazione Docker. Per creare immagini di container efficienti, segui le best practice per scrivere file Docker.

Questa pagina spiega come creare, testare e implementare le immagini di container per Lambda.

Argomenti

Immagini di base AWS per Python
Utilizzo di un'immagine di base AWS per Python
Utilizzo di un'immagine di base alternativa con il client di interfaccia di runtime

Immagini di base AWS per Python

AWS fornisce le seguenti immagini di base per Python:

Tag	Runtime	Sistema operativo	Dockerfile	Definizione come obsoleto
3,12	Python 3.12	Amazon Linux 2023	Dockerfile per Python 3.12 e versioni successive GitHub
3.11	Python 3.11	Amazon Linux 2	Dockerfile per Python 3.11 e versioni successive GitHub
3.10	Python 3.10	Amazon Linux 2	Dockerfile per Python 3.10 e versioni successive GitHub
3.9	Python 3.9	Amazon Linux 2	Dockerfile per Python 3.9 e versioni successive GitHub
3.8	Python 3.8	Amazon Linux 2	Dockerfile per Python 3.8 e versioni successive GitHub	14 ottobre 2024

Repository Amazon ECR: gallery.ecr.aws/lambda/python

Le immagini di base di Python 3.12 e versioni successive si basano sull'immagine contenitore minima di Amazon Linux 2023. Le immagini di base di Python 3.8-3.11 sono basate sull'immagine Amazon Linux 2. Le immagini basate su AL2023 offrono diversi vantaggi rispetto ad Amazon Linux 2, tra cui un ingombro di implementazione ridotto e versioni aggiornate di librerie come. glibc

Le immagini basate su AL2023 utilizzano microdnf (symlinked asdnf) come gestore di pacchetti anzichéyum, che è il gestore di pacchetti predefinito in Amazon Linux 2. microdnfè un'implementazione autonoma di. dnf Per un elenco dei pacchetti inclusi nelle immagini basate su AL2023, consulta le colonne Minimal Container in Confronto dei pacchetti installati su Amazon Linux 2023 Container Images. Per ulteriori informazioni sulle differenze tra AL2023 e Amazon Linux 2, consulta la sezione Introduzione al runtime di Amazon Linux 2023 per AWS Lambda sul AWS Compute Blog.

Nota

Per eseguire immagini basate su AL2023 localmente, incluso with AWS Serverless Application Model (AWS SAM), devi usare la versione Docker 20.10.10 o successiva.

Percorso di ricerca delle dipendenze nelle immagini di base

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, il runtime cerca prima nella directory {LAMBDA_TASK_ROOT}. Se includi una versione di una libreria inclusa nel runtime nella tua immagine, questa versione avrà la precedenza sulla versione inclusa nel runtime.

Gli altri passaggi del percorso di ricerca dipendono dalla versione dell'immagine base Lambda per il Python che stai utilizzando:

Python 3.11 e versioni successive: le librerie incluse nel runtime e le librerie installate con pip sono installate nella directory /var/lang/lib/python3.11/site-packages. Questa directory ha la precedenza su /var/runtime nel percorso di ricerca. Puoi sovrascrivere l'SDK usando pip per installare una versione più recente. Puoi usare pip per verificare che l'SDK incluso nel runtime e le sue dipendenze siano compatibili con tutti i pacchetti che installi.
Python 3.8-3.10: le librerie incluse nel runtime sono installate nella directory /var/runtime. Le librerie installate da pip sono installate nella directory /var/lang/lib/python3.x/site-packages. La directory /var/runtime ha la precedenza su /var/lang/lib/python3.x/site-packages nel percorso di ricerca.

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)

Utilizzo di un'immagine di base AWS per Python

Per completare le fasi riportate in questa sezione, è necessario:

AWS Command Line Interface (AWS CLI) versione 2
Docker (versione minima 20.10.10 per Python 3.12 e immagini base successive)
Python

Creazione di un'immagine di container da un'immagine di base AWS per Python

Crea una directory per il progetto, quindi passa a quella directory.
```
mkdir example
cd example
```
Crea un nuovo file denominato lambda_function.py. A fini di test, puoi utilizzare il codice della funzione di esempio seguente o sostituirlo con il tuo codice personalizzato.
Esempio Funzione Python
```
import sys
def handler(event, context):
    return 'Hello from AWS Lambda using Python' + sys.version + '!'
```
Crea un nuovo file denominato requirements.txt. Se stai utilizzando il codice della funzione di esempio del passaggio precedente, puoi lasciare il file vuoto perché non ci sono dipendenze. Altrimenti, elenca ogni libreria richiesta. Ad esempio, ecco come dovrebbe apparire la tua versione di requirements.txt se la funzione utilizza AWS SDK for Python (Boto3):
Esempio requirements.txt
```
boto3
```

Crea un nuovo Dockerfile con la seguente configurazione:

Imposta la proprietà FROM sull'URI dell'immagine di base.
Usa il comando COPY per copiare il codice della funzione e le dipendenze di runtime in una variabile di {LAMBDA_TASK_ROOT} ambiente definita da Lambda.
Imposta l'argomento CMD specificando il gestore della funzione Lambda.

Esempio Dockerfile


FROM public.ecr.aws/lambda/python:3.12

# Copy requirements.txt
COPY requirements.txt ${LAMBDA_TASK_ROOT}

# Install the specified packages
RUN pip install -r requirements.txt

# Copy function code
COPY lambda_function.py ${LAMBDA_TASK_ROOT}

# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "lambda_function.handler" ]

Crea l'immagine Docker con il comando docker build. L'esempio seguente assegna un nome all'immagine docker-image e le assegna il tag test.
```
docker build --platform linux/amd64 -t docker-image:test .
```
Nota
Il comando specifica l’opzione --platform linux/amd64 per garantire che il container sia compatibile con l'ambiente di esecuzione di Lambda, indipendentemente dall'architettura della macchina di sviluppo. Per creare una funzione Lambda utilizzando l'architettura del set di istruzioni ARM64, accertati di modificare il comando per utilizzare l’opzione --platform linux/arm64.

Avvia l'immagine Docker con il comando docker run. In questo esempio, docker-image è il nome dell'immagine e test è il tag.
```
docker run --platform linux/amd64 -p 9000:8080 docker-image:test
```
Questo comando esegue l'immagine come container e crea un endpoint locale in localhost:9000/2015-03-31/functions/function/invocations.

Nota
Per creare l'immagine Docker per l'architettura del set di istruzioni ARM64, assicurati di utilizzare l'opzione --platform linux/arm64 anziché --platform linux/amd64.
Da una nuova finestra di terminale, invia un evento all'endpoint locale.
Linux/macOS
Su MacOS o Linux, esegui il comando seguente curl:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Questo comando richiama la funzione con un evento vuoto e restituisce una risposta. Se stai utilizzando il tuo codice della funzione anziché quello di esempio, potresti voler richiamare la funzione con un payload JSON. Esempio:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
PowerShell
In PowerShell, esegui il comando seguente: Invoke-WebRequest
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Questo comando richiama la funzione con un evento vuoto e restituisce una risposta. Se stai utilizzando il tuo codice della funzione anziché quello di esempio, potresti voler richiamare la funzione con un payload JSON. Esempio:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
Ottieni l'ID del container.
```
docker ps
```
Utilizza il comando docker kill per arrestare il container. In questo comando, sostituisci 3766c4ab331c con l'ID del container del passaggio precedente.
```
docker kill 3766c4ab331c
```

Caricamento dell'immagine su Amazon ECR e creazione della funzione Lambda

Esegui il get-login-passwordcomando per autenticare la CLI Docker nel tuo registro Amazon ECR.
- Imposta il valore di --region sulla Regione AWS in cui desideri creare il repository Amazon ECR.
- Sostituisci 111122223333 con l'ID dell'Account AWS.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```

Crea un repository in Amazon ECR utilizzando il commando create-repository.


aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE

Nota

Il repository Amazon ECR deve essere nella stessa Regione AWS della funzione Lambda.

In caso di esito positivo, dovresti ottenere una risposta simile a questa:


{
    "repository": {
        "repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
        "registryId": "111122223333",
        "repositoryName": "hello-world",
        "repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
        "createdAt": "2023-03-09T10:39:01+00:00",
        "imageTagMutability": "MUTABLE",
        "imageScanningConfiguration": {
            "scanOnPush": true
        },
        "encryptionConfiguration": {
            "encryptionType": "AES256"
        }
    }
}

Copia il repositoryUri dall'output del passaggio precedente.
Esegui il comando docker tag per etichettare l'immagine locale nel repository Amazon ECR come versione più recente. In questo comando:
- Sostituisci docker-image:test con il nome e il tag della tua immagine Docker.
- Sostituisci l’<ECRrepositoryUri> con l’repositoryUri copiato. Assicurati di includere :latest alla fine dell'URI.
```
docker tag docker-image:test <ECRrepositoryUri>:latest
```
Esempio:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
Esegui il comando docker push per implementare la tua immagine locale sul repository Amazon ECR. Assicurati di includere :latest alla fine dell'URI del repository.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
Crea un ruolo di esecuzione per la funzione, se non lo hai già fatto. Il nome della risorsa Amazon (ARN) del ruolo ti occorrerà nel passaggio successivo.
Creazione della funzione Lambda Per ImageUri, specifica l'URI del repository creato in precedenza. Assicurati di includere :latest alla fine dell'URI.
```
aws lambda create-function \
  --function-name hello-world \
  --package-type Image \
  --code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
  --role arn:aws:iam::111122223333:role/lambda-ex
```
Nota
È possibile creare una funzione utilizzando un'immagine in un account AWS diverso, purché l'immagine si trovi nella stessa regione della funzione Lambda. Per ulteriori informazioni, consulta Autorizzazioni multiaccount Amazon ECR.

Richiama la funzione.


aws lambda invoke --function-name hello-world response.json

Dovresti ottenere una risposta simile a questa:


{
  "ExecutedVersion": "$LATEST", 
  "StatusCode": 200
}

Per vedere l'output della funzione, controlla il file response.json.

Per aggiornare il codice della funzione, devi creare nuovamente l'immagine, caricare la nuova immagine nell'archivio Amazon ECR e quindi utilizzare il update-function-codecomando per distribuire l'immagine nella funzione Lambda.

Utilizzo di un'immagine di base alternativa con il client di interfaccia di runtime

Se utilizzi un'immagine di base solo per il sistema operativo o un'immagine di base alternativa, devi includere il client dell'interfaccia di runtime nell'immagine. Il client dell'interfaccia di runtime estende l'API di runtime Lambda, che gestisce l'interazione tra Lambda e il codice della funzione.

Installa il client di interfaccia di runtime per Python utilizzando il gestore di pacchetti pip:


pip install awslambdaric

Puoi anche scaricare il client dell'interfaccia di runtime Python da. GitHub

L'esempio seguente dimostra come creare un'immagine di container per Python utilizzando un'immagine di base non AWS. Il Dockerfile di esempio utilizza un'immagine di base Python ufficiale. Il Dockerfile include il client di interfaccia di runtime per Python.

Per completare le fasi riportate in questa sezione, è necessario:

AWS Command Line Interface (AWS CLI) versione 2
Docker
Python

Creazione di un'immagine di container da un'immagine di base non AWS

Crea una directory per il progetto, quindi passa a quella directory.
```
mkdir example
cd example
```
Crea un nuovo file denominato lambda_function.py. A fini di test, puoi utilizzare il codice della funzione di esempio seguente o sostituirlo con il tuo codice personalizzato.
Esempio Funzione Python
```
import sys
def handler(event, context):
    return 'Hello from AWS Lambda using Python' + sys.version + '!'
```
Crea un nuovo file denominato requirements.txt. Se stai utilizzando il codice della funzione di esempio del passaggio precedente, puoi lasciare il file vuoto perché non ci sono dipendenze. Altrimenti, elenca ogni libreria richiesta. Ad esempio, ecco come dovrebbe apparire la tua versione di requirements.txt se la funzione utilizza AWS SDK for Python (Boto3):
Esempio requirements.txt
```
boto3
```

Crea un nuovo Dockerfile. Il seguente Dockerfile utilizza un'immagine di base Python ufficiale anziché un'immagine di base AWS. Il Dockerfile include il client di interfaccia di runtime, che rende l'immagine compatibile con Lambda. Il seguente Dockerfile di esempio utilizza una build multi-fase.

Imposta la proprietà FROM sull'immagine di base.
Imposta l'ENTRYPOINT sul modulo su cui desideri che il container Docker venga eseguito all'avvio. In questo caso, il modulo è il client di interfaccia di runtime.
Imposta il CMD specificando il gestore della funzione Lambda.

Esempio Dockerfile


# Define custom function directory
ARG FUNCTION_DIR="/function"

FROM python:3.12 as build-image

# Include global arg in this stage of the build
ARG FUNCTION_DIR

# Copy function code
RUN mkdir -p ${FUNCTION_DIR}
COPY . ${FUNCTION_DIR}

# Install the function's dependencies
RUN pip install \
    --target ${FUNCTION_DIR} \
        awslambdaric

# Use a slim version of the base Python image to reduce the final image size
FROM python:3.12-slim

# Include global arg in this stage of the build
ARG FUNCTION_DIR
# Set working directory to function root directory
WORKDIR ${FUNCTION_DIR}

# Copy in the built dependencies
COPY --from=build-image ${FUNCTION_DIR} ${FUNCTION_DIR}

# Set runtime interface client as default command for the container runtime
ENTRYPOINT [ "/usr/local/bin/python", "-m", "awslambdaric" ]
# Pass the name of the function handler as an argument to the runtime
CMD [ "lambda_function.handler" ]

Crea l'immagine Docker con il comando docker build. L'esempio seguente assegna un nome all'immagine docker-image e le assegna il tag test.
```
docker build --platform linux/amd64 -t docker-image:test .
```
Nota
Il comando specifica l’opzione --platform linux/amd64 per garantire che il container sia compatibile con l'ambiente di esecuzione di Lambda, indipendentemente dall'architettura della macchina di sviluppo. Per creare una funzione Lambda utilizzando l'architettura del set di istruzioni ARM64, accertati di modificare il comando per utilizzare l’opzione --platform linux/arm64.

Usa il simulatore dell'interfaccia di runtime per testare localmente l'immagine. Puoi creare l'emulatore nella tua immagine o installarlo sul tuo computer locale.

Installazione ed esecuzione dell'emulatore di interfaccia di runtime sul computer locale

Dalla directory del progetto, esegui il seguente comando per scaricare l'emulatore di interfaccia runtime (architettura x86-64) GitHub e installarlo sul tuo computer locale.

Avvia l'immagine Docker con il comando docker run. Tieni presente quanto segue:
- docker-image è il nome dell'immagine e test è il tag.
- /usr/local/bin/python -m awslambdaric lambda_function.handler è l'ENTRYPOINT seguito dal CMD del Dockerfile.
Linux/macOS
```
docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
    --entrypoint /aws-lambda/aws-lambda-rie \
    docker-image:test \
        /usr/local/bin/python -m awslambdaric lambda_function.handler
```
PowerShell
```
docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
--entrypoint /aws-lambda/aws-lambda-rie `
docker-image:test `
    /usr/local/bin/python -m awslambdaric lambda_function.handler
```
Questo comando esegue l'immagine come container e crea un endpoint locale in localhost:9000/2015-03-31/functions/function/invocations.

Nota
Per creare l'immagine Docker per l'architettura del set di istruzioni ARM64, assicurati di utilizzare l'opzione --platform linux/arm64 anziché --platform linux/amd64.
Pubblica un evento nell'endpoint locale.
Linux/macOS
Su MacOS o Linux, esegui il comando seguente curl:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Questo comando richiama la funzione con un evento vuoto e restituisce una risposta. Se stai utilizzando il tuo codice della funzione anziché quello di esempio, potresti voler richiamare la funzione con un payload JSON. Esempio:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
PowerShell
In PowerShell, esegui il seguente comando: Invoke-WebRequest
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Questo comando richiama la funzione con un evento vuoto e restituisce una risposta. Se stai utilizzando il tuo codice della funzione anziché quello di esempio, potresti voler richiamare la funzione con un payload JSON. Esempio:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
Ottieni l'ID del container.
```
docker ps
```
Utilizza il comando docker kill per arrestare il container. In questo comando, sostituisci 3766c4ab331c con l'ID del container del passaggio precedente.
```
docker kill 3766c4ab331c
```

Caricamento dell'immagine su Amazon ECR e creazione della funzione Lambda

Esegui il get-login-passwordcomando per autenticare la CLI Docker nel tuo registro Amazon ECR.
- Imposta il valore di --region sulla Regione AWS in cui desideri creare il repository Amazon ECR.
- Sostituisci 111122223333 con l'ID dell'Account AWS.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```

Crea un repository in Amazon ECR utilizzando il commando create-repository.


aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE

Nota

Il repository Amazon ECR deve essere nella stessa Regione AWS della funzione Lambda.

In caso di esito positivo, dovresti ottenere una risposta simile a questa:


{
    "repository": {
        "repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
        "registryId": "111122223333",
        "repositoryName": "hello-world",
        "repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
        "createdAt": "2023-03-09T10:39:01+00:00",
        "imageTagMutability": "MUTABLE",
        "imageScanningConfiguration": {
            "scanOnPush": true
        },
        "encryptionConfiguration": {
            "encryptionType": "AES256"
        }
    }
}

Copia il repositoryUri dall'output del passaggio precedente.
Esegui il comando docker tag per etichettare l'immagine locale nel repository Amazon ECR come versione più recente. In questo comando:
- Sostituisci docker-image:test con il nome e il tag della tua immagine Docker.
- Sostituisci l’<ECRrepositoryUri> con l’repositoryUri copiato. Assicurati di includere :latest alla fine dell'URI.
```
docker tag docker-image:test <ECRrepositoryUri>:latest
```
Esempio:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
Esegui il comando docker push per implementare la tua immagine locale sul repository Amazon ECR. Assicurati di includere :latest alla fine dell'URI del repository.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
Crea un ruolo di esecuzione per la funzione, se non lo hai già fatto. Il nome della risorsa Amazon (ARN) del ruolo ti occorrerà nel passaggio successivo.
Creazione della funzione Lambda Per ImageUri, specifica l'URI del repository creato in precedenza. Assicurati di includere :latest alla fine dell'URI.
```
aws lambda create-function \
  --function-name hello-world \
  --package-type Image \
  --code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
  --role arn:aws:iam::111122223333:role/lambda-ex
```
Nota
È possibile creare una funzione utilizzando un'immagine in un account AWS diverso, purché l'immagine si trovi nella stessa regione della funzione Lambda. Per ulteriori informazioni, consulta Autorizzazioni multiaccount Amazon ECR.

Richiama la funzione.


aws lambda invoke --function-name hello-world response.json

Dovresti ottenere una risposta simile a questa:


{
  "ExecutedVersion": "$LATEST", 
  "StatusCode": 200
}

Per vedere l'output della funzione, controlla il file response.json.

Per un esempio di come creare un'immagine Python da un'immagine di base Alpine, consulta Supporto delle immagini di container per Lambda sul Blog AWS.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Implementazione di archivi di file .zip

Livelli

Distribuisci funzioni Lambda per Python con immagini di container

Suggerimento

Argomenti

Immagini di base AWS per Python

Nota

Percorso di ricerca delle dipendenze nelle immagini di base

Utilizzo di un'immagine di base AWS per Python

Creazione di un'immagine di container da un'immagine di base AWS per Python

Esempio Funzione Python

Esempio requirements.txt

Esempio Dockerfile

Nota

Nota

Caricamento dell'immagine su Amazon ECR e creazione della funzione Lambda

Nota

Nota

Utilizzo di un'immagine di base alternativa con il client di interfaccia di runtime

Creazione di un'immagine di container da un'immagine di base non AWS

Esempio Funzione Python

Esempio requirements.txt

Esempio Dockerfile

Nota

Installazione ed esecuzione dell'emulatore di interfaccia di runtime sul computer locale

Nota

Caricamento dell'immagine su Amazon ECR e creazione della funzione Lambda

Nota

Nota