Utilisation d’une image de base Node.js pour créer et conditionner le code de fonction TypeScript

Déployez le code TypeScript transpilé dans Lambda avec des images du conteneur

Vous pouvez déployer votre code TypeScript vers une fonction AWS Lambda en tant qu’image de conteneur Node.js. AWS fournit des images de base pour Node.js, pour vous aider à créer l’image du conteneur. Ces images de base sont préchargées avec un environnement d’exécution de langage et d’autres composants requis pour exécuter l’image sur Lambda. AWS fournit un Dockerfile pour chacune des images de base afin de vous aider à créer votre image de conteneur.

Si vous utilisez une image de base de communauté ou d’entreprise privée, vous devez y ajouter un client de l’environnement d’exécution de Node.js (RIC) pour la rendre compatible avec Lambda.

Lambda fournit un émulateur d’interface d’exécution pour les tests locaux. L’image de base AWS pour Node.js inclut l’émulateur d’interface d’exécution. Si vous utilisez une autre image de base, telle qu’une image Alpine Linux ou Debian, vous pouvez intégrer l’émulateur dans votre image ou l’installer sur votre ordinateur local.

Utilisation d’une image de base Node.js pour créer et conditionner le code de fonction TypeScript

Pour exécuter la procédure indiquée dans cette section, vous devez satisfaire aux exigences suivantes :

AWS CLI version 2
Docker (version minimale 25.0.0)
Le plug-in buildx Docker.
Node.js 22.x

Pour créer une image à partir d’une image de base AWS pour Lambda

Sur votre machine locale, créez un répertoire de projets pour votre nouvelle fonction.
Créez un nouveau projet Node.js avec npm ou un gestionnaire de packs de votre choix.
```
npm init
```
Ajoutez les packs @types/aws-lambda et esbuild en tant que dépendances de développement. Le package @types/aws-lambda contient les définitions de type pour Lambda.
```
npm install -D @types/aws-lambda esbuild
```

Ajoutez un script de création au fichier package.json.


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

Créez un nouveau fichier appelé index.ts. Ajoutez l’exemple de code suivant au nouveau fichier. Il s’agit du code de la fonction Lambda. La fonction renvoie un message hello world.

Note

L’instruction import importe les définitions de type depuis @types /aws-lambda. Elle n’importe pas le package NPM aws-lambda, qui est un outil tiers indépendant. Pour plus d’informations, voir aws-lambda dans le référentiel GitHub DefinitelyTyped.


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',
        }),
    };
};

Créez un nouveau Dockerfile avec la configuration suivante :
- Définir la propriété FROM sur l’URI de l’image de base.
- Définissez l’argument CMD pour spécifier le gestionnaire de la fonction Lambda.
L’exemple de fichier Docker suivant utilise une génération en plusieurs étapes. La première étape consiste à transpirer le code TypeScript en JavaScript. La deuxième étape produit une image du conteneur contenant uniquement des fichiers JavaScript et des dépendances de production.

Notez que l’exemple de Dockerfile n’inclut pas d’instruction USER. Lorsque vous déployez une image de conteneur sur Lambda, Lambda définit automatiquement un utilisateur Linux par défaut disposant d’autorisations de moindre privilège. Ceci est différent du comportement standard de Docker qui est défini par défaut par l’utilisateur root lorsqu’aucune instruction USER n’est fournie.
Exemple 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"]
```
Générez l’image Docker à l’aide de la commande docker build. L’exemple suivant nomme l’image docker-image et lui donne la balise test. Pour rendre votre image compatible avec Lambda, vous devez utiliser l’option --provenance=false.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
Note
La commande spécifie l’option --platform linux/amd64 pour garantir la compatibilité de votre conteneur avec l’environnement d’exécution Lambda, quelle que soit l’architecture de votre machine de génération. Si vous avez l’intention de créer une fonction Lambda à l’aide de l’architecture du jeu d’instructions ARM64, veillez à modifier la commande pour utiliser plutôt l’option --platform linux/arm64.

Démarrez votre image Docker à l’aide de la commande docker run. Dans cet exemple, docker-image est le nom de l’image et test est la balise.
```
docker run --platform linux/amd64 -p 9000:8080 docker-image:test
```
Cette commande exécute l’image en tant que conteneur et crée un point de terminaison local à localhost:9000/2015-03-31/functions/function/invocations.

Note
Si vous avez créé l’image Docker pour l’architecture du jeu d’instructions ARM64, veillez à utiliser l’option --platform linux/arm64 plutôt que --platform linux/amd64.
À partir d’une nouvelle fenêtre de terminal, publiez un événement au point de terminaison local.
Linux/macOS
Sous Linux et macOS, exécutez la commande curl suivante :
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Cette commande invoque la fonction avec un événement vide et renvoie une réponse. Si vous utilisez votre propre code de fonction plutôt que l’exemple de code de fonction, vous pouvez invoquer la fonction avec une charge utile JSON. Exemple :
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
PowerShell
Sous PowerShell, exécutez la commande Invoke-WebRequest suivante :
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Cette commande invoque la fonction avec un événement vide et renvoie une réponse. Si vous utilisez votre propre code de fonction plutôt que l’exemple de code de fonction, vous pouvez invoquer la fonction avec une charge utile JSON. Exemple :
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
Obtenez l’ID du conteneur.
```
docker ps
```
Utilisez la commande docker kill pour arrêter le conteneur. Dans cette commande, remplacez 3766c4ab331c par l’ID du conteneur de l’étape précédente.
```
docker kill 3766c4ab331c
```

Pour charger l’image sur Amazon RIE et créer la fonction Lambda

Exécutez la commande get-login-password pour authentifier la CLI Docker auprès de votre registre Amazon ECR.
- Définissez la valeur --region sur la Région AWS où vous voulez créer le référentiel Amazon ECR.
- Remplacez 111122223333 par votre ID Compte AWS.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```

