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à.
# Distribuisci funzioni Lambda in Node.js con immagini di container
Esistono tre modi per creare un'immagine di container per una funzione Lambda in Node.js:
+ [Utilizzo di un'immagine di AWS base per Node.js](#nodejs-image-instructions)
[Le immagini di base AWS](images-create.md#runtimes-images-lp) 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.
+ [Utilizzo di un'immagine di AWS base solo per il sistema operativo](images-create.md#runtimes-images-provided)
[AWS Le immagini di base solo](https://gallery.ecr.aws/lambda/provided) per il sistema operativo contengono una distribuzione Amazon Linux e l'emulatore [di interfaccia di runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Queste immagini vengono comunemente utilizzate per creare immagini di container per linguaggi compilati, come [Go](go-image.md#go-image-provided) e [Rust](lambda-rust.md), 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 al fine di implementare un [runtime personalizzato](runtimes-custom.md). Per rendere l'immagine compatibile con Lambda, devi includere il [client di interfaccia di runtime per Node.js](#nodejs-image-clients) nell'immagine.
+ [Utilizzo di un'immagine non di base AWS ](#nodejs-image-clients)
È 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 Node.js](#nodejs-image-clients) nell'immagine.
**Suggerimento**
Per ridurre il tempo necessario all'attivazione delle funzioni del container Lambda, consulta [Utilizzo di compilazioni a più fasi](https://docs.docker.com/build/building/multi-stage/) nella documentazione Docker. Per creare immagini di container efficienti, segui le [best practice per scrivere file Docker](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
Questa pagina spiega come creare, testare e implementare le immagini di container per Lambda.
**Topics**
+ [AWS immagini di base per Node.js](#nodejs-image-base)
+ [Utilizzo di un'immagine di AWS base per Node.js](#nodejs-image-instructions)
+ [Utilizzo di un'immagine di base alternativa con il client di interfaccia di runtime](#nodejs-image-clients)
## AWS immagini di base per Node.js
AWS fornisce le seguenti immagini di base per Node.js:
| Tag | Runtime | Sistema operativo | Dockerfile | Raggiunta obsolescenza |
| --- | --- | --- | --- | --- |
| 24 | Node.js 24 | Amazon Linux 2023 | [Dockerfile per Node.js 24 ore su 24 GitHub](https://github.com/aws/aws-lambda-base-images/blob/nodejs24.x/Dockerfile.nodejs24.x) | 30 aprile 2028 |
| 22 | Node.js 22 | Amazon Linux 2023 | [Dockerfile per Node.js dalla 22 in poi GitHub](https://github.com/aws/aws-lambda-base-images/blob/nodejs22.x/Dockerfile.nodejs22.x) | 30 aprile 2027 |
| 20 | Node.js 20 | Amazon Linux 2023 | [Dockerfile per Node.js dalla versione 20 in poi GitHub](https://github.com/aws/aws-lambda-base-images/blob/nodejs20.x/Dockerfile.nodejs20.x) | 30 aprile 2026 |
[Archivio Amazon ECR: gallery.ecr. aws/lambda/nodejs](https://gallery.ecr.aws/lambda/nodejs)
Le immagini di base Node.js 20 e successive si basano sull'[immagine minima del contenitore Amazon Linux 2023](https://docs.aws.amazon.com/linux/al2023/ug/minimal-container.html). Le immagini di base precedenti utilizzavano Amazon Linux 2. AL2023 offre diversi vantaggi rispetto ad Amazon Linux 2, tra cui un ingombro di distribuzione ridotto e versioni aggiornate di librerie come`glibc`.
AL2023le immagini basate utilizzano `microdnf` (symlinked as`dnf`) 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 AL2023 basate, consulta le colonne **Minimal Container** in [Comparing packages installed on Amazon Linux 2023 Container Images](https://docs.aws.amazon.com/linux/al2023/ug/al2023-container-image-types.html). Per ulteriori informazioni sulle differenze tra Amazon Linux 2 AL2023 e Amazon Linux 2, consulta [la sezione Introduzione al runtime di Amazon Linux 2023 AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/) sul AWS Compute Blog.
**Nota**
Per eseguire immagini AL2023 basate localmente, incluso with AWS Serverless Application Model (AWS SAM), devi usare la versione Docker 20.10.10 o successiva.
## Utilizzo di un'immagine di AWS base per Node.js
### Prerequisiti
Per completare le fasi riportate in questa sezione, è necessario:
+ [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versione minima 25.0.0)
+ Il [plugin buildx](https://github.com/docker/buildx/blob/master/README.md) di Docker.
+ Node.js
### Creazione di un'immagine da un'immagine di base
**Per creare un'immagine del contenitore da un'immagine di AWS base per Node.js**
1. Crea una directory per il progetto, quindi passa a quella directory.
```
mkdir example
cd example
```
1. Crea un nuovo progetto Node.js con `npm`. Per accettare le opzioni predefinite fornite nell'esperienza interattiva, premi `Enter`.
```
npm init
```
1. Crea un nuovo file denominato `index.js`. A fini di test, puoi utilizzare il codice della funzione di esempio seguente o sostituirlo con il tuo codice personalizzato.
**Example Gestore CommonJS**
```
exports.handler = async (event) => {
const response = {
statusCode: 200,
body: JSON.stringify('Hello from Lambda!'),
};
return response;
};
```
1. Se la tua funzione dipende da librerie diverse da AWS SDK per JavaScript, usa [npm](https://www.npmjs.com/) per aggiungerle al tuo pacchetto.
1. Crea un nuovo Dockerfile con la seguente configurazione:
+ Imposta la proprietà `FROM` sull'[URI dell'immagine di base](https://gallery.ecr.aws/lambda/nodejs).
+ Utilizza il comando COPY per copiare il codice della funzione e le dipendenze di runtime in `{LAMBDA_TASK_ROOT}`, una [variabile d'ambiente definita da Lambda](configuration-envvars.md#configuration-envvars-runtime).
+ Imposta l'argomento `CMD` specificando il gestore della funzione Lambda.
Nota che l'esempio Dockerfile non include un'[istruzione USER](https://docs.docker.com/reference/dockerfile/#user). Quando implementi un'immagine di container su Lambda, Lambda definisce automaticamente un utente Linux predefinito con autorizzazioni con privilegi minimi. Questo è diverso dal comportamento standard di Docker, che per impostazione predefinita è l'utente `root` quando non viene fornita alcuna istruzione `USER`.
**Example Dockerfile**
```
FROM public.ecr.aws/lambda/nodejs:22
# Copy function code
COPY index.js ${LAMBDA_TASK_ROOT}
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "index.handler" ]
```
1. Crea l'immagine Docker con il comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). L'esempio seguente assegna un nome all'immagine `docker-image` e le assegna il [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Per rendere l'immagine compatibile con Lambda, è necessario utilizzare l'`--provenance=false`opzione.
```
docker buildx build --platform linux/amd64 --provenance=false -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. Se intendi creare una funzione Lambda utilizzando l'architettura del set di ARM64 istruzioni, assicurati di modificare il comando per utilizzare invece l'`--platform linux/arm64`opzione.
### (Facoltativo) Test dell'immagine in locale
1. 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**
Se hai creato l'immagine Docker per l'architettura del set di ARM64 istruzioni, assicurati di utilizzare l'`--platform linux/arm64`opzione invece di. `--platform linux/amd64`
1. 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 seguente `Invoke-WebRequest` comando:
```
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"
```
------
1. Ottieni l'ID del container.
```
docker ps
```
1. Utilizza il comando [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) per arrestare il container. In questo comando, sostituisci `3766c4ab331c` con l'ID del container del passaggio precedente.
```
docker kill 3766c4ab331c
```
### Implementazione dell'immagine
**Caricamento dell'immagine su Amazon ECR e creazione della funzione Lambda**
1. Esegui il [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)comando per autenticare la CLI Docker nel tuo registro Amazon ECR.
+ Imposta il `--region` valore nel Regione AWS punto in cui desideri creare il repository Amazon ECR.
+ Sostituiscilo `111122223333` con il tuo ID. 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
```
1. Crea un repository in Amazon ECR utilizzando il commando [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).
```
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 corrispondere alla funzione Lambda. Regione AWS
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"
}
}
}
```
1. Copia il `repositoryUri` dall'output del passaggio precedente.
1. Esegui il comando [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) per etichettare l'immagine locale nel repository Amazon ECR come versione più recente. In questo comando:
+ `docker-image:test` è il nome e [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) dell'immagine Docker. Si tratta del nome e del tag dell'immagine specificati nel comando `docker build`.
+ Sostituisci l’`` con l’`repositoryUri` copiato. Assicurati di includere `:latest` alla fine dell'URI.
```
docker tag docker-image:test :latest
```
Esempio:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Esegui il comando [docker push](https://docs.docker.com/engine/reference/commandline/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
```
1. [Crea un ruolo di esecuzione](lambda-intro-execution-role.md#permissions-executionrole-api) per la funzione, se non lo hai già fatto. Il nome della risorsa Amazon (ARN) del ruolo ti occorrerà nel passaggio successivo.
1. 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 AWS account diverso, purché l'immagine si trovi nella stessa regione della funzione Lambda. Per ulteriori informazioni, consulta [Autorizzazioni multiaccount Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Richiama la funzione.
```
aws lambda invoke --function-name hello-world response.json
```
Dovresti ottenere una risposta simile a questa:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. 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-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)comando per distribuire l'immagine nella funzione Lambda.
Lambda risolve il tag dell'immagine in un digest di immagine specifico. Ciò significa che se punti il tag immagine utilizzato per implementare la funzione su una nuova immagine in Amazon ECR, Lambda non aggiorna automaticamente la funzione per utilizzare la nuova immagine.
Per distribuire la nuova immagine nella stessa funzione Lambda, è necessario utilizzare [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)il comando, anche se il tag dell'immagine in Amazon ECR rimane lo stesso. Nell'esempio seguente, l'opzione `--publish` crea una nuova versione della funzione utilizzando l'immagine del container aggiornata.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
## 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](images-create.md#runtimes-images-provided) 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 Runtime](runtimes-api.md), che gestisce l'interazione tra Lambda e il codice della funzione.
Installa il [client di interfaccia di runtime per Node.js](https://www.npmjs.com/package/aws-lambda-ric) utilizzando il gestore di pacchetti npm:
```
npm install aws-lambda-ric
```
È inoltre possibile scaricare il [client dell'interfaccia di runtime Node.js](https://github.com/aws/aws-lambda-nodejs-runtime-interface-client) da GitHub.
L'esempio seguente dimostra come creare un'immagine contenitore per Node.js utilizzando un'immagine non di AWS base. Il Dockerfile di esempio utilizza l'immagine di base `bookworm`. Il Dockerfile include il client di interfaccia di runtime.
### Prerequisiti
Per completare le fasi riportate in questa sezione, è necessario:
+ [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versione minima 25.0.0)
+ Il [plugin buildx](https://github.com/docker/buildx/blob/master/README.md) di Docker.
+ Node.js
### Creazione di un'immagine da un'immagine di base alternativa
**Per creare un'immagine contenitore da un'immagine non di AWS base**
1. Crea una directory per il progetto, quindi passa a quella directory.
```
mkdir example
cd example
```
1. Crea un nuovo progetto Node.js con `npm`. Per accettare le opzioni predefinite fornite nell'esperienza interattiva, premi `Enter`.
```
npm init
```
1. Crea un nuovo file denominato `index.js`. A fini di test, puoi utilizzare il codice della funzione di esempio seguente o sostituirlo con il tuo codice personalizzato.
**Example Gestore CommonJS**
```
exports.handler = async (event) => {
const response = {
statusCode: 200,
body: JSON.stringify('Hello from Lambda!'),
};
return response;
};
```
1. Crea un nuovo Dockerfile. Il seguente Dockerfile utilizza un'immagine di base `bookworm` anziché un'[immagine di base AWS](images-create.md#runtimes-images-lp). Il Dockerfile include il [client di interfaccia di runtime](https://www.npmjs.com/package/aws-lambda-ric), che rende l'immagine compatibile con Lambda. Il seguente Dockerfile utilizza una [build multi-fase](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds). Nella prima fase viene creata un'immagine della build, che è un ambiente Node.js standard in cui sono installate le dipendenze della funzione. Nella seconda fase viene creata un'immagine più leggera con il codice della funzione e le relative dipendenze. Ciò riduce la dimensione finale dell'immagine.
+ Imposta la proprietà `FROM` sull'identificativo dell'immagine di base.
+ Utilizza il comando `COPY` per copiare il codice della funzione e le dipendenze di runtime.
+ 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 l'argomento `CMD` specificando il gestore della funzione Lambda.
Nota che l'esempio Dockerfile non include un'[istruzione USER](https://docs.docker.com/reference/dockerfile/#user). Quando implementi un'immagine di container su Lambda, Lambda definisce automaticamente un utente Linux predefinito con autorizzazioni con privilegi minimi. Questo è diverso dal comportamento standard di Docker, che per impostazione predefinita è l'utente `root` quando non viene fornita alcuna istruzione `USER`.
**Example Dockerfile**
```
# Define custom function directory
ARG FUNCTION_DIR="/function"
FROM node:20-bookworm as build-image
# Include global arg in this stage of the build
ARG FUNCTION_DIR
# Install build dependencies
RUN apt-get update && \
apt-get install -y \
g++ \
make \
cmake \
unzip \
libcurl4-openssl-dev
# Copy function code
RUN mkdir -p ${FUNCTION_DIR}
COPY . ${FUNCTION_DIR}
WORKDIR ${FUNCTION_DIR}
# Install Node.js dependencies
RUN npm install
# Install the runtime interface client
RUN npm install aws-lambda-ric
# Grab a fresh slim copy of the image to reduce the final size
FROM node:20-bookworm-slim
# Required for Node runtimes which use npm@8.6.0+ because
# by default npm writes logs under /home/.npm and Lambda fs is read-only
ENV NPM_CONFIG_CACHE=/tmp/.npm
# 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/npx", "aws-lambda-ric"]
# Pass the name of the function handler as an argument to the runtime
CMD ["index.handler"]
```
1. Crea l'immagine Docker con il comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). L'esempio seguente assegna un nome all'immagine `docker-image` e le assegna il [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Per rendere l'immagine compatibile con Lambda, è necessario utilizzare l'`--provenance=false`opzione.
```
docker buildx build --platform linux/amd64 --provenance=false -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. Se intendi creare una funzione Lambda utilizzando l'architettura del set di ARM64 istruzioni, assicurati di modificare il comando per utilizzare invece l'`--platform linux/arm64`opzione.
### (Facoltativo) Test dell'immagine in locale
Usa il [simulatore dell'interfaccia di runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/) per testare localmente l'immagine. Puoi [creare l'emulatore nella tua immagine](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image) o seguire la procedura riportata e installarlo sul tuo computer locale.
**Installazione ed esecuzione dell'emulatore di interfaccia di runtime sul computer locale**
1. Dalla directory del progetto, esegui il comando seguente per scaricare l'emulatore di interfaccia di runtime (architettura x86-64) GitHub e installarlo sul computer locale.
------
#### [ Linux/macOS ]
```
mkdir -p ~/.aws-lambda-rie && \
curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
chmod +x ~/.aws-lambda-rie/aws-lambda-rie
```
Per installare l'emulatore arm64, sostituisci l'URL del GitHub repository nel comando precedente con il seguente:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
#### [ PowerShell ]
```
$dirPath = "$HOME\.aws-lambda-rie"
if (-not (Test-Path $dirPath)) {
New-Item -Path $dirPath -ItemType Directory
}
$downloadLink = "https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie"
$destinationPath = "$HOME\.aws-lambda-rie\aws-lambda-rie"
Invoke-WebRequest -Uri $downloadLink -OutFile $destinationPath
```
Per installare l'emulatore arm64, sostituisci `$downloadLink` con quanto segue:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
1. Avvia l'immagine Docker con il comando **docker run**. Tenere presente quanto segue:
+ `docker-image` è il nome dell'immagine e `test` è il tag.
+ `/usr/local/bin/npx aws-lambda-ric index.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/npx aws-lambda-ric index.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/npx aws-lambda-ric index.handler
```
------
Questo comando esegue l'immagine come container e crea un endpoint locale in `localhost:9000/2015-03-31/functions/function/invocations`.
**Nota**
Se hai creato l'immagine Docker per l'architettura del set di ARM64 istruzioni, assicurati di utilizzare l'`--platform linux/arm64`opzione invece di. `--platform linux/amd64`
1. 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 `Invoke-WebRequest` comando:
```
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"
```
------
1. Ottieni l'ID del container.
```
docker ps
```
1. Utilizza il comando [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) per arrestare il container. In questo comando, sostituisci `3766c4ab331c` con l'ID del container del passaggio precedente.
```
docker kill 3766c4ab331c
```
### Implementazione dell'immagine
**Caricamento dell'immagine su Amazon ECR e creazione della funzione Lambda**
1. Esegui il [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html)comando per autenticare la CLI Docker nel tuo registro Amazon ECR.
+ Imposta il `--region` valore nel Regione AWS punto in cui desideri creare il repository Amazon ECR.
+ Sostituiscilo `111122223333` con il tuo ID. 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
```
1. Crea un repository in Amazon ECR utilizzando il commando [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).
```
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 corrispondere alla funzione Lambda. Regione AWS
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"
}
}
}
```
1. Copia il `repositoryUri` dall'output del passaggio precedente.
1. Esegui il comando [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) per etichettare l'immagine locale nel repository Amazon ECR come versione più recente. In questo comando:
+ `docker-image:test` è il nome e [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) dell'immagine Docker. Si tratta del nome e del tag dell'immagine specificati nel comando `docker build`.
+ Sostituisci l’`` con l’`repositoryUri` copiato. Assicurati di includere `:latest` alla fine dell'URI.
```
docker tag docker-image:test :latest
```
Esempio:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Esegui il comando [docker push](https://docs.docker.com/engine/reference/commandline/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
```
1. [Crea un ruolo di esecuzione](lambda-intro-execution-role.md#permissions-executionrole-api) per la funzione, se non lo hai già fatto. Il nome della risorsa Amazon (ARN) del ruolo ti occorrerà nel passaggio successivo.
1. 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 AWS account diverso, purché l'immagine si trovi nella stessa regione della funzione Lambda. Per ulteriori informazioni, consulta [Autorizzazioni multiaccount Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Richiama la funzione.
```
aws lambda invoke --function-name hello-world response.json
```
Dovresti ottenere una risposta simile a questa:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. 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-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)comando per distribuire l'immagine nella funzione Lambda.
Lambda risolve il tag dell'immagine in un digest di immagine specifico. Ciò significa che se punti il tag immagine utilizzato per implementare la funzione su una nuova immagine in Amazon ECR, Lambda non aggiorna automaticamente la funzione per utilizzare la nuova immagine.
Per distribuire la nuova immagine nella stessa funzione Lambda, è necessario utilizzare [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html)il comando, anche se il tag dell'immagine in Amazon ECR rimane lo stesso. Nell'esempio seguente, l'opzione `--publish` crea una nuova versione della funzione utilizzando l'immagine del container aggiornata.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```