# Creación de la primera MicroVM de Lambda
Este tutorial explica cómo crear una imagen de MicroVM de AWS Lambda y ejecutar una MicroVM a partir de esta. Al finalizar, tendrá una aplicación en ejecución a la que podrá acceder mediante HTTPS.
## Requisitos previos
Antes de comenzar, necesita dos elementos:
1. **Un bucket de Amazon S3** en la región de AWS que prefiera para almacenar el artefacto de la aplicación, es decir, el archivo .zip que creará en el paso 2.
1. **Un rol de compilación de IAM** que Lambda asume durante la creación de la imagen. Lambda utiliza este rol para descargar el artefacto de código desde Amazon S3 y escribir los registros de compilación en CloudWatch.
Cree el rol de IAM con la siguiente política de confianza. Esto permite que el servicio Lambda asuma el rol:
```
{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": { "Service": "lambda.amazonaws.com" },
"Action": ["sts:AssumeRole", "sts:TagSession"]
}]
}
```
Asocie al rol la siguiente política de permisos. Sustituya `` por el nombre del bucket de Amazon S3:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:GetObject"],
"Resource": "arn:aws:s3:::/*"
},
{
"Effect": "Allow",
"Action": ["logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents"],
"Resource": "arn:aws:logs:*:*:*"
}
]
}
```
**nota**
Si `Dockerfile` obtiene contenido de un repositorio privado de AWS ECR, agregue también `ecr:GetAuthorizationToken` y `ecr:BatchGetImage` a la política de permisos.
## Creación de la primera imagen de MicroVM
Una imagen de MicroVM captura la aplicación en un estado completamente inicializado. Cuando se ejecuta una MicroVM a partir de esta imagen, la aplicación se inicia de inmediato, sin demoras de arranque ni de inicialización.
### Paso 1: Escriba la aplicación y el Dockerfile
Cree un servidor HTTP sencillo que se ejecute dentro de la MicroVM. Este ejemplo utiliza Node.js sin dependencias externas:
**`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');
});
```
A continuación, cree un `Dockerfile` que empaquete e inicie la aplicación:
**`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"]
```
**nota**
La instrucción `FROM` establece la imagen de contenedor para las capas de la aplicación. Puede utilizar cualquier imagen de contenedor compatible. La imagen base administrada por Lambda, que proporciona el sistema operativo de la MicroVM y los componentes del servicio, se especifica por separado mediante `--base-image-arn` en el paso 3.
Si la aplicación genera valores únicos, como identificadores, secretos o material criptográfico, utilice la biblioteca estándar del lenguaje correspondiente para generar números seudoaleatorios criptográficamente seguros (CSPRNG), a fin de garantizar que los valores sean únicos entre las MicroVM. Si la aplicación utiliza OpenSSL, use la imagen de contenedor base de Lambda, que incluye una versión compatible con instantáneas. Para obtener más información, consulte la sección sobre compatibilidad con instantáneas en [Imágenes de MicroVM](microvms-images.md).
### Paso 2: Empaquete y cargue el contenido en Amazon S3
Empaquete `app.js` y `Dockerfile` en un archivo ZIP y, a continuación, cárguelo en el bucket de Amazon S3. Ejecute los siguientes comandos en el terminal:
```
zip app.zip app.js Dockerfile
aws s3 cp app.zip s3://{{your-bucket-name}}/app.zip
```
### Paso 3: Cree la imagen de MicroVM
Llame a `create-microvm-image` para iniciar la compilación. Lambda descarga el archivo ZIP desde Amazon S3, ejecuta `Dockerfile`, inicia la aplicación y captura una instantánea de Firecracker del estado completamente inicializado:
```
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
```
La imagen se inicia en el estado `CREATING`. Compruebe el estado de la compilación con:
```
aws lambda-microvms get-microvm-image \
--image-identifier my-first-microvm-image
```
Cuando finaliza la compilación, el campo `state` cambia a `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 el estado es `CREATE_FAILED`, consulte los registros de compilación en CloudWatch, en `/aws/lambda/microvms/my-first-microvm-image`.
## Ejecución de la primera MicroVM
Una vez que la imagen de MicroVM alcanza el estado `CREATED`, puede ejecutar MicroVM a partir de esta. Cada imagen puede lanzar numerosas MicroVM, una por inquilino, sesión de usuario o trabajo.
Ejecute una MicroVM con el siguiente 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}'
```
Explicación de los parámetros:
+ `--ingress-network-connectors`: habilita el tráfico HTTPS entrante a la MicroVM en todos los puertos. Este es un conector administrado por Lambda.
+ `--egress-network-connectors`: habilita el acceso saliente a Internet desde la MicroVM. Este es un conector administrado por Lambda.
+ `--idle-policy`: configura el comportamiento automático de suspensión y reanudación. Esta política suspende la MicroVM después de 15 minutos de inactividad, la mantiene suspendida durante un máximo de 5 minutos y la reanuda automáticamente cuando llega tráfico.
La respuesta incluye el ID de la MicroVM y la URL del punto de conexión:
```
{
"microvmId": "mvm-01234567-abcd-ef01-2345-6789abcdef01",
"state": "PENDING",
"endpoint": "mvm-01234567-abcd-ef01-2345-6789abcdef01.lambda-microvm.us-east-1.on.aws",
...
}
```
Espere a que el estado cambie a `RUNNING`:
```
aws lambda-microvms get-microvm \
--microvm-identifier mvm-01234567-abcd-ef01-2345-6789abcdef01
```
## Conexión a la MicroVM
Todas las solicitudes a un punto de conexión de MicroVM requieren un token de autenticación. Genere 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 respuesta incluye un token en el campo `authToken`. Úselo para enviar una solicitud a la aplicación en ejecución:
```
curl https://mvm-01234567-abcd-ef01-2345-6789abcdef01.lambda-microvm.us-east-1.on.aws/ \
-H "X-aws-proxy-auth: {{}}"
```
Debería ver la respuesta de la aplicación:
```
{"status":"ok","path":"/"}
```
La MicroVM está en ejecución y atiende el tráfico. La aplicación que escribió en el paso 1 está disponible en la URL del punto de conexión.
## Limpieza
Para evitar cargos continuos, termine la MicroVM cuando deje de utilizarla:
```
aws lambda-microvms terminate-microvm \
--microvm-identifier mvm-01234567-abcd-ef01-2345-6789abcdef01
```
## Siguientes pasos
+ Obtenga información sobre [Conceptos clave](microvms-how-it-works.md) para comprender el proceso de creación de instantáneas, los estados del ciclo de vida y las imágenes base.
+ Explore [Imágenes de MicroVM](microvms-images.md) para obtener información sobre los enlaces de compilación de imágenes, el control de versiones y la compatibilidad con instantáneas.
+ Consulte [Ejecución de MicroVM](microvms-launching.md) para ver ejemplos de SDK, enlaces del ciclo de vida y estrategias de escalado.