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 durchführen.

Eine MicroVM starten

Verwenden Sie den run-microvm Befehl, um eine neue MicroVM von einem bestimmten 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 aufrufen. 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 einzelnen MicroVM verknüpft.

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

Hauptparameter

Konfiguration der Richtlinie „Inaktiv“

Wenn diese Option aktiviert ist, steuert die Richtlinie für den Leerlauf die automatische Sperrung und Wiederaufnahme. Das Vorhandensein von Datenverkehr über den Endpunkt der MicroVM signalisiert Aktivität. Wenn während der konfigurierten Leerlaufdauer kein Datenverkehr eingeht, wird die MicroVM als inaktiv behandelt und angehalten.

Nutzlasten zur Laufzeit

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

Der /run Hook erhält einen JSON-Body mit der folgenden Struktur:

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

Verwenden Sie Laufzeit-Payloads, um eine Konfiguration bereitzustellen, die je nach MicroVM unterschiedlich ist — zum Beispiel Mandanten-IDs, Sitzungstoken, signierte URLs oder Secrets Manager-Pfade. Im Gegensatz zu Umgebungsvariablen (die auf Image-Ebene festgelegt werden und von allen MicroVMs aus diesem Image aus 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, um alle Ladevorgänge zu beenden. Detaillierte Anweisungen finden Sie unter Eine MicroVM beenden.

Verbindung zu einer MicroVM herstellen

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

Authentifizierung

Für alle Anfragen an einen MicroVM-Endpunkt ist ein JWE-Authentifizierungstoken erforderlich. Es gibt keine unauthentifizierte Zugriffsoption. 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":{}}]'

Token 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 in 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 — Ausführen 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

Mithilfe von Lifecycle-Hooks können Sie benutzerdefinierte Logik an wichtigen Punkten im MicroVM-Lebenszyklus ausführen — wenn der MicroVM-Lebenszyklus beginnt, unterbrochen, fortgesetzt oder beendet wird. Verwenden Sie Hooks, um den Status pro Mandant zu initialisieren, Daten vor dem Aussetzen zu löschen, Anmeldeinformationen bei Wiederaufnahme zu aktualisieren oder Ressourcen vor dem Beenden zu bereinigen.

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

Ihre MicroVM beginnt, externen Datenverkehr zu empfangen, nachdem der /run Hook HTTP 200 zurückgegeben hat. 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" }
  ]
}

Aussetzen und Fortsetzen von MicroVMs

Setzen Sie MicroVMs aus, um die Kosten zu senken und gleichzeitig den Anwendungsstatus beizubehalten. Während der Ausführung zahlen Sie Rechengebühren. Während der Sperrung zahlen Sie nur Snapshot-Speichergebühren.

Wie kann ich aussetzen

Es gibt zwei Möglichkeiten, eine MicroVM zu suspendieren:

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

Der /suspend-Hook

Vor dem Suspendieren ruft Lambda Ihren Hook auf. /suspend 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 dürfen.

Verhalten wieder aufnehmen

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 SUSPENDED Status, während der /resume Hook ausgeführt wird. Nachdem der Hook HTTP 200 zurückgegeben hat, wechselt die MicroVM zum Datenverkehr RUNNING und beginnt, diesen zu empfangen.

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 gesperrten MicroVM erreicht, nimmt Lambda die MicroVM automatisch wieder auf. Lambda speichert die eingehende Anfrage, bis die Wiederaufnahme 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 Suspende-Zustands und der Dauer Ihres /resume Hooks ab.

Wenn die Wiederaufnahme nicht erfolgreich ist, gibt Lambda 502 Bad Gateway an den Aufrufer 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 den 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 im SUSPENDED Bundesstaat zugewiesen werden kann, und Sie können vertikal auf das Vierfache dieses Kontingents skalieren. Um eine Erhöhung des Kontingents anzufordern, besuchen Sie die Service Quota-Konsole und suchen Sie nach Lambda MicroVMs.

Kostenmodell:

Strategien für das Kapazitätsmanagement:

Eine MicroVM beenden

Beenden Sie eine MicroVM, wenn sie nicht mehr benötigt wird. Bei einer Kündigung werden alle Rechenressourcen freigegeben und alle Ladevorgänge werden gestoppt.

Vor der Freigabe von Ressourcen ruft Lambda Ihren /terminate Hook auf. Verwenden Sie es, 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:

Strategie erneut versuchen

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

Informationen zu unterstützten Serviceintegrationen mit Lambda Managed Instances finden Sie unter. Integrationen