Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

MicroVMS ausführen und verwenden

In diesem Abschnitt wird beschrieben, wie Sie MicroVMs starten, eine Verbindung zu Ihren laufenden Anwendungen herstellen, den MicroVM-Lebenszyklus verwalten und die Skalierung handhaben.

Eine MicroVM starten

Verwenden Sie den run-microvm Befehl, um eine neue MicroVM von einem angegebenen Image aus zu starten. Lambda stellt die erforderlichen Ressourcen bereit, erstellt einen dedizierten HTTPS-Endpunkt und startet Ihre Anwendung vom Image-Snapshot aus.

aws lambda-microvms run-microvm \
  --image-identifier arn:aws:lambda:us-east-1:123456789012:microvm-image:my-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":1800}' \
  --maximum-duration-in-seconds 14400

Eine MicroVM wird erstellt, wenn Sie anrufen. run-microvm Jede MicroVM hat ihren eigenen dedizierten Endpunkt. Es gibt keinen Lastenausgleich zwischen MicroVMs von einem einzigen Endpunkt aus — jeder Endpunkt ist mit einer einzigen MicroVM verknüpft.

Der einzige erforderliche Parameter ist --image-identifier (das muss der ARN des MicroVM-Images sein). Alle anderen Parameter sind optional.

Hauptparameter

Richtlinienkonfiguration im Leerlauf

Wenn diese Option aktiviert ist, steuert die Richtlinie für den Leerlauf die automatische Unterbrechung und Wiederaufnahme. Das Vorhandensein von Datenverkehr über den Endpunkt der microVM signalisiert Aktivität. Wenn für die konfigurierte Dauer des Leerlaufs kein Datenverkehr eingeht, wird die microVM als inaktiv behandelt und ausgesetzt.

Payloads zur Laufzeit

Mit runHookPayload diesem Parameter können Sie zur Laufzeit Konfigurationsdaten pro microVM (maximal 16 KB Zeichenfolge) übergeben. Lambda übermittelt diese Nutzlast als Teil des Anforderungstextes an den /run Lifecycle-Hook. Lambda fügt das auch microvmId in den Anforderungstext ein.

Der /run Hook empfängt einen JSON-Hauptteil mit der folgenden Struktur:

{
  "microvmId": "mvm-01234567-abcd-ef01-2345-6789abcdef01",
  "runHookPayload": "tenant-specific-string"
}

Verwenden Sie Runtime-Payloads, um Konfigurationen bereitzustellen, die je nach MicroVM variieren — zum Beispiel Mandanten-IDs, Sitzungstoken, signierte URLs oder Secrets Manager Manager-Pfade. Im Gegensatz zu Umgebungsvariablen (die auf Image-Ebene festgelegt und von allen MicroVMs dieses Images gemeinsam genutzt werden) ist die Run-Hook-Payload für jede MicroVM einzigartig.

aws lambda-microvms run-microvm \
  --image-identifier arn:aws:lambda:us-east-1:123456789012:microvm-image:my-microvm-image \
  --run-hook-payload 'tenant-specific-string'

Wenn Sie eine MicroVM nicht mehr benötigen, beenden Sie sie, damit keine Gebühren mehr anfallen. Detaillierte Anweisungen finden Sie unter Terminierung einer MicroVM.

Verbindung zu einer MicroVM herstellen

Jede MicroVM erhält eine eindeutige öffentliche HTTPS-Endpunkt-URL, die beim Anruf zugewiesen wird. run-microvm Über diese URL stellen Sie eine Verbindung zu Ihrer Anwendung her, die in der MicroVM ausgeführt wird.

Authentifizierung

Alle Anfragen an einen MicroVM-Endpunkt erfordern ein JWE-Authentifizierungstoken. Es gibt keine Option für einen nicht authentifizierten Zugriff. Generieren Sie ein Token mit: create-microvm-auth-token

aws lambda-microvms create-microvm-auth-token \
  --microvm-identifier microvm-id \
  --expiration-in-minutes 30 \
  --allowed-ports '[{"allPorts":{}}]'

Tokens sind auf bestimmte Ports beschränkt und haben ein konfigurierbares Ablaufdatum. Sie können den Zugriff auf einen einzelnen Port, einen Portbereich oder alle Ports einschränken:

