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à.

Crea la tua prima microVM Lambda

Questo tutorial illustra la creazione di un'immagine AWS Lambda MicroVM e l'esecuzione di una MicroVM da essa. Alla fine, avrai un'applicazione in esecuzione accessibile tramite HTTPS.

Prerequisiti

Hai bisogno di due cose prima di iniziare:

Crea il ruolo IAM con la seguente politica di fiducia. Ciò consente al servizio Lambda di assumere il ruolo:

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

Allega la seguente politica di autorizzazioni al ruolo. Sostituisci <your-bucket-name> con il nome del tuo bucket 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:*:*:*"
    }
  ]
}

Creazione della prima immagine MicroVM

Un'immagine MicroVM acquisisce l'applicazione in uno stato completamente inizializzato. Quando si esegue una microVM da questa immagine, l'applicazione si avvia immediatamente, senza ritardi di avvio o inizializzazione.

Passaggio 1: scrivi l'applicazione e il Dockerfile

Crea un semplice server HTTP che verrà eseguito all'interno della tua microVM. Questo esempio utilizza Node.js senza dipendenze esterne:

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

Quindi, crea un Dockerfile pacchetto e avvia l'applicazione:

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"]

Fase 2: Package e caricamento su Amazon S3

Package del tuo app.js and Dockerfile in un archivio zip, quindi caricalo nel tuo bucket Amazon S3. Esegui i seguenti comandi nel tuo terminale:

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

Fase 3: Creare l'immagine MicroVM

Chiama create-microvm-image per avviare la compilazione. Lambda scarica il file zip da Amazon S3, esegue, Dockerfile avvia l'applicazione e acquisisce un'istantanea di Firecracker dello stato completamente inizializzato:

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'immagine inizia nello stato. CREATING Controlla lo stato della build con:

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

Al termine della compilazione, il state campo diventa: 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",
  ...
}

Se lo stato èCREATE_FAILED, controlla i log in della build in CloudWatch . /aws/lambda/microvms/my-first-microvm-image

Esecuzione della prima microVM

Una volta che l'immagine MicroVM ha raggiunto CREATED lo stato, è possibile eseguire MicroVMS da essa. Ogni immagine può avviare molte microVM, una per tenant, sessione utente o processo.

Esegui una microVM con il seguente comando:

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}'

Parametri spiegati:

La risposta include l'ID MicroVM e l'URL dell'endpoint:

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

Attendi che lo stato raggiunga: RUNNING

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

Connessione alla tua microVM

Tutte le richieste a un endpoint MicroVM richiedono un token di autenticazione. Genera uno con:

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

La risposta include un token nel authToken campo. Usalo per inviare una richiesta all'applicazione in esecuzione:

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

Dovresti vedere la risposta dalla tua applicazione:

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

La tua microVM è in esecuzione e serve traffico. L'applicazione che hai scritto nella Fase 1 è attiva sull'URL dell'endpoint.

Eliminazione

Per evitare addebiti continui, interrompi la microVM quando hai finito:

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

Fasi successive