Créez un référentiel dans Amazon ECR à l’aide de la commande create-repository.


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

Note

Le référentiel Amazon ECR doit être dans la même Région AWS que la fonction Lambda.

En cas de succès, vous obtenez une réponse comme celle-ci :


{
    "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"
        }
    }
}

Copiez le repositoryUri à partir de la sortie de l’étape précédente.
Exécutez la commande docker tag pour étiqueter votre image locale dans votre référentiel Amazon ECR en tant que dernière version. Dans cette commande :
- docker-image:test est le nom et la balise de votre image Docker. Il s’agit du nom et de la balise de l’image que vous avez spécifiés dans la commande docker build.
- Remplacez <ECRrepositoryUri> par l’repositoryUri que vous avez copié. Assurez-vous d’inclure :latest à la fin de l’URI.
```
docker tag docker-image:test <ECRrepositoryUri>:latest
```
Exemple :
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
Exécutez la commande docker push pour déployer votre image locale dans le référentiel Amazon ECR. Assurez-vous d’inclure :latest à la fin de l’URI du référentiel.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
Créez un rôle d’exécution pour la fonction, si vous n’en avez pas déjà un. Vous aurez besoin de l’Amazon Resource Name (ARN) du rôle à l’étape suivante.
Créez la fonction Lambda. Pour ImageUri, indiquez l’URI du référentiel mentionné précédemment. Assurez-vous d’inclure :latest à la fin de l’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
```
Note
Vous pouvez créer une fonction à l’aide d’une image dans un compte AWS différent, à condition que l’image soit dans la même région que la fonction Lambda. Pour de plus amples informations, consultez Autorisations entre comptes Amazon ECR.

Invoquer la fonction.


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

Vous devriez obtenir une réponse comme celle-ci :


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

Pour voir la sortie de la fonction, consultez le fichier response.json.

Pour mettre à jour le code de la fonction, vous devez recréer l’image, charger la nouvelle image dans le référentiel Amazon ECR, puis utiliser la commande update-function-code pour déployer l’image dans la fonction Lambda.

Lambda résout l’étiquette d’image en hachage d’image spécifique. Cela signifie que si vous pointez la balise d’image qui a été utilisée pour déployer la fonction vers une nouvelle image dans Amazon ECR, Lambda ne met pas automatiquement à jour la fonction pour utiliser la nouvelle image.

Pour déployer la nouvelle image sur la même fonction Lambda, vous devez utiliser la commande update-function-code, même si la balise d’image dans Amazon ECR reste la même. Dans l’exemple suivant, l’option --publish crée une version de la fonction à l’aide de l’image du conteneur mise à jour.


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

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Déployez des archives de fichiers .zip

Contexte

Déployez le code TypeScript transpilé dans Lambda avec des images du conteneur

Utilisation d’une image de base Node.js pour créer et conditionner le code de fonction TypeScript

Pour créer une image à partir d’une image de base AWS pour Lambda

Note

Exemple Dockerfile

Note

Note

Pour charger l’image sur Amazon RIE et créer la fonction Lambda

Note

Note