Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Menjalankan dan menggunakan microVMS

Bagian ini menjelaskan cara memulai microVMS, menyambung ke aplikasi yang sedang berjalan, mengelola siklus hidup microVM, dan menangani penskalaan.

Memulai MicroVM

Gunakan run-microvm perintah untuk meluncurkan microVM baru dari gambar tertentu. Lambda menyediakan sumber daya yang diperlukan, membuat titik akhir HTTPS khusus, dan memulai aplikasi Anda dari snapshot gambar.

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

MicroVM dibuat saat Anda menelepon. run-microvm Setiap microVM memiliki titik akhir khusus sendiri. Tidak ada penyeimbangan beban di seluruh microVM dari satu titik akhir — setiap titik akhir ditautkan ke satu microVM.

Satu-satunya parameter yang diperlukan adalah --image-identifier (yang harus menjadi ARN dari gambar microVM). Semua parameter lainnya adalah opsional.

Parameter Kunci

Konfigurasi kebijakan menganggur

Saat diaktifkan, kebijakan idle mengontrol penangguhan dan dimulainya kembali otomatis. Kehadiran lalu lintas melalui aktivitas sinyal endpoint microVM. Jika tidak ada lalu lintas yang tiba untuk durasi idle yang dikonfigurasi, microVM diperlakukan sebagai idle dan ditangguhkan.

Muatan runtime

runHookPayloadParameter ini memungkinkan Anda meneruskan data konfigurasi per-microVM (maks 16 KB string) pada waktu berjalan. Lambda mengirimkan muatan ini sebagai bagian dari badan permintaan ke kait siklus hidup. /run Lambda juga menyuntikkan microvmId ke dalam badan permintaan.

/runKait menerima badan JSON dengan struktur berikut:

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

Gunakan payload runtime untuk menyediakan konfigurasi yang bervariasi per microVM — misalnya, ID penyewa, token sesi, URL yang ditandatangani, atau jalur Secrets Manager. Tidak seperti variabel lingkungan (yang diatur pada tingkat gambar dan dibagikan di semua microVM dari gambar itu), muatan run hook unik untuk setiap microVM.

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'

Ketika Anda tidak lagi membutuhkan microVM, hentikan untuk menghentikan semua biaya. Untuk petunjuk, lihat Mengakhiri microVM.

Menghubungkan ke microVM

Setiap microVM mendapatkan URL titik akhir HTTPS publik yang unik, yang ditetapkan saat Anda menelepon. run-microvm Anda terhubung ke aplikasi Anda yang berjalan di dalam microVM melalui URL ini.

Autentikasi

Semua permintaan ke endpoint microVM memerlukan token otentikasi JWE. Tidak ada opsi akses yang tidak diautentikasi. Hasilkan token dengancreate-microvm-auth-token:

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

Token dicakup ke port tertentu dan memiliki kedaluwarsa yang dapat dikonfigurasi. Anda dapat membatasi akses ke satu port, rentang port, atau semua port:

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

Perutean port

Secara default, Lambda merutekan lalu lintas masuk ke port 8080 dalam microVM Anda. Untuk merutekan ke port yang berbeda, sertakan X-aws-proxy-port header dalam permintaan Anda. Port target harus berada dalam yang allowedPorts ditentukan dalam token otentikasi.

Protokol

Lambda MicroVMS mendukung,, WebSockets gRPC HTTP/2, dan SSE melalui URL endpoint.

Untuk WebSocket koneksi, berikan token otentikasi dan port target melalui subprotokol:

// 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 menghapus MicroVM-specific subprotokol dari permintaan sebelum meneruskannya ke aplikasi Anda.

Contoh SDK

Contoh berikut menunjukkan cara menjalankan microVM dan menghubungkannya menggunakan SDK AWS .

Python

contoh Contoh - Menjalankan MicroVM dan menghubungkan dengan boto3

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

contoh Contoh - Menjalankan microVM dan menghubungkan dengan AWS SDK untuk 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());

Mengirim permintaan

Bash

contoh Contoh - Mengirim permintaan dengan cURL

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

Python

contoh Contoh - Mengirim permintaan dengan perpustakaan permintaan

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

Node.js

contoh Contoh - Mengirim permintaan dengan fetch

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

Pengait siklus hidup