{ "port": number }
{ "range": { "startPort": N, "endPort": N } }
{ "allPorts": {} }

Port-Routing

Standardmäßig leitet Lambda eingehenden Datenverkehr an Port 8080 innerhalb Ihrer MicroVM weiter. Um an einen anderen Port weiterzuleiten, fügen Sie den X-aws-proxy-port Header in Ihre Anfrage ein. Der Zielport muss innerhalb des im Authentifizierungstoken allowedPorts definierten Ports liegen.

Protokolle

Lambda MicroVMS unterstützt HTTP/2, WebSockets, gRPC und SSE über die Endpunkt-URL.

Übergeben Sie bei WebSocket Verbindungen das Authentifizierungstoken und den Zielport über Unterprotokolle:

// JavaScript WebSocket example
const protocols = [
  "lambda-microvms",                              // Required base protocol
  "lambda-microvms.authentication.<auth-token>",  // Auth token
  "lambda-microvms.port.9000"                     // Target port
];
const ws = new WebSocket('wss://<microvm-endpoint>/path', protocols);

Lambda entfernt MicroVM-specific Unterprotokolle aus der Anfrage, bevor sie an Ihre Anwendung weitergeleitet wird.

SDK-Beispiele

Die folgenden Beispiele zeigen, wie Sie eine MicroVM ausführen und mithilfe der AWS SDKs eine Verbindung zu ihr herstellen.

Python

Beispiel Beispiel — Eine MicroVM ausführen und eine Verbindung mit boto3 herstellen

import boto3, requests
client = boto3.client("lambda-microvms")
run_resp = client.run_microvm(
    imageIdentifier="arn:aws:lambda:us-east-1:123456789012:microvm-image:my-microvm-image",
    idlePolicy={"autoResumeEnabled": True, "maxIdleDurationSeconds": 900, "suspendedDurationSeconds": 300}
)
microvm_id = run_resp["microvmId"]
endpoint = run_resp["endpoint"]
print(f"MicroVM {microvm_id} running at {endpoint}")
token_resp = client.create_microvm_auth_token(
    microvmIdentifier=microvm_id, expirationInMinutes=30, allowedPorts=[{"allPorts": {}}]
)
token = token_resp["authToken"]["X-aws-proxy-auth"]
resp = requests.get(f"https://{endpoint}/health", headers={"X-aws-proxy-auth": token})
print(resp.status_code, resp.json())

Node.js

Beispiel Beispiel — Betrieb einer MicroVM und Herstellen einer Verbindung mit AWS SDK für JavaScript

import { LambdaMicrovmsClient, RunMicrovmCommand, CreateMicrovmAuthTokenCommand } from "@aws-sdk/client-lambda-microvms";
const client = new LambdaMicrovmsClient({});
const { microvmId, endpoint } = await client.send(new RunMicrovmCommand({
  imageIdentifier: "arn:aws:lambda:us-east-1:123456789012:microvm-image:my-microvm-image",
  idlePolicy: { autoResumeEnabled: true, maxIdleDurationSeconds: 900, suspendedDurationSeconds: 300 }
}));
const { authToken } = await client.send(new CreateMicrovmAuthTokenCommand({
  microvmIdentifier: microvmId, expirationInMinutes: 30, allowedPorts: [{ allPorts: {} }]
}));
const resp = await fetch(`https://${endpoint}/health`, {
  headers: { "X-aws-proxy-auth": authToken["X-aws-proxy-auth"] }
});
console.log(await resp.json());

Anfragen senden

Bash

Beispiel Beispiel — Senden einer Anfrage mit cURL

curl 'https://<microvm-endpoint>' \
  -H 'X-aws-proxy-auth: <TOKEN>' \
  -H 'X-aws-proxy-port: 8080'

Python

Beispiel Beispiel — Senden einer Anfrage mit der Anforderungsbibliothek

import requests
response = requests.get('https://<microvm-endpoint>', headers={'X-aws-proxy-auth': '<TOKEN>'})
print(response.text)

Node.js

Beispiel Beispiel — Senden einer Anfrage mit fetch

const response = await fetch('https://<microvm-endpoint>', {
  headers: { 'X-aws-proxy-auth': '<TOKEN>', 'X-aws-proxy-port': '8080' }
});
console.log(await response.text());

