Utilizzo di un'immagine di base Node.js per creare e impacchettare il codice TypeScript della funzione

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. AWS fornisce immagini di 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 utilizzi un'immagine di base aziendale privata o comunitaria, devi aggiungere il client dell'interfaccia di runtime Node.js (RIC) 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 dell'interfaccia di runtime. Se utilizzi un'immagine di base alternativa, come Alpine Linux o Debian, puoi creare il simulatore nella tua immagine o installarlo sul tuo computer locale.

Utilizzo di un'immagine di base Node.js per creare e impacchettare il codice TypeScript della funzione

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

AWS Command Line Interface (AWS CLI) versione 2
Docker
Node.js 20.x

Per creare un'immagine da un'immagine di AWS base per Lambda

Sul tuo computer locale, crea una directory di progetto per la nuova funzione.
Crea un nuovo progetto Node.js con npm o un gestore di pacchetti a tua scelta.
```
npm init
```
Aggiungi i pacchetti @types/aws-lambda e esbuild come dipendenze di sviluppo. Il pacchetto @types/aws-lambda contiene le definizioni dei tipi per Lambda.
```
npm install -D @types/aws-lambda esbuild
```

Aggiungi uno script di compilazione al file package.json.


  "scripts": {
  "build": "esbuild index.ts --bundle --minify --sourcemap --platform=node --target=es2020 --outfile=dist/index.js"
}

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. Non importa il aws-lambda NPM pacchetto, che è uno strumento di terze parti non correlato. Per ulteriori informazioni, consulta aws-lambda nel repository. DefinitelyTyped GitHub


import { Context, APIGatewayProxyResult, APIGatewayEvent } from 'aws-lambda';

export const handler = async (event: APIGatewayEvent, context: Context): Promise<APIGatewayProxyResult> => {
    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',
        }),
    };
};

Crea un nuovo Dockerfile con la seguente configurazione:
- Imposta la FROM proprietà sull'immagine URI 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 TypeScript codice in. 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 Quando distribuisci un'immagine del contenitore in Lambda, Lambda definisce automaticamente un utente Linux predefinito con le autorizzazioni con privilegi minimi. Questo è diverso dal comportamento standard di Docker, che per impostazione predefinita è l'utente quando non viene fornita alcuna istruzione. root USER
Esempio Dockerfile
```
FROM public.ecr.aws/lambda/nodejs:20 as builder
WORKDIR /usr/app
COPY package.json index.ts  ./
RUN npm install
RUN npm run build
    
FROM public.ecr.aws/lambda/nodejs:20
WORKDIR ${LAMBDA_TASK_ROOT}
COPY --from=builder /usr/app/dist/* ./
CMD ["index.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. 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/arm64opzione.

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 --read-only 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/arm64opzione invece di. --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 utilizzi il tuo codice di funzione anziché il codice di funzione di esempio, potresti voler richiamare la funzione con un JSON payload. 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 utilizzi il tuo codice di funzione anziché il codice di funzione di esempio, potresti voler richiamare la funzione con un JSON payload. 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
```

Per caricare l'immagine su Amazon ECR e creare la funzione Lambda

Esegui il get-login-passwordcomando per autenticare il Docker nel CLI tuo registro AmazonECR.
- Imposta il --region valore nel Regione AWS punto in cui desideri creare il ECR repository Amazon.
- 111122223333Sostituiscilo con il tuo Account AWS ID.
```
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 comando 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 ECR repository Amazon deve corrispondere alla funzione Regione AWS 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 taggare la tua immagine locale nel tuo ECR repository Amazon come versione più recente. In questo comando:
- docker-image:testè il nome e il tag della tua immagine Docker. Si tratta del nome e del tag dell'immagine che hai specificato nel docker build comando.
- Sostituisci l’<ECRrepositoryUri> con l’repositoryUri copiato. Assicurati di includere :latest alla fine diURI.
```
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 distribuire l'immagine locale nel repository Amazon. ECR Assicurati di includerla alla :latest fine del repository. URI
```
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. Nella fase successiva è necessario l'Amazon Resource Name (ARN) del ruolo.
Creazione della funzione Lambda PerImageUri, specifica il repository URI di cui hai parlato in precedenza. Assicurati di includere :latest alla fine di. 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 Amazon ECR per più account.

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 nel ECR repository Amazon e quindi utilizzare il update-function-codecomando per distribuire l'immagine nella funzione Lambda.

Lambda risolve il tag image in un digest di immagini specifico. Ciò significa che se punti il tag di immagine utilizzato per distribuire la funzione su una nuova immagine in AmazonECR, Lambda non aggiorna automaticamente la funzione per utilizzare la nuova immagine.

Per distribuire la nuova immagine nella stessa funzione Lambda, devi usare update-function-codeil comando, anche se il tag dell'immagine in ECR Amazon rimane lo stesso. Nell'esempio seguente, l'--publishopzione crea una nuova versione della funzione utilizzando l'immagine del contenitore aggiornata.


aws lambda update-function-code \
  --function-name hello-world \
  --image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
  --publish

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

Implementare archivi di file .zip

Context

Implementa codice trascritto TypeScript in Lambda con immagini di container

Utilizzo di un'immagine di base Node.js per creare e impacchettare il codice TypeScript della funzione

Per creare un'immagine da un'immagine di AWS base per Lambda

Nota

Esempio Dockerfile

Nota

Nota

Per caricare l'immagine su Amazon ECR e creare la funzione Lambda

Nota

Nota