Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Créez votre première microVM Lambda

Ce didacticiel vous explique comment créer une image AWS Lambda microVM et exécuter une microVM à partir de celle-ci. À la fin, vous aurez une application en cours d'exécution accessible via HTTPS.

Conditions préalables

Vous avez besoin de deux choses avant de commencer :

Créez le rôle IAM avec la politique de confiance suivante. Cela permet au service Lambda d'assumer le rôle suivant :

{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Principal": { "Service": "lambda.amazonaws.com" },
    "Action": ["sts:AssumeRole", "sts:TagSession"]
  }]
}

Associez la politique d'autorisation suivante au rôle. Remplacez <your-bucket-name> par le nom de votre compartiment Amazon S3 :

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::<your-bucket-name>/*"
    },
    {
      "Effect": "Allow",
      "Action": ["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents"],
      "Resource": "arn:aws:logs:*:*:*"
    }
  ]
}

Création de votre première image microVM

Une image microVM capture votre application dans un état entièrement initialisé. Lorsque vous exécutez une microVM à partir de cette image, votre application démarre immédiatement, sans délai de démarrage ou d'initialisation.

Étape 1 : Rédigez votre application et votre Dockerfile

Créez un serveur HTTP simple qui s'exécutera dans votre microVM. Cet exemple utilise Node.js sans dépendances externes :

app.js

// Minimal HTTP server — listens on port 8080
const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({ status: 'ok', path: req.url }));
});

server.listen(8080, () => {
  console.log('Listening on port 8080');
});

Ensuite, créez un package Dockerfile qui empaquète et démarre votre application :

Dockerfile

# Use a lightweight Node.js runtime for your application layers
FROM node:24-alpine

# Set the working directory inside the container
WORKDIR /app

# Copy your application code
COPY app.js .

# Declare the port your app listens on
EXPOSE 8080

# Start the application — Lambda snapshots the running state
CMD ["node", "app.js"]

Étape 2 : Package et téléchargement sur Amazon S3

app.jsPackage votre Dockerfile main dans une archive zip, puis chargez-la dans votre compartiment Amazon S3. Exécutez les commandes suivantes dans votre terminal :

zip app.zip app.js Dockerfile
aws s3 cp app.zip s3://your-bucket-name/app.zip

Étape 3 : Création de l'image microVM

Appelez create-microvm-image pour démarrer la construction. Lambda télécharge votre fichier zip depuis Amazon S3, exécute votre applicationDockerfile, démarre votre application et capture un instantané Firecracker de l'état complètement initialisé :

aws lambda-microvms create-microvm-image \
  --name my-first-microvm-image \
  --code-artifact uri=s3://your-bucket-name/app.zip \
  --base-image-arn arn:aws:lambda:us-east-1:aws:microvm-image:al2023-1 \
  --build-role-arn arn:aws:iam::123456789012:role/MicrovmBuildRole

L'image démarre dans CREATING l'état actuel. Vérifiez l'état de la construction avec :

aws lambda-microvms get-microvm-image \
  --image-identifier my-first-microvm-image

Lorsque la construction est terminée, le state champ devient CREATED :

{
  "imageName": "my-first-microvm-image",
  "imageArn": "arn:aws:lambda:us-east-1:123456789012:microvm-image:my-first-microvm-image",
  "state": "CREATED",
  "imageVersion": "1.0",
  ...
}

Si l'état est le casCREATE_FAILED, vérifiez que le build se connecte CloudWatch sous/aws/lambda/microvms/my-first-microvm-image.

Exécution de votre première microVM

Une fois que l'image de votre microVM atteint son CREATED état, vous pouvez exécuter des microVM à partir de celle-ci. Chaque image peut lancer de nombreuses microVM : une par locataire, session utilisateur ou tâche.

Exécutez une microVM à l'aide de la commande suivante :

aws lambda-microvms run-microvm \
  --image-identifier my-first-microvm-image \
  --ingress-network-connectors "arn:aws:lambda:us-east-1:aws:network-connector:aws-network-connector:ALL_INGRESS" \
  --egress-network-connectors "arn:aws:lambda:us-east-1:aws:network-connector:aws-network-connector:INTERNET_EGRESS" \
  --idle-policy '{"autoResumeEnabled":true,"maxIdleDurationSeconds":900,"suspendedDurationSeconds":300}'

Paramètres expliqués :

La réponse inclut l'ID microVM et l'URL du point de terminaison :

{
  "microvmId": "mvm-01234567-abcd-ef01-2345-6789abcdef01",
  "state": "PENDING",
  "endpoint": "mvm-01234567-abcd-ef01-2345-6789abcdef01.lambda-microvm.us-east-1.on.aws",
  ...
}

Attendez que l'État atteigne RUNNING :

aws lambda-microvms get-microvm \
  --microvm-identifier mvm-01234567-abcd-ef01-2345-6789abcdef01

Connexion à votre microVM

Toutes les demandes adressées à un point de terminaison microVM nécessitent un jeton d'authentification. Générez-en un avec :

aws lambda-microvms create-microvm-auth-token \
  --microvm-identifier mvm-01234567-abcd-ef01-2345-6789abcdef01 \
  --expiration-in-minutes 30 \
  --allowed-ports '[{"allPorts":{}}]'

La réponse inclut un jeton dans le authToken champ. Utilisez-le pour envoyer une demande à votre application en cours d'exécution :

curl https://mvm-01234567-abcd-ef01-2345-6789abcdef01.lambda-microvm.us-east-1.on.aws/ \
  -H "X-aws-proxy-auth: <token-value>"

Vous devriez voir la réponse de votre candidature :

{"status":"ok","path":"/"}

Votre microVM est en cours d'exécution et gère le trafic. L'application que vous avez écrite à l'étape 1 est en ligne sur l'URL du point de terminaison.

Nettoyage

Pour éviter des frais récurrents, mettez fin à la microVM lorsque vous avez terminé :

aws lambda-microvms terminate-microvm \
  --microvm-identifier mvm-01234567-abcd-ef01-2345-6789abcdef01

Étapes suivantes