Lebenszyklus-Hooks

Mit Lifecycle-Hooks können Sie benutzerdefinierte Logik an wichtigen Punkten im MicroVM-Lebenszyklus ausführen — wenn der MicroVM-Lebenszyklus gestartet, unterbrochen, wieder aufgenommen oder beendet wird. Verwenden Sie Hooks, um den Status pro Mandant zu initialisieren, Daten vor dem Sperren zu leeren, Anmeldeinformationen bei der Wiederaufnahme zu aktualisieren oder Ressourcen vor der Beendigung zu bereinigen.

Jeder Hook ist ein HTTP-Endpunkt, den Ihre Anwendung verfügbar macht. Lambda sendet beim entsprechenden Lebenszyklusereignis eine POST-Anfrage an den Hook. Hooks überwachen den Pfad /aws/lambda-microvms/runtime/v1/<hook-name> auf dem Port, den Sie konfigurieren.

Ihre MicroVM beginnt, externen Datenverkehr zu empfangen, nachdem der /run Hook HTTP 200 zurückgibt. Bis dahin leitet der Endpunkt keine Anfragen an Ihre Anwendung weiter.

Informationen zu Hooks, die während der Image-Erstellung (/readyund/validate) ausgeführt werden, finden Sie unterHooks zum Erstellen von MicroVM-Images.

OpenAPI-Spezifikation:

{
  "openapi": "3.0.2",
  "info": {
    "title": "Lambda MicroVMs Application Hook Interface",
    "version": "2025-12-03"
  },
  "paths": {
    "/ready": {
      "post": {
        "description": "Called by Lambda during MicroVM image creation to determine if the application has initialized.",
        "operationId": "Ready",
        "responses": {
          "200": { "description": "Successful invocation." },
          "503": { "description": "Application is not yet ready. Lambda retries until timeout." }
        }
      }
    },
    "/resume": {
      "post": {
        "description": "Called by Lambda when resuming a MicroVM that is in the SUSPENDED state.",
        "operationId": "Resume",
        "responses": {
          "200": { "description": "Successful invocation." }
        }
      }
    },
    "/run": {
      "post": {
        "description": "Called by Lambda when a new MicroVM is run from a MicroVM image.",
        "operationId": "Run",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": { "$ref": "#/components/schemas/RunRequestContent" }
            }
          }
        },
        "responses": {
          "200": { "description": "Successful invocation." }
        }
      }
    },
    "/suspend": {
      "post": {
        "description": "Called by Lambda when suspending a MicroVM.",
        "operationId": "Suspend",
        "responses": {
          "200": { "description": "Successful invocation." }
        }
      }
    },
    "/terminate": {
      "post": {
        "description": "Called by Lambda when terminating a MicroVM, before resources are released.",
        "operationId": "Terminate",
        "responses": {
          "200": { "description": "Successful invocation." }
        }
      }
    },
    "/validate": {
      "post": {
        "description": "Called by Lambda when running a MicroVM to validate the image build. Use this hook to perform tests that validate your application behaves correctly when running. Lambda also samples the portions of the image that are used when handling this request, allowing Lambda to prefetch those portions of the image to reduce latency at run time.",
        "operationId": "Validate",
        "responses": {
          "200": { "description": "Successful invocation." },
          "503": { "description": "Validation in progress. Lambda retries until timeout." }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "RunRequestContent": {
        "type": "object",
        "properties": {
          "microvmId": {
            "type": "string",
            "description": "The MicroVM identifier."
          },
          "runHookPayload": {
            "type": "string",
            "description": "Run hook payload provided to RunMicrovm."
          }
        }
      }
    }
  },
  "servers": [
    { "url": "/aws/lambda-microvms/runtime/v1" }
  ]
}

MicroVMS aussetzen und wieder aufnehmen

Unterbrechen Sie MicroVMs, um die Kosten zu senken und gleichzeitig den Anwendungsstatus beizubehalten. Während des Betriebs zahlen Sie Rechengebühren. Während der Sperrung zahlen Sie nur Snapshot-Speichergebühren.

Wie kann ich den Vorgang aussetzen

