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 de jouer 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'autorisations 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 complètement initialisé. Lorsque vous exécutez une microVM à partir de cette image, votre application démarre immédiatement, sans délai de démarrage ni d'initialisation.

Étape 1 : Rédigez votre application et Dockerfile

Créez un serveur HTTP simple qui s'exécute 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 Dockerfile package et démarrez 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 : empaqueter et charger sur Amazon S3

app.jsEmballez votre Dockerfile annonce dans une archive zip, puis télé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, l'exécuteDockerfile, démarre votre application et capture un instantané de Firecracker à 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 commence dans CREATING cet état. Vérifiez l'état de la construction avec :

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

Une fois la génération 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 c'est le casCREATE_FAILED, vérifiez les journaux de compilation CloudWatch ci-dessous/aws/lambda/microvms/my-first-microvm-image.

Exécution de votre première microVM

Une fois que votre image MicroVM atteint son CREATED état, vous pouvez exécuter MicroVMS à partir de celle-ci. Chaque image peut lancer de nombreuses micromachines virtuelles, 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 de la 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 disponible à l'URL du point de terminaison.

Nettoyage

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

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

Étapes suivantes