Pengait siklus hidup memungkinkan Anda menjalankan logika kustom pada titik-titik penting dalam siklus hidup microVM — saat dimulai, ditangguhkan, dilanjutkan, atau dihentikan. Gunakan kait untuk menginisialisasi status per penyewa, siram data sebelum menangguhkan, menyegarkan kredensyal saat resume, atau membersihkan sumber daya sebelum penghentian.

Setiap hook adalah titik akhir HTTP yang diekspos aplikasi Anda. Lambda mengirimkan permintaan POST ke hook pada acara siklus hidup yang sesuai. Hooks mendengarkan di jalur /aws/lambda-microvms/runtime/v1/<hook-name> pada port yang Anda konfigurasikan.

MicroVM Anda mulai menerima lalu lintas eksternal setelah /run hook mengembalikan HTTP 200. Sampai saat itu, titik akhir tidak meneruskan permintaan ke aplikasi Anda.

Untuk kait yang berjalan selama pembuatan gambar (/readydan/validate), lihatKait pembuatan gambar MicroVM.

Spesifikasi OpenAPI:

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

Menangguhkan dan melanjutkan microVMS

Tangguhkan microVMS untuk mengurangi biaya sambil mempertahankan status aplikasi. Saat berjalan, Anda membayar biaya komputasi. Saat ditangguhkan, Anda hanya membayar biaya penyimpanan snapshot.

Cara menangguhkan

Ada dua cara untuk menangguhkan microVM:

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

Kait /tangguhkan

Sebelum menangguhkan, Lambda memanggil /suspend hook Anda. Gunakan untuk membersihkan penulisan yang tertunda, menutup koneksi jaringan, dan melepaskan sumber daya yang tidak boleh bertahan di seluruh batas penangguhan.

Lanjutkan perilaku

Saat microVM dilanjutkan (melalui panggilan API atau lanjutkan otomatis), Lambda mengembalikan memori dan status disk dari pos pemeriksaan penangguhan. MicroVM tetap dalam SUSPENDED status saat /resume hook dijalankan. Setelah hook mengembalikan HTTP 200, microVM beralih ke RUNNING dan mulai menerima lalu lintas.

Gunakan /resume hook untuk menyegarkan kredensil, membangun kembali koneksi jaringan, dan memvalidasi status.

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

Auto-resume

Kapan autoResumeEnabled=true dan lalu lintas tiba di titik akhir microVM yang ditangguhkan, Lambda melanjutkan microVM secara otomatis. Lambda memegang permintaan masuk saat resume selesai (termasuk /resume hook), lalu mengirimkannya ke aplikasi Anda.

Resume menambahkan latensi ke permintaan pertama. Durasi tergantung pada ukuran status ditangguhkan yang dipulihkan dan durasi /resume kait Anda.

Jika resume tidak berhasil, Lambda mengembalikan 502 Bad Gateway ke penelepon.

Penskalaan dan konkurensi

Anda membuat microVMS baru dengan menelepon. run-microvm Setiap microVM memiliki titik akhir khusus sendiri. Tidak ada penyeimbangan beban di seluruh microVM dari satu titik akhir.

Account-level kapasitas — Akun Anda memiliki kuota untuk total memori yang dapat dialokasikan di semua microVM Anda di RUNNING atau SUSPENDED negara bagian di Wilayah, dan Anda dapat menskalakan secara vertikal hingga empat kali kuota ini. Untuk meminta peningkatan kuota, kunjungi konsol Service Quotas dan cari MicroVMS Lambda.

Model biaya:

Strategi untuk mengelola kapasitas:

Mengakhiri microVM

Hentikan microVM saat tidak lagi diperlukan. Penghentian melepaskan semua sumber daya komputasi dan menghentikan semua biaya.

Sebelum merilis sumber daya, Lambda memanggil /terminate hook Anda. Gunakan untuk menyiram data yang tertunda atau memberi tahu sistem eksternal.

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

Daftar MicroVMS

Cantumkan semua microVMS di akun Anda, secara opsional difilter berdasarkan gambar:

aws lambda-microvms list-microvms

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

Penanganan kesalahan

Jalankan kesalahan

Tabel berikut mencantumkan kesalahan umum yang dikembalikan oleh run-microvm API:

Strategi percobaan kembali

Untuk kesalahan sementara (ThrottlingException,InternalServerException), gunakan backoff eksponensial:

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