Es gibt zwei Möglichkeiten, eine MicroVM auszusetzen:

aws lambda-microvms suspend-microvm --microvm-identifier microvm-id

Der /suspend-Hook

Vor dem Aussetzen ruft Lambda Ihren /suspend Hook auf. Verwenden Sie ihn, um ausstehende Schreibvorgänge zu löschen, Netzwerkverbindungen zu schließen und Ressourcen freizugeben, die nicht über die Suspend-Grenze hinaus bestehen bleiben dürfen.

Verhalten fortsetzen

Wenn eine MicroVM wieder aufgenommen wird (durch einen API-Aufruf oder automatische Wiederaufnahme), stellt Lambda den Speicher- und Festplattenstatus vom Suspend-Checkpoint aus wieder her. Die MicroVM bleibt im Status, während der Hook ausgeführt wird. SUSPENDED /resume Nachdem der Hook HTTP 200 zurückgegeben hat, wechselt die MicroVM zum Datenverkehr RUNNING und empfängt diesen.

Verwenden Sie den /resume Hook, um Anmeldeinformationen zu aktualisieren, Netzwerkverbindungen wiederherzustellen und den Status zu überprüfen.

aws lambda-microvms resume-microvm --microvm-identifier microvm-id

Auto-resume

Wenn autoResumeEnabled=true der Datenverkehr den Endpunkt einer angehaltenen MicroVM erreicht, nimmt Lambda die MicroVM automatisch wieder auf. Lambda hält die eingehende Anfrage, während der Lebenslauf abgeschlossen ist (einschließlich des /resume Hooks), und übermittelt sie dann an Ihre Anwendung.

Der Lebenslauf erhöht die Latenz bei der ersten Anfrage. Die Dauer hängt von der Größe des wiederherzustellenden Status und der Dauer Ihres /resume Hooks ab.

Wenn die Wiederaufnahme nicht erfolgreich ist, gibt Lambda 502 Bad Gateway an den Anrufer zurück.

Skalierung und Parallelität

Sie erstellen neue MicroVMs, indem Sie anrufen. run-microvm Jede MicroVM hat ihren eigenen dedizierten Endpunkt. Es gibt keinen Lastenausgleich zwischen MicroVMs von einem einzigen Endpunkt aus.

Account-level Kapazität — Ihr Konto hat ein Kontingent für den gesamten Arbeitsspeicher, der all Ihren MicroVMs in der Region RUNNING oder einem SUSPENDED Bundesstaat zugewiesen werden kann, und Sie können das Vierfache dieses Kontingents vertikal skalieren. Um eine Erhöhung des Kontingents zu beantragen, besuchen Sie die Service Quotas Quotas-Konsole und suchen Sie nach Lambda MicroVMs.

Kostenmodell:

Strategien für das Kapazitätsmanagement:

Terminierung einer MicroVM

Beenden Sie eine MicroVM, wenn sie nicht mehr benötigt wird. Durch die Kündigung werden alle Rechenressourcen freigegeben und alle Gebühren werden eingestellt.

Vor der Freigabe von Ressourcen ruft Lambda Ihren /terminate Hook auf. Verwenden Sie ihn, um ausstehende Daten zu löschen oder externe Systeme zu benachrichtigen.

aws lambda-microvms terminate-microvm --microvm-identifier microvm-id

MicroVMs auflisten

Listet alle MicroVMs in Ihrem Konto auf, optional nach Bildern gefiltert:

aws lambda-microvms list-microvms

# Filter by image
aws lambda-microvms list-microvms --image-identifier my-image --image-version 1.0

Fehlerbehandlung

Fehler ausführen

In der folgenden Tabelle sind die häufigsten Fehler aufgeführt, die von der run-microvm API zurückgegeben werden:

Versuchen Sie es erneut mit der Strategie

Verwenden Sie für vorübergehende Fehler (ThrottlingException,InternalServerException) den exponentiellen Backoff:

import time, random
def run_with_retry(client, params, max_retries=5):
    for attempt in range(max_retries):
        try:
            return client.run_microvm(**params)
        except client.exceptions.ThrottlingException:
            delay = (2 ** attempt) + random.uniform(0, 1)
            time.sleep(delay)
    raise Exception("Max retries exceeded")