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à.
# Implementa codice trascritto TypeScript in Lambda con immagini di container
[Puoi distribuire il TypeScript codice in una AWS Lambda funzione come immagine del contenitore Node.js.](images-create.md) AWS fornisce [immagini di base](nodejs-image.md#nodejs-image-base) per Node.js per aiutarti a creare l'immagine del contenitore. Queste immagini di base sono precaricate con un runtime del linguaggio e altri componenti necessari per eseguire l'immagine su Lambda. AWS fornisce un Dockerfile per ciascuna delle immagini di base per facilitare la creazione dell'immagine del contenitore.
Se si utilizza un'immagine di base di community o aziendale privata, è necessario [aggiungere il client di interfaccia di runtime (RIC) Node.js](nodejs-image.md#nodejs-image-clients) all'immagine di base per renderla compatibile con Lambda.
Lambda fornisce un emulatore di interfaccia di runtime per i test in locale. Le immagini di AWS base per Node.js includono l'emulatore di interfaccia di runtime. Se utilizzi un'immagine di base alternativa, come Alpine Linux o Debian, puoi [creare il simulatore nella tua immagine](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image) o[ installarlo sul tuo computer locale](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#test-an-image-without-adding-rie-to-the-image).
## Utilizzo di un'immagine di base Node.js per creare e impacchettare il codice TypeScript funzionale
### 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 22.x
### Creazione di un'immagine da un'immagine di base
**Per creare un'immagine da un'immagine di AWS base per Lambda**
1. Sul tuo computer locale, crea una directory di progetto per la nuova funzione.
1. Crea un nuovo progetto Node.js con `npm` o un gestore di pacchetti a tua scelta.
```
npm init
```
1. Aggiungi i pacchetti [@types/aws-lambda](https://www.npmjs.com/package/@types/aws-lambda) e [esbuild](https://esbuild.github.io/) come dipendenze di sviluppo. Il pacchetto `@types/aws-lambda` contiene le definizioni dei tipi per Lambda.
```
npm install -D @types/aws-lambda esbuild
```
1. Aggiungi uno [script di compilazione](https://esbuild.github.io/getting-started/#build-scripts) al file `package.json`.
```
"scripts": {
"build": "esbuild index.ts --bundle --minify --sourcemap --platform=node --target=es2020 --outfile=dist/index.js"
}
```
1. Crea un nuovo file denominato `index.ts`. Aggiungi il codice di esempio seguente al nuovo file. Questo è il codice per la funzione Lambda. La funzione restituisce un messaggio `hello world`.
**Nota**
L'istruzione `import` importa le definizioni dei tipi da [@types/aws-lambda](https://www.npmjs.com/package/@types/aws-lambda). Non importa il pacchetto NPM `aws-lambda`, che è uno strumento di terzi non correlato. Per ulteriori informazioni, consulta [aws-lambda](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/aws-lambda) nel repository. DefinitelyTyped GitHub
```
import { Context, APIGatewayProxyResult, APIGatewayEvent } from 'aws-lambda';
export const handler = async (event: APIGatewayEvent, context: Context): Promise => {
console.log(`Event: ${JSON.stringify(event, null, 2)}`);
console.log(`Context: ${JSON.stringify(context, null, 2)}`);
return {
statusCode: 200,
body: JSON.stringify({
message: 'hello world',
}),
};
};
```
1. Crea un nuovo Dockerfile con la seguente configurazione:
+ Imposta la proprietà `FROM` sull'URI dell'immagine di base.
+ Imposta l'argomento `CMD` per specificare il gestore della funzione Lambda.
Il seguente Dockerfile di esempio utilizza una build multi-fase. Il primo passaggio trascrive il codice in. TypeScript JavaScript Il secondo passaggio produce un'immagine del contenitore che contiene solo JavaScript file e dipendenze di produzione.
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 as builder
WORKDIR /usr/app
COPY package.json index.ts ./
RUN npm install
RUN npm run build
FROM public.ecr.aws/lambda/nodejs:22
WORKDIR ${LAMBDA_TASK_ROOT}
COPY --from=builder /usr/app/dist/* ./
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
```