# Configuración de funciones de AWS Lambda
Obtenga información sobre cómo configurar las capacidades y las opciones principales de su función de Lambda mediante la API o la consola de Lambda.
**[.archivos de archivo .zip](configuration-function-zip.md) **
Cree un paquete de implementación de funciones de Lambda cuando desee incluir dependencias, capas de tiempo de ejecución personalizadas o cualquier archivo más allá del código de la función. El paquete de implementación es un archivo .zip que contiene el código de la función y las dependencias.
**[Imágenes de contenedor](images-create.md) **
Utilice imágenes de contenedor para empaquetar el código de la función y las dependencias cuando necesite tener más control sobre el proceso de creación, o si la función requiere configuraciones de tiempo de ejecución personalizadas. Puede compilar, probar e implementar funciones de Lambda como imágenes de contenedor con herramientas como la CLI de Docker.
**[Memoria](configuration-memory.md)**
Obtenga información sobre cómo y cuándo aumentar la memoria de una función.
**[Almacenamiento efímero](configuration-ephemeral-storage.md) **
Obtenga información sobre cómo y cuándo aumentar la capacidad de almacenamiento temporal de la función.
**[Timeout (Tiempo de espera](configuration-timeout.md) **
Obtenga información sobre cómo y cuándo aumentar el valor del tiempo de espera de la función.
**[Configuración duradera](durable-configuration.md) **
Permita que las funciones de Lambda se ejecuten durante períodos prolongados (hasta 1 año) y, al mismo tiempo, mantenga el estado entre las invocaciones. Configure los tiempos de espera de ejecución, la retención del estado y el comportamiento de control de versiones para flujos de trabajo con estado y de larga duración. Las funciones duraderas le permiten crear procesos complejos de varios pasos que pueden pausar, reanudar y gestionar automáticamente las interrupciones.
** [ Variables de entorno](configuration-envvars.md)**
Puede hacer que el código de su función sea portátil y mantener los secretos fuera de su código almacenándolos en la configuración de la función mediante las variables de entorno.
**[Redes salientes](configuration-vpc.md) **
Puede utilizar la función de Lambda con los recursos de AWS de una nube de Amazon VPC. La conexión de la función a una VPC le permite obtener acceso a los recursos de una subred privada, como bases de datos relacionales y cachés.
** [Redes entrantes](configuration-vpc-endpoints.md)**
Puede utilizar un punto de conexión de VPC de tipo interfaz para invocar las funciones de Lambda sin pasar por la red pública de Internet.
**[Sistema de archivos](configuration-filesystem.md)**
Puede usar la función de Lambda para montar un sistema de Amazon EFS en un directorio local. Un sistema de archivos permite al código de su función acceder a los recursos compartidos de forma segura y en alta simultaneidad, y también le permite modificarlos.
**[Alias](configuration-aliases.md)**
Puede configurar sus clientes para invocar una versión específica de la función de Lambda mediante un alias en lugar de actualizar el cliente.
**[Versiones](configuration-versions.md)**
Al publicar una versión de su función, puede almacenar el código y la configuración como recursos independientes que no pueden modificarse.
**[Etiquetas de](configuration-tags.md)**
Utilice etiquetas para activar el control de acceso basado en atributos (ABAC), organizar las funciones de Lambda y filtrar y generar informes sobre las funciones mediante los servicios de Administración de costos y facturación de AWS Cost Explorer o AWS.
**[Transmisión de respuestas](configuration-response-streaming.md)**
Puede configurar las URL de función de Lambda para devolver las cargas de respuesta a los clientes. La transmisión de respuestas puede beneficiar a las aplicaciones sensibles a la latencia al mejorar el rendimiento del tiempo hasta el primer byte (TTFB). Esto se debe a que puede volver respuestas parciales al cliente a medida que estén disponibles. Además, puede usar la transmisión de respuestas para crear funciones que devuelvan cargas más grandes.
**[Punto de conexión de metadatos](configuration-metadata-endpoint.md)**
Utilice el punto de conexión de metadatos de Lambda para identificar en qué zona de disponibilidad se ejecuta su función, lo que le permite optimizar la latencia al enrutar hacia recursos en la misma zona de disponibilidad y aplicar patrones de resiliencia con reconocimiento de zona.
# Implementación de funciones de Lambda como archivos .zip
Cuando se crea una función Lambda, empaquete el código de función en un paquete de implementación. Lambda admite dos tipos de paquetes de implementación: imágenes de contenedor y archivos .zip. El flujo de trabajo para crear una función depende del tipo de paquete de implementación. Para configurar una función definida como una imagen de contenedor, consulte [Crear una función de Lambda con una imagen de contenedor](images-create.md).
Puede utilizar la consola de Lambda y la API de Lambda para crear una función definida con un archivo .zip. También puede cargar un archivo .zip actualizado para cambiar el código de función.
**nota**
No puede cambiar el [tipo de paquete de implementación](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip o imagen de contenedor) de una función existente. Por ejemplo, no se puede convertir una función de imagen de contenedor para utilizar un archivo .zip. Debe crear una nueva función.
**Topics**
+ [
## Creación de la función
](#configuration-function-create)
+ [
## Uso del editor de código de la consola
](#configuration-functions-console-update)
+ [
## Actualización del código de la función
](#configuration-function-update)
+ [
## Cambio del tiempo de ejecución
](#configuration-function-runtime)
+ [
## Modificación de la arquitectura
](#configuration-function-arch)
+ [
## Uso de la API de Lambda
](#configuration-function-api)
+ [
## Descargar el código de la función
](#configuration-function-download)
+ [
## CloudFormation
](#configuration-function-cloudformation)
+ [
# Cifrado de los paquetes de implementación .zip de Lambda
](encrypt-zip-package.md)
## Creación de la función
Cuando se crea una función definida con un archivo .zip, se elige una plantilla de código, la versión de idioma y el rol de ejecución para la función. Agregue su código de función después de que Lambda cree la función.
**Cómo crear la función**
1. Abra la página de [Functions](https://console.aws.amazon.com/lambda/home#/functions) (Funciones) en la consola de Lambda.
1. Elija **Create function (Crear función)**.
1. Seleccione **Author from scratch (Crear desde cero)** o **Use a blueprint (Usar proyecto)** para crear su función.
1. Bajo **Basic information (Información básica)**, haga lo siguiente:
1. En **Nombre de la función**, escriba el nombre de la función. Los nombres de las funciones están limitados a 64 caracteres de longitud.
1. Para **Runtime (Tiempo de ejecución)**, elija la versión del idioma que desea utilizar para su función.
1. (Opcional) Para **Architecture** (Arquitectura), elija la arquitectura del conjunto de instrucciones que utilizará para su función. La arquitectura predeterminada es x86\$164. Cuando cree el paquete de implementación para su función, asegúrese de que sea compatible con esta [arquitectura del conjunto de instrucciones](foundation-arch.md).
1. (Opcional) En **Permisos**, expanda **Cambiar función de ejecución predeterminada**. Puede crear un nuevo **Rol de ejecución** o crear un rol existente.
1. (Opcional) Expanda **Advanced settings (Configuración avanzada)**. Puede elegir una **Configuración de firma de código** para la función. También puede configurar una (Amazon VPC) para que tenga acceso a la función.
1. Elija **Create function (Crear función)**.
Lambda crea la nueva función. Ahora puede usar la consola para agregar el código de función y configurar otros parámetros y características de función. Para obtener instrucciones de implementación de código, consulte la página del controlador para conocer el tiempo de ejecución que utiliza la función.
------
#### [ Node.js ]
[Implementar funciones Node.js de Lambda con archivos de archivo.zip](nodejs-package.md)
------
#### [ Python ]
[Uso de archivos .zip para funciones de Lambda en Python](python-package.md)
------
#### [ Ruby ]
[Implementar funciones de Lambda de Ruby con archivos .zip](ruby-package.md)
------
#### [ Java ]
[Implementar funciones de Lambda Java con archivos de archivo .zip o JAR](java-package.md)
------
#### [ Go ]
[Implementar funciones de Lambda en Go con archivos .zip](golang-package.md)
------
#### [ C\$1 ]
[Crear e implementar funciones de Lambda C\$1 con archivos de archivo .zip](csharp-package.md)
------
#### [ PowerShell ]
[Implementar funciones Lambda de PowerShell con archivos .zip](powershell-package.md)
------
## Uso del editor de código de la consola
La consola crea una función de Lambda con un único archivo de fuente. Para los lenguajes de scripting, puede editar este archivo y agregar más archivos con el editor de código integrado. Para guardar los cambios, elija **Guardar**. A continuación, para ejecutar el código, elija **Pruebas**.
Al guardar el código de función, la consola de Lambda crea un paquete de implementación de archivo .zip. Cuando desarrolle el código de función fuera de la consola (mediante un IDE), debe [crear un paquete de implementación](nodejs-package.md) para cargar el código a la función de Lambda.
## Actualización del código de la función
Para los lenguajes de scripting (Node.js, Python y Ruby), puede editar el código de la función en el editor de código integrado. Si el tamaño del código supera los 3 MB, o si necesita agregar bibliotecas, o para lenguajes incompatibles con el editor (Java, Go, C\$1), debe cargar el código de función como un archivo .zip. Si el archivo .zip tiene un tamaño inferior a los 50 MB, puede cargarlo desde su equipo local. Si el tamaño del archivo supera los 50 MB, cárguelo a la función desde un bucket de Amazon S3.
**Para cargar código de función como un archivo .zip**
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija la función que desea actualizar y elija la pestaña **Código**.
1. En **Fuente de código**, seleccione **Cargar desde**.
1. Elija **.zip file** (Archivo .zip) y, a continuación, elija **Upload** (Cargar).
1. En el selector de archivos, seleccione la versión de imagen nueva y elija **Open** (Abrir) y, luego, **Save** (Guardar).
1. (Alternativa al paso 4) Elija **Amazon S3 location (Ubicación de Amazon S3)**.
1. En el cuadro de texto, introduzca el vínculo URL de S3 del archivo .zip y, después, elija **Save (Guardar)**.
## Cambio del tiempo de ejecución
Si actualiza la configuración de la función para utilizar un nuevo tiempo de ejecución, es posible que deba actualizar el código de la función para que sea compatible con el tiempo de ejecución nuevo. Si actualiza la configuración de la función para utilizar un tiempo de ejecución diferente, **debe** proporcionar un nuevo código de función que sea compatible con el tiempo de ejecución y la arquitectura. Para obtener instrucciones acerca de cómo crear un paquete de implementación para el código de función, consulte la página del controlador para conocer el tiempo de ejecución que utiliza la función.
Las imágenes base de Node.js 20, Python 3.12, Java 21, .NET 8, Ruby 3.3 y versiones posteriores se basan en la imagen de contenedor mínima de Amazon Linux 2023. Las imágenes base anteriores utilizan Amazon Linux 2. AL2023 ofrece varias ventajas con respecto a Amazon Linux 2, incluida una huella de implementación más reducida y versiones actualizadas de bibliotecas como `glibc`. Para obtener más información, consulte [Presentación del tiempo de ejecución de Amazon Linux 2023 para AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/) en el Blog de informática de AWS.
**Para cambiar el tiempo de ejecución**
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija la función que desea actualizar y elija la pestaña **Código**.
1. Desplácese hasta la sección **Configuración de tiempo de ejecución**, que se encuentra en el editor de código.
1. Elija **Edit (Edición de)**.
1. Para **Runtime** (Tiempo de ejecución), seleccione el identificador del tiempo de ejecución.
1. Para **Handler (Controlador)**, especifique el nombre de archivo y el controlador de au función.
1. Para **Architecture** (Arquitectura), elija la arquitectura del conjunto de instrucciones que utilizará para su función.
1. Seleccione **Save**.
## Modificación de la arquitectura
Antes de cambiar la arquitectura del conjunto de instrucciones, debe asegurarse de que el código de función sea compatible con la arquitectura de destino.
Si utiliza Node.js, Python o Ruby y edita el código de función en el editor integrado, el código existente puede ejecutarse sin modificaciones.
Sin embargo, si proporciona el código de función mediante un paquete de implementación de archivo .zip, debe preparar un nuevo archivo .zip recopilado y creado de forma correcta para el tiempo de ejecución de destino y la arquitectura del conjunto de instrucciones. Para obtener instrucciones, consulte la página del controlador para conocer el tiempo de ejecución de la función.
**Para cambiar la arquitectura del conjunto de instrucciones**
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija la función a actualizar y luego elija la pesetaña **Code (Código)**.
1. En **Runtime settings (Configuración de tiempo de ejecución)**, elija **Edit (Editar)**.
1. Para **Architecture** (Arquitectura), elija la arquitectura del conjunto de instrucciones que utilizará para su función.
1. Seleccione **Save**.
## Uso de la API de Lambda
Para crear y configurar una función que utilice un archivo .zip, utilice las siguientes operaciones de la API:
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
## Descargar el código de la función
Puede descargar la versión no publicada (`$LATEST`) actual del archivo .zip con el código de la función a través de la consola de Lambda. Para ello, primero asegúrese de que dispone de los siguientes permisos de IAM:
+ `iam:GetPolicy`
+ `iam:GetPolicyVersion`
+ `iam:GetRole`
+ `iam:GetRolePolicy`
+ `iam:ListAttachedRolePolicies`
+ `iam:ListRolePolicies`
+ `iam:ListRoles`
**Para descargar el archivo .zip con el código de la función**
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija la función para la que desea descargar el archivo .zip con el código de la función.
1. En la **Descripción general de la función**, pulse el botón **Descargar** y, a continuación, seleccione **Descargar archivo .zip con el código de la función**.
1. También puede seleccionar **Descargar archivo AWS SAM** para generar y descargar una plantilla SAM basada en la configuración de la función. También puede seleccionar **Descargar ambos** para descargar tanto el archivo .zip como la plantilla SAM.
## CloudFormation
Puede usar CloudFormation para crear una función Lambda con archivos .zip. En su plantilla CloudFormation, el recurso `AWS::Lambda::Function` especifica la función Lambda. Para obtener descripciones de las propiedades del recurso `AWS::Lambda::Function`, consulte [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html) en la *Guía del usuario de AWS CloudFormation*.
En el recurso `AWS::Lambda::Function`, establezca las siguientes propiedades para crear una función definida como un archivo .zip:
+ AWS::Lambda::Function
+ PackageType: estableca en `Zip`.
+ Código: introduzca el nombre del bucket de Amazon S3 y el nombre del archivo .zip en los campos `S3Bucket` y `S3Key`. Para Node.js o Python, puede proporcionar código fuente en línea de su función Lambda.
+ Tiempo de ejecución: establece el valor de tiempo de ejecución.
+ Arquitectura: establezca el valor de la arquitectura en `arm64` para utilizar el procesador Graviton2 de AWS. De forma predeterminada, el valor de la arquitectura es `x86_64`.
# Cifrado de los paquetes de implementación .zip de Lambda
Lambda siempre proporciona cifrado en el servidor en reposo para los paquetes de implementación .zip y los detalles de configuración de las funciones con una AWS KMS key. De forma predeterminada, Lambda utiliza una [Clave propiedad de AWS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk). Si este comportamiento predeterminado se ajusta a su flujo de trabajo, no tiene que configurar nada más. AWS no cobra por usar esta clave.
Si lo prefiere, puede proporcionar una clave administrada por el cliente de AWS KMS en su lugar. Puede hacerlo para tener control sobre la rotación de la clave de KMS o para cumplir con los requisitos de su organización para administrar claves de KMS. Cuando usa una clave administrada por el usuario, solo los usuarios de su cuenta con acceso a la clave de KMS pueden ver o administrar el código o la configuración de la función.
Las claves administradas por el cliente ocasionan cargos de AWS KMS estándar. Para más información, consulte [Precios de AWS Key Management Service](https://aws.amazon.com/kms/pricing/).
## Crear una clave administrada por el cliente
Puede crear una clave simétrica administrada por el cliente a través de la Consola de administración de AWS o las API de AWS KMS.
**Para crear una clave simétrica administrada por el cliente**
Siga los pasos de [Creación de cifrado simétrico y creación de claves de KMS simétricas](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) en la *Guía para desarrolladores de AWS Key Management Service*.
### Permisos
**Política de claves**
Las [políticas de clave](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) controlan el acceso a la clave administrada por el cliente. Cada clave administrada por el cliente debe tener exactamente una política de clave, que contiene instrucciones que determinan quién puede usar la clave y cómo puede utilizarla. Para obtener más información, consulte [Cómo cambiar una política de claves](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying.html#key-policy-modifying-how-to) en la *Guía para desarrolladores de AWS Key Management Service*.
Cuando se utiliza una clave administrada por el cliente para cifrar un paquete de implementación de .zip, Lambda no agrega ninguna [concesión](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) a la clave. En su lugar, su política de claves de AWS KMS debe permitir a Lambda llamar a las siguientes operaciones de la API de AWS KMS en su nombre:
+ [kms:GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)
+ [kms:Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)
El siguiente ejemplo de política de claves permite que todas las funciones de Lambda de la cuenta 111122223333 llamen a las operaciones de AWS KMS requeridas para la clave administrada por el cliente especificada:
**Example AWS KMSPolítica de claves de**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt"
],
"Resource": "arn:aws:kms:us-east-1:111122223333:key/key-id",
"Condition": {
"StringLike": {
"kms:EncryptionContext:aws:lambda:FunctionArn": "arn:aws:lambda:us-east-1:111122223333:function:*"
}
}
}
]
}
```
Para obtener información sobre la [solución de problemas de acceso a las claves](https://docs.aws.amazon.com/kms/latest/developerguide/policy-evaluation.html#example-no-iam), consulte la *Guía para desarrolladores de AWS Key Management Service*.
**Permisos de entidades principales**
Cuando se utiliza una clave administrada por el cliente para cifrar un paquete de implementación .zip, solo las [entidades principales](https://docs.aws.amazon.com/IAM/latest/UserGuide/intro-structure.html) con acceso a esa clave pueden acceder al paquete de implementación .zip. Por ejemplo, las entidades principales que no tienen acceso a la clave administrada por el cliente no pueden descargar el paquete .zip mediante la URL de S3 prefirmada que se incluye en la respuesta de [GetFunction](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html). Se devuelve una `AccessDeniedException` en la sección `Code` de la respuesta.
**Example AWS KMS AccessDeniedException**
```
{
"Code": {
"RepositoryType": "S3",
"Error": {
"ErrorCode": "AccessDeniedException",
"Message": "KMS access is denied. Check your KMS permissions. KMS Exception: AccessDeniedException KMS Message: User: arn:aws:sts::111122223333:assumed-role/LambdaTestRole/session is not authorized to perform: kms:Decrypt on resource: arn:aws:kms:us-east-1:111122223333:key/key-id with an explicit deny in a resource-based policy"
},
"SourceKMSKeyArn": "arn:aws:kms:us-east-1:111122223333:key/key-id"
},
...
```
Para obtener más información sobre los permisos para las claves de AWS KMS, consulte [Autenticación y control de acceso para AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/control-access.html).
## Uso de una clave administrada por el cliente para el paquete de implementación .zip
Utilice los siguientes parámetros de la API para configurar las claves administradas por el cliente para los paquetes de implementación .zip:
+ [SourceKMSKeyArn](https://docs.aws.amazon.com/lambda/latest/api/API_FunctionCode.html#lambda-Type-FunctionCode-SourceKMSKeyArn): cifra el paquete de implementación .zip de origen (el archivo que se carga).
+ [KMSKeyArn](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-KMSKeyArn): cifra las [variables de entorno](configuration-envvars-encryption.md) y las instantáneas de [Lambda SnapStart](snapstart.md).
Cuando `SourceKMSKeyArn` y `KMSKeyArn` se especifican, Lambda utiliza la clave `KMSKeyArn` para cifrar la versión descomprimida del paquete que Lambda usa para invocar la función. Cuando se especifica `SourceKMSKeyArn`, pero no `KMSKeyArn`, Lambda utiliza una [Clave administrada de AWS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk) para cifrar la versión descomprimida del paquete.
------
#### [ Lambda console ]
**Cómo agregar una clave de cifrado administrada por el cliente al crear una función**
1. Abra la página de [Functions](https://console.aws.amazon.com/lambda/home#/functions) (Funciones) en la consola de Lambda.
1. Seleccione **Creación de función**.
1. Elija **Author from scratch** (Crear desde cero) o **Container image** (Imagen de contenedor).
1. Bajo **Basic information (Información básica)**, haga lo siguiente:
1. En **Nombre de la función**, escriba el nombre de la función.
1. Para **Runtime (Tiempo de ejecución)**, elija la versión del idioma que desea utilizar para su función.
1. Expanda **Configuración avanzada** y, a continuación, seleccione **Habilitar el cifrado con una clave administrada por el cliente de AWS KMS**.
1. Elija una clave administrada por el cliente.
1. Seleccione **Creación de función**.
Para eliminar el cifrado de clave administrada por el cliente o utilizar una clave diferente, debe volver a cargar el paquete de implementación .zip.
**Cómo agregar el cifrado de clave administrada por el cliente a una función existente**
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija el nombre de una función.
1. En el panel **Código fuente**, elija **Cargar desde**.
1. Elija el **archivo .zip** o la **ubicación de Amazon S3**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/upload-zip.png)
1. Cargue el archivo o introduzca la ubicación de Amazon S3.
1. Elija **Habilitar el cifrado con una clave administrada por el cliente de AWS KMS**.
1. Elija una clave administrada por el cliente.
1. Seleccione **Save**.
------
#### [ AWS CLI ]
**Cómo agregar una clave de cifrado administrada por el cliente al crear una función**
En el siguiente ejemplo de [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html):
+ `--code`: especifica la ruta local al paquete de implementación .zip (`ZipFile`) y la clave administrada del cliente para cifrarla (`SourceKMSKeyArn`).
+ `--kms-key-arn`: especifica la clave administrada por el cliente para cifrar las variables de entorno y la versión descomprimida del paquete de implementación.
```
aws lambda create-function \
--function-name myFunction \
--runtime nodejs24.x \
--handler index.handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code ZipFile=fileb://myFunction.zip,SourceKMSKeyArn=arn:aws:kms:us-east-1:111122223333:key/key-id \
--kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key2-id
```
En el siguiente ejemplo de [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html):
+ `--code`: especifica la ubicación del archivo .zip en un bucket de Amazon S3 (`S3Bucket`, `S3Key`, `S3ObjectVersion`) y la clave administrada del el cliente para cifrarla (`SourceKMSKeyArn`).
+ `--kms-key-arn`: especifica la clave administrada por el cliente para cifrar las variables de entorno y la versión descomprimida del paquete de implementación.
```
aws lambda create-function \
--function-name myFunction \
--runtime nodejs24.x --handler index.handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion,SourceKMSKeyArn=arn:aws:kms:us-east-1:111122223333:key/key-id \
--kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key2-id
```
**Cómo agregar el cifrado de clave administrada por el cliente a una función existente**
En el siguiente ejemplo de [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html):
+ `--zip-file`: especifica la ruta local del paquete de implementación .zip.
+ `--source-kms-key-arn`: especifica la clave administrada por el cliente para cifrar la versión comprimida del paquete de implementación. Lambda utiliza una clave propiedad de AWS para cifrar el paquete descomprimido durante las invocaciones de la función. Si desea utilizar una clave administrada por el cliente para cifrar la versión descomprimida del paquete, ejecute el comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) con la opción `--kms-key-arn`.
```
aws lambda update-function-code \
--function-name myFunction \
--zip-file fileb://myFunction.zip \
--source-kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key-id
```
En el siguiente ejemplo de [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html):
+ `--s3-bucket`: especifica la ubicación del archivo .zip en un bucket de Amazon S3.
+ `--s3-key`: especifica la clave de Amazon S3 del paquete de implementación.
+ `--s3-object-version`: para objetos con control de versiones, la versión del objeto del paquete de implementación que se va a utilizar.
+ `--source-kms-key-arn`: especifica la clave administrada por el cliente para cifrar la versión comprimida del paquete de implementación. Lambda utiliza una clave propiedad de AWS para cifrar el paquete descomprimido durante las invocaciones de la función. Si desea utilizar una clave administrada por el cliente para cifrar la versión descomprimida del paquete, ejecute el comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) con la opción `--kms-key-arn`.
```
aws lambda update-function-code \
--function-name myFunction \
--s3-bucket amzn-s3-demo-bucket \
--s3-key myFileName.zip \
--s3-object-version myObject Version
--source-kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key-id
```
**Cómo eliminar el cifrado de clave administrada por el cliente de una función existente**
En el siguiente ejemplo de [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html), `--zip-file` especifica la ruta local al paquete de implementación .zip. Al ejecutar este comando sin la opción `--source-kms-key-arn`, Lambda utiliza una clave propia de AWS para cifrar la versión comprimida del paquete de implementación.
```
aws lambda update-function-code \
--function-name myFunction \
--zip-file fileb://myFunction.zip
```
------
# Crear una función de Lambda con una imagen de contenedor
El código de la función AWS Lambda se compone de scripts o programas compilados y sus dependencias. Utiliza un *paquete de implementación* para implementar su código de función en Lambda. Lambda admite dos tipos de paquetes de implementación: imágenes de contenedor y archivos .zip.
Hay tres formas de crear una imagen de contenedor para una función de Lambda:
+ [Uso de una imagen base de AWS para Lambda](#runtimes-images-lp)
Las [imágenes base de AWS](#runtimes-images-lp) vienen precargadas con un tiempo de ejecución de lenguaje, un cliente de interfaz de tiempo de ejecución para administrar la interacción entre Lambda y el código de la función, y un emulador de interfaz de tiempo de ejecución para realizar pruebas locales.
+ [Uso de una imagen base exclusiva del sistema operativo de AWS](#runtimes-images-provided)
[Las imágenes base exclusivas del sistema operativo de AWS](https://gallery.ecr.aws/lambda/provided)contienen una distribución de Amazon Linux y el [emulador de interfaz de tiempo de ejecución](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Por lo general, estas imágenes se utilizan para crear imágenes contenedoras para lenguajes compilados, como [Go](go-image.md#go-image-provided) y [Rust](lambda-rust.md), y para un lenguaje o versión de un lenguaje para los que Lambda no proporciona una imagen base, como Node.js 19. También puede usar imágenes base exclusivas del sistema operativo para implementar un [tiempo de ejecución personalizado](runtimes-custom.md). Para que la imagen sea compatible con Lambda, debe incluir en ella un [cliente de interfaz de tiempo de ejecución](#images-ric) para su lenguaje.
+ [Uso de una imagen base que no es de AWS](#images-types)
Puede utilizar una imagen base alternativa de otro registro de contenedores, como Alpine Linux o Debian. También puede utilizar una imagen personalizada creada por su organización. Para que la imagen sea compatible con Lambda, debe incluir en ella un [cliente de interfaz de tiempo de ejecución](#images-ric) para su lenguaje.
**sugerencia**
Para reducir el tiempo que tardan las funciones de contenedor de Lambda en activarse, consulte [Uso de compilaciones de varias fases](https://docs.docker.com/build/building/multi-stage/) en la documentación de Docker. Para compilar imágenes de contenedor eficientes, siga [Prácticas recomendadas para escribir Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
Para crear una función de Lambda a partir de una imagen de contenedor, cree su imagen de manera local y cárguela en un repositorio de Amazon Elastic Container Registry (Amazon ECR). Si está utilizando una imagen de contenedor proporcionada por un vendedor de [AWS Marketplace](https://docs.aws.amazon.com/marketplace/latest/userguide/container-based-products.html), antes debe clonar la imagen en su repositorio privado de Amazon ECR. A continuación, especifique el URI del repositorio cuando cree la función. El repositorio Amazon ECR debe estar en el mismo Región de AWS que la función de Lambda. Puede crear una función con una imagen de una cuenta AWS diferente, siempre que la imagen esté en la misma región que la función de Lambda. Para obtener más información, consulte [Permisos entre cuentas de Amazon ECR](#configuration-images-xaccount-permissions).
**nota**
Lambda no admite puntos de conexión FIPS de Amazon ECR para imágenes de contenedores. Si el URI de su repositorio incluye `ecr-fips`, está utilizando un punto de conexión FIPS. Ejemplo: : `111122223333.dkr.ecr-fips.us-east-1.amazonaws.com`.
En esta página, se explican los tipos de imágenes base y los requisitos para crear imágenes de contenedor compatibles con Lambda.
**nota**
No puede cambiar el [tipo de paquete de implementación](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip o imagen de contenedor) de una función existente. Por ejemplo, no se puede convertir una función de imagen de contenedor para utilizar un archivo .zip. Debe crear una nueva función.
**Topics**
+ [
## Requisitos
](#images-reqs)
+ [
## Uso de una imagen base de AWS para Lambda
](#runtimes-images-lp)
+ [
## Uso de una imagen base exclusiva del sistema operativo de AWS
](#runtimes-images-provided)
+ [
## Uso de una imagen base que no es de AWS
](#images-types)
+ [
## Clientes de interfaz de tiempo de ejecución
](#images-ric)
+ [
## Permisos de Amazon ECR
](#gettingstarted-images-permissions)
+ [
## Ciclo de vida de la función
](#images-lifecycle)
## Requisitos
Instale la [versión 2 de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) y la [CLI de Docker](https://docs.docker.com/get-docker). Además, tenga en cuenta los siguientes requisitos:
+ La imagen de contenedor debe implementar la [Uso de la API de tiempo de ejecución de Lambda para tiempos de ejecución personalizados](runtimes-api.md). Los [clientes de interfaz de tiempo de ejecución](#images-ric) de AWS de código abierto implementan la API. Puede agregar un cliente de interfaz de tiempo de ejecución a su imagen base preferida para que sea compatible con Lambda.
+ La imagen de contenedor debe poder ejecutarse en un sistema de archivos de solo lectura. Su código de función puede acceder a un directorio `/tmp` con escritura permitida con entre 512 MB y 10,240 MB, en incrementos de 1 MB, de almacenamiento.
+ El usuario predeterminado de Lambda debe ser capaz de leer todos los archivos necesarios para ejecutar el código de función. Lambda sigue las prácticas recomendadas de seguridad definiendo un usuario predeterminado de Linux con permisos de privilegio mínimo. Esto significa que no tiene que especificar un [USUARIO](https://docs.docker.com/reference/dockerfile/#user) en el Dockerfile. Compruebe que el código de su aplicación no depende de los archivos que otros usuarios de Linux tienen restricciones para ejecutar.
+ Lambda solo admite imágenes de contenedor basadas en Linux.
+ Lambda proporciona imágenes base de varias arquitecturas. Sin embargo, la imagen que crea para su función debe tener como destino a solo una de las arquitecturas. Lambda no admite funciones que utilizan imágenes de contenedor de varias arquitecturas.
## Uso de una imagen base de AWS para Lambda
Puede utilizar una de las [imágenes base de AWS](https://gallery.ecr.aws/lambda/) para Lambda a fin de crear la imagen de contenedor para el código de función. Las imágenes base están precargadas con un tiempo de ejecución de lenguaje y otros componentes necesarios para ejecutar una imagen contenedor en Lambda. Agregue su código de función y dependencias a la imagen base y luego lo empaqueta como una imagen de contenedor.
AWS proporciona periódicamente actualizaciones a las imágenes base AWS para Lambda. Si su Dockerfile incluye el nombre de la imagen en la propiedad FROM, el cliente de Docker extrae la última versión de la imagen del [repositorio de Amazon ECR](https://gallery.ecr.aws/lambda/). Para utilizar la imagen base actualizada, debe reconstruir la imagen contenedor y [actualizar el código de función](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html).
Las imágenes base de Node.js 20, Python 3.12, Java 21, .NET 8, Ruby 3.3 y versiones posteriores se basan en la [imagen de contenedor mínima de Amazon Linux 2023](https://docs.aws.amazon.com/linux/al2023/ug/minimal-container.html). Las imágenes base anteriores utilizan Amazon Linux 2. AL2023 ofrece varias ventajas con respecto a Amazon Linux 2, incluida una huella de implementación más reducida y versiones actualizadas de bibliotecas como `glibc`.
Las imágenes basadas en AL2023 utilizan `microdnf` (enlazadas simbólicamente como `dnf`) como administrador de paquetes en lugar de `yum`, que es el administrador de paquetes predeterminado en Amazon Linux 2. `microdnf` es una implementación independiente de `dnf`. Para obtener una lista de los paquetes que se incluyen en las imágenes basadas en AL2023, consulte las columnas de **Minimal Container** de [Comparing packages installed on Amazon Linux 2023 Container Images](https://docs.aws.amazon.com/linux/al2023/ug/al2023-container-image-types.html). Para obtener más información sobre las diferencias entre AL2023 y Amazon Linux 2, consulte [Introducing the Amazon Linux 2023 runtime for AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/) en el Blog de informática de AWS.
**nota**
Para ejecutar imágenes basadas en AL2023 de forma local, incluso con AWS Serverless Application Model (AWS SAM), debe usar Docker en la versión 20.10.10 o posterior.
Para crear una imagen de contenedor a partir de una imagen base de AWS, elija las instrucciones para el lenguaje que prefiera:
+ [Node.js](nodejs-image.md#nodejs-image-instructions)
+ [TypeScript](typescript-image.md#base-image-typescript) (usa una imagen base de Node.js)
+ [Python](python-image.md#python-image-instructions)
+ [Java](java-image.md#java-image-instructions)
+ [Go](go-image.md#go-image-provided)
+ [.NET](csharp-image.md#csharp-image-instructions)
+ [Ruby](ruby-image.md#ruby-image-instructions)
## Uso de una imagen base exclusiva del sistema operativo de AWS
[Las imágenes base exclusivas del sistema operativo de AWS](https://gallery.ecr.aws/lambda/provided)contienen una distribución de Amazon Linux y el [emulador de interfaz de tiempo de ejecución](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Por lo general, estas imágenes se utilizan para crear imágenes contenedoras para lenguajes compilados, como [Go](go-image.md#go-image-provided) y [Rust](lambda-rust.md), y para un lenguaje o versión de un lenguaje para los que Lambda no proporciona una imagen base, como Node.js 19. También puede usar imágenes base exclusivas del sistema operativo para implementar un [tiempo de ejecución personalizado](runtimes-custom.md). Para que la imagen sea compatible con Lambda, debe incluir en ella un [cliente de interfaz de tiempo de ejecución](#images-ric) para su lenguaje.
| Etiquetas | Tiempo de ejecución | Sistema operativo | Dockerfile | Obsolescencia |
| --- | --- | --- | --- | --- |
| al2023 | Tiempo de ejecución exclusivo del sistema operativo | Amazon Linux 2023 | [Dockerfile para tiempo de ejecución exclusivo del sistema operativo en GitHub](https://github.com/aws/aws-lambda-base-images/blob/provided.al2023/Dockerfile.provided.al2023) | 30 de junio de 2029 |
| al2 | Tiempo de ejecución exclusivo del sistema operativo | Amazon Linux 2 | [Dockerfile para tiempo de ejecución exclusivo del sistema operativo en GitHub](https://github.com/aws/aws-lambda-base-images/blob/provided.al2/Dockerfile.provided.al2) | 31 de julio de 2026 |
Galería pública de Amazon Elastic Container Registry: [gallery.ecr.aws/lambda/provided](https://gallery.ecr.aws/lambda/provided)
## Uso de una imagen base que no es de AWS
Lambda admite cualquier imagen que se ajuste a uno de los siguientes formatos de manifiesto de imagen:
+ Docker Image Manifest V2 Schema 2 (usado con Docker versión 1.10 y posteriores)
+ Especificaciones de la iniciativa de contenedores abiertos (OCI) (versión 1.0.0 y posteriores)
Lambda admite un tamaño máximo de imagen sin comprimir de 10 GB, incluidas todas las capas.
**nota**
Para que la imagen sea compatible con Lambda, debe incluir en ella un [cliente de interfaz de tiempo de ejecución](#images-ric) para su lenguaje.
Para un rendimiento óptimo, mantenga el tamaño del manifiesto de la imagen por debajo de 25 400 bytes. Para reducir el tamaño del manifiesto de la imagen, minimice el número de capas de la imagen y reduzca las anotaciones.
## Clientes de interfaz de tiempo de ejecución
Si utiliza una [imagen base exclusiva del sistema operativo](#runtimes-images-provided) o una imagen base alternativa, debe incluir un cliente de interfaz de tiempo de ejecución en su imagen. El cliente de interfaz de tiempo de ejecución debe extender la [Uso de la API de tiempo de ejecución de Lambda para tiempos de ejecución personalizados](runtimes-api.md), que administra la interacción entre Lambda y el código de función. AWS proporciona clientes de interfaz de tiempo de ejecución de código abierto para los siguientes lenguajes:
+ [Node.js](nodejs-image.md#nodejs-image-clients)
+ [Python](python-image.md#python-image-clients)
+ [Java](java-image.md#java-image-clients)
+ [.NET](csharp-image.md#csharp-image-clients)
+ [Go](go-image.md#go-image-clients)
+ [Ruby](ruby-image.md#ruby-image-clients)
+ [Rust](lambda-rust.md) –
Si utiliza un lenguaje que no tiene un cliente de interfaz de tiempo de ejecución de AWS, debe crear el suyo propio.
## Permisos de Amazon ECR
Antes de crear la función de Lambda desde una imagen de contenedor, debe crear la imagen de forma local y cargarla en un repositorio de Amazon ECR. Cuando cree la función, especifique el URI del repositorio de Amazon ECR.
Asegúrese de que los permisos para el usuario o el rol que crea la función incluyan `GetRepositoryPolicy`, `SetRepositoryPolicy`, `BatchGetImage` y `GetDownloadUrlForLayer`.
Por ejemplo, utilice la consola de IAM para crear un rol con la siguiente política:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"ecr:SetRepositoryPolicy",
"ecr:GetRepositoryPolicy",
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Resource": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world"
}
]
}
```
------
### Políticas de repositorios de Amazon ECR
Para una función en la misma cuenta que la imagen de contenedor en Amazon ECR, puede agregar los permisos `ecr:BatchGetImage` y `ecr:GetDownloadUrlForLayer` a su política de repositorios de Amazon ECR. En el siguiente ejemplo se muestra la política mínima:
```
{
"Sid": "LambdaECRImageRetrievalPolicy",
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
]
}
```
Para obtener más información sobre los permisos de repositorio de Amazon ECR, consulte [Políticas de repositorio privado](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policies.html) en la *Guía del usuario de Amazon Elastic Container Registry*.
Si el repositorio de Amazon ECR no incluye estos permisos, Lambda intenta agregarlos automáticamente. Lambda puede agregar estos permisos únicamente si la entidad principal que llama a Lambda tiene los permisos `ecr:getRepositoryPolicy` y `ecr:setRepositoryPolicy`.
Para ver o editar los permisos del repositorio de Amazon ECR, siga las instrucciones de [Establecer una instrucción de política de repositorio privado](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html) en la *Guía del usuario de Amazon Elastic Container Registry*.
#### Permisos entre cuentas de Amazon ECR
Una cuenta diferente en la misma región puede crear una función que utiliza una imagen de contenedor propiedad de su cuenta. En el siguiente ejemplo, su [política de permisos de repositorio de Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html) necesita las siguientes instrucciones para otorgar acceso al número de cuenta 123456789012.
+ **CrossAccountPermission**: permite a la cuenta 123456789012 crear y actualizar funciones Lambda que utilizan imágenes de este repositorio ECR.
+ **LambdaECRImageCrossAccountRetrievalPolicy**: con el tiempo, Lambda establecerá el estado de una función como inactiva si esta no se invoca durante un período prolongado. Esta instrucción es necesaria para que Lambda pueda recuperar la imagen de contenedor para su optimización y almacenamiento en caché en nombre de la función propiedad de 123456789012.
**Example — Agregar permiso entre cuentas al repositorio**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CrossAccountPermission",
"Effect": "Allow",
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Principal": {
"AWS": "arn:aws:iam::123456789012:root"
},
"Resource": "arn:aws:ecr:us-east-1:123456789012:repository/example-lambda-repository"
},
{
"Sid": "LambdaECRImageCrossAccountRetrievalPolicy",
"Effect": "Allow",
"Action": [
"ecr:BatchGetImage",
"ecr:GetDownloadUrlForLayer"
],
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Condition": {
"ArnLike": {
"aws:sourceARN": "arn:aws:lambda:us-east-1:123456789012:function:*"
}
},
"Resource": "arn:aws:ecr:us-east-1:123456789012:repository/example-lambda-repository"
}
]
}
```
Para brindar acceso a varias cuentas, agregue los ID de cuenta a la lista de la entidad principal en la política `CrossAccountPermission` y a la lista de evaluación de condiciones en `LambdaECRImageCrossAccountRetrievalPolicy`.
Si está trabajando con varias cuentas en una organización de AWS, le recomendamos que enumere cada ID de cuenta en la política de permisos ECR. Este enfoque se alinea con la práctica recomendada de seguridad de AWS de establecer permisos limitados en las políticas de IAM.
Además de los permisos de Lambda, el usuario o rol que crea la función también debe tener los permisos `BatchGetImage` y `GetDownloadUrlForLayer`.
## Ciclo de vida de la función
Después de cargar una imagen de contenedor nueva o actualizada, Lambda la optimiza antes de que la función pueda procesar las invocaciones. El proceso de optimización puede tardar unos segundos. La función permanece en el estado `Active` hasta que finaliza el proceso, momento en el que el estado pasa a `Pending`. No puede invocar la función hasta que alcance el estado `Active`.
Si una función no se invoca durante varias semanas, Lambda recupera su versión optimizada y la función pasa al estado `Inactive`. Para reactivar la función, debe invocarla. Lambda rechaza la primera invocación y la función entra en el estado `Pending` hasta que Lambda vuelva a optimizar la imagen. A continuación, la función regresa al `Active` estado.
Lambda recupera periódicamente la imagen del contenedor asociado del repositorio de Amazon ECR. Si la imagen de contenedor correspondiente ya no existe en Amazon ECR o se revocan los permisos, la función entra en estado `Failed` y Lambda devuelve un error para cualquier invocación de la función.
Puede utilizar la API de Lambda para obtener información sobre el estado de una función. Para obtener más información, consulte [Estados de función de Lambda](functions-states.md).
# Configuración de la memoria de una función de Lambda
Lambda asigna potencia de CPU en proporción a la cantidad de memoria configurada. La *memoria* es la cantidad de memoria disponible para la función de Lambda en tiempo de ejecución. Puede aumentar o disminuir la memoria y la potencia de CPU asignada a su función mediante la configuración **Memoria**. Puede configurar un valor de memoria comprendido entre 128 MB y 10 240 MB, en incrementos de 1 MB. Si se configuran 1769 MB, la función tiene el equivalente de una vCPU (un segundo de créditos de vCPU por segundo).
En esta página se describe cómo y cuándo actualizar la configuración de memoria de una función de Lambda.
**Topics**
+ [
## Determinación de la configuración de memoria adecuada de una función de Lambda
](#configuration-memory-use-cases)
+ [
## Configuración de la memoria de función (consola)
](#configuration-memory-console)
+ [
## Configuración de la memoria de una función (AWS CLI)
](#configuration-memory-cli)
+ [
## Configuración de la memoria de una función (AWS SAM)
](#configuration-memory-sam)
+ [
## Aceptación de recomendaciones de memoria de función (consola)
](#configuration-memory-optimization-accept)
## Determinación de la configuración de memoria adecuada de una función de Lambda
La memoria es la palanca principal para controlar el rendimiento de una función. El valor predeterminado, 128 MB, es el más bajo posible. Solo se recomienda utilizar 128 MB para las funciones de Lambda sencillas, como las que transforman y enrutan eventos a otros servicios de AWS. Una mayor asignación de memoria puede mejorar el rendimiento de las funciones que utilizan bibliotecas importadas, [capas de Lambda](chapter-layers.md), Amazon Simple Storage Service (Amazon S3) o Amazon Elastic File System (Amazon EFS). Agregar más memoria aumenta proporcionalmente la cantidad de CPU, lo que aumenta la potencia computacional general disponible. Si una función está vinculada a la CPU, la red o la memoria, aumentar la configuración de memoria puede mejorar drásticamente su rendimiento.
Para encontrar la configuración de memoria adecuada, supervise las funciones con Amazon CloudWatch y establezca alarmas que avisen en caso de que el consumo de memoria se acerque a los máximos configurados. Esto puede ayudar a identificar las funciones vinculadas a la memoria. En el caso de las funciones vinculadas a la CPU y a las operaciones de E/S, la supervisión de la duración también puede aportar información. En estos casos, aumentar la memoria puede ayudar a resolver los cuellos de botella informáticos o de red.
También puede considerar el uso de la herramienta de código abierto [AWS Lambda Power Tuning](https://github.com/alexcasalboni/aws-lambda-power-tuning). Esta herramienta utiliza AWS Step Functions para ejecutar varias versiones simultáneas de una función de Lambda en diferentes asignaciones de memoria y medir el rendimiento. La función de entrada se ejecuta en su cuenta de AWS y realiza llamadas HTTP en tiempo real e interacciones con el SDK para medir el rendimiento probable en un escenario de producción activo. También puede implementar un proceso de CI/CD para usar esta herramienta y medir automáticamente el rendimiento de las nuevas funciones que implemente.
## Configuración de la memoria de función (consola)
Puede configurar la memoria de su función en la consola de Lambda.
**Para actualizar la memoria de una función**
1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija una función.
1. Seleccione **Configuración** y, a continuación, **Configuración general**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/configuration-tab.png)
1. En **Configuración general**, seleccione la pestaña **Etiquetas**.
1. En **Memoria**, establezca un valor comprendido entre 128 MB y 10 240 MB.
1. Seleccione **Save**.
## Configuración de la memoria de una función (AWS CLI)
Puede usar el comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) para configurar la memoria de la función.
**Example**
```
aws lambda update-function-configuration \
--function-name my-function \
--memory-size 1024
```
## Configuración de la memoria de una función (AWS SAM)
Puede usar [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) para configurar la memoria de su función. Actualice la propiedad [MemorySize](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-memorysize) de su archivo `template.yaml` y, a continuación, ejecute [sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html).
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 1024
# Other function properties...
```
## Aceptación de recomendaciones de memoria de función (consola)
Si tiene permisos de administrador en AWS Identity and Access Management (IAM), puede optar por recibir recomendaciones de configuración de memoria de Lambda función de AWS Compute Optimizer. Para obtener instrucciones sobre cómo darse de alta en las recomendaciones de memoria para su cuenta u organización, consulte [Opción en su cuenta](https://docs.aws.amazon.com/compute-optimizer/latest/ug/getting-started.html#account-opt-in) en la *Guía del usuario de AWS Compute Optimizer*.
**nota**
Compute Optimizer solo admite funciones que utilizan la arquitectura x86\$164.
Luego de realizar la activación y de que su [función de Lambda cumpla con los requisitos de Compute Optimizer](https://docs.aws.amazon.com/compute-optimizer/latest/ug/requirements.html#requirements-lambda-functions), puede ver y aceptar recomendaciones de memoria de la función desde Compute Optimizer de la consola de Lambda, en **Configuración general**.
# Configuración del almacenamiento efímero para funciones de Lambda
Lambda proporciona almacenamiento efímero para las funciones del directorio `/tmp`. Este almacenamiento es temporal y exclusivo de cada entorno de ejecución. Puede controlar la cantidad de almacenamiento efímero asignado a su función mediante la configuración **Almacenamiento efímero**. Puede configurar un valor de almacenamiento efímero comprendido entre 512 MB y 10 240 MB, en incrementos de 1 MB. Todos los datos almacenados en `/tmp` se cifran en reposo con una clave administrada por AWS.
En esta página, se describen los casos de uso más comunes y cómo actualizar el almacenamiento efímero de una función de Lambda.
**Topics**
+ [
## Casos de uso habituales para aumentar el almacenamiento efímero
](#configuration-ephemeral-storage-use-cases)
+ [
## Configuración del almacenamiento efímero (consola)
](#configuration-ephemeral-storage-console)
+ [
## Configuración del almacenamiento efímero (AWS CLI)
](#configuration-ephemeral-storage-cli)
+ [
## Configuración del almacenamiento efímero (AWS SAM)
](#configuration-ephemeral-storage-sam)
## Casos de uso habituales para aumentar el almacenamiento efímero
Estos son algunos casos de uso comunes que se benefician del aumento del almacenamiento efímero:
+ **Trabajos de extracción, transformación y carga (ETL):** aumente el almacenamiento efímero cuando el código realice cálculos intermedios o descargue otros recursos para completar el procesamiento. Si se aumenta el espacio temporal, se pueden ejecutar trabajos de ETL más complejos en las funciones de Lambda.
+ **Inferencia de machine learning (ML):** muchas tareas de inferencia se basan en archivos de datos de referencia de gran tamaño, que incluyen bibliotecas y modelos. Con un almacenamiento efímero, puede descargar modelos de mayor tamaño de Amazon Simple Storage Service (Amazon S3) en `/tmp` y utilizarlos en su procesamiento.
+ **Procesamiento de datos:** en el caso de las cargas de trabajo que descargan objetos de Amazon S3 en respuesta a eventos de S3, un mayor espacio de `/tmp` permite gestionar objetos de mayor tamaño sin necesidad de utilizar el procesamiento en memoria. Las cargas de trabajo que crean archivos PDF o procesan contenido multimedia también se benefician de más almacenamiento efímero.
+ **Procesamiento de gráficos:** el procesamiento de imágenes es un caso de uso habitual para las aplicaciones basadas en Lambda. Para las cargas de trabajo que procesan archivos TIFF o imágenes de satélite de gran tamaño, más almacenamiento efímero facilita el uso de bibliotecas y la realización de cálculos en Lambda.
## Configuración del almacenamiento efímero (consola)
Puede configurar el almacenamiento efímero en la consola de Lambda.
**Modificación del almacenamiento efímero de una función**
1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija una función.
1. Seleccione **Configuración** y, a continuación, **Configuración general**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/configuration-tab.png)
1. En **Configuración general**, seleccione la pestaña **Etiquetas**.
1. En **Almacenamiento efímero**, establezca un valor comprendido entre 512 MB y 10 240 MB, en incrementos de 1 MB.
1. Seleccione **Save**.
## Configuración del almacenamiento efímero (AWS CLI)
Puede usar el comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) para configurar el almacenamiento efímero.
**Example**
```
aws lambda update-function-configuration \
--function-name my-function \
--ephemeral-storage '{"Size": 1024}'
```
## Configuración del almacenamiento efímero (AWS SAM)
Puede usar [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) para configurar el almacenamiento efímero de su función. Actualice la propiedad [EphemeralStorage](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-ephemeralstorage) de su archivo `template.yaml` y, a continuación, ejecute [sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html).
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 128
Timeout: 120
Handler: index.handler
Runtime: nodejs22.x
Architectures:
- x86_64
EphemeralStorage:
Size: 10240
# Other function properties...
```
# Configuración y selección de la arquitectura del conjunto de instrucciones para una función de Lambda
La *arquitectura del conjunto de instrucciones* de una función de Lambda determina el tipo de procesador informático que Lambda utiliza para ejecutar la función. Lambda proporciona una variedad de arquitecturas del conjunto de instrucciones:
+ arm64: arquitectura ARM de 64 bits, para el procesador Graviton2 de AWS
+ x86\$164: arquitectura x86 de 64 bits, para procesadores basados en x86
**nota**
La arquitectura arm64 está disponible en la mayoría de Regiones de AWS. Para más información, consulte [Precios de AWS Lambda](https://aws.amazon.com//lambda/pricing/#aws-element-9ccd9262-b656-4d9c-8a72-34ee6b662135). En la tabla de precios de memoria, elija la pestaña **ARM Price** (Precio de ARM) y, a continuación, abra la lista desplegable **Region** (Región) para ver qué Regiones de AWS admiten arm64 con Lambda.
Para obtener un ejemplo de cómo crear una función con arquitectura arm64, consulte [Funciones de AWS Lambda alimentadas por procesadores Graviton2 de AWS](https://aws.amazon.com/blogs/aws/aws-lambda-functions-powered-by-aws-graviton2-processor-run-your-functions-on-arm-and-get-up-to-34-better-price-performance/).
**Topics**
+ [
## Ventajas del uso de la arquitectura arm64
](#foundation-arch-adv)
+ [
## Requisitos para migrar a la arquitectura arm64
](#foundation-arch-consider)
+ [
## Compatibilidad de código de función con la arquitectura arm64
](#foundation-arch-considerations)
+ [
## Cómo migrar a la arquitectura arm64
](#foundation-arch-steps)
+ [
## Configuración de la arquitectura del conjunto de instrucciones
](#foundation-arch-config)
## Ventajas del uso de la arquitectura arm64
Las funciones de Lambda que utilizan arquitectura arm64 (Procesador Graviton2 de AWS) pueden lograr un precio y un rendimiento significativamente mejores que la función equivalente que se ejecuta en la arquitectura x86\$164. Considere el uso de arm64 para aplicaciones de uso intensivo de informática, como la informática de alto rendimiento, la codificación de video y las cargas de trabajo de simulación.
La CPU Graviton2 utiliza el núcleo Neoverse N1 y admite Armv8.2 (incluidas las extensiones CRC y criptográficas) además de varias otras extensiones de arquitectura.
Graviton2 reduce el tiempo de lectura de la memoria mediante una caché L2 más grande por vCPU, lo que mejora el rendimiento de latencia de los backends web y móviles, los microservicios y los sistemas de procesamiento de datos. Graviton2 también proporciona un rendimiento de cifrado mejorado y admite conjuntos de instrucciones que mejoran la latencia de la inferencia de machine learning basada en CPU.
Para obtener más información acerca de Graviton2 de AWS, consulte [Procesador Graviton de AWS](https://aws.amazon.com/ec2/graviton).
## Requisitos para migrar a la arquitectura arm64
Cuando selecciona una función de Lambda para migrar a la arquitectura arm64, para garantizar una migración fluida, asegúrese de que la función cumple los siguientes requisitos:
+ El paquete de implementación contiene solo componentes de código abierto y código fuente que usted controla, para que pueda realizar las actualizaciones necesarias para la migración.
+ Si el código de función incluye dependencias de terceros, cada biblioteca o paquete proporciona una versión de arm64.
## Compatibilidad de código de función con la arquitectura arm64
El código de función de Lambda debe ser compatible con la arquitectura del conjunto de instrucciones de la función. Antes de migrar una función a una arquitectura arm64, tenga en cuenta los siguientes aspectos sobre el código de función actual:
+ Si agregó el código de función mediante el editor de código integrado, es probable que el código se ejecute en cualquiera de las arquitecturas sin modificaciones.
+ Si cargó su código de función, debe cargar un código nuevo que sea compatible con la arquitectura de destino.
+ Si la función utiliza capas, debe [verificar cada capa](adding-layers.md#finding-layer-information) para asegurarse de que sea compatible con la arquitectura nueva. Si una capa no es compatible, edite la función para reemplazar la versión de la capa actual por una versión de la capa compatible.
+ Si la función utiliza extensiones de Lambda, debe verificar cada extensión para asegurarse de que sea compatible con la arquitectura nueva.
+ Si la función utiliza un tipo de paquete de implementación de imágenes de contenedor, debe crear una imagen de contenedor nueva que sea compatible con la arquitectura de la función.
## Cómo migrar a la arquitectura arm64
Para migrar una función de Lambda a la arquitectura arm64, le recomendamos que siga los pasos a continuación:
1. Cree la lista de dependencias para su aplicación o carga de trabajo. Las dependencias frecuentes incluyen lo siguiente:
+ todas las bibliotecas y todos los paquetes que utiliza la función
+ las herramientas que utiliza para crear, implementar y probar la función, como los compiladores, los conjuntos de pruebas, las canalizaciones de integración continua y entrega continua (CI/CD), las herramientas de aprovisionamiento y los scripts
+ las extensiones de Lambda y las herramientas de terceros que utiliza para monitorear la función en producción
1. Para cada una de las dependencias, verifique la versión y, luego, verifique si hay versiones arm64 disponibles.
1. Cree un entorno para migrar su aplicación.
1. Arranque la aplicación.
1. Pruebe y depure la aplicación.
1. Pruebe el rendimiento de la función arm64. Compare el rendimiento con la versión x86\$164.
1. Actualice la canalización de su infraestructura para admitir las funciones de Lambda de arm64.
1. Organice la implementación en producción.
Por ejemplo, utilice la [configuración de enrutamiento de alias](configuring-alias-routing.md) para dividir el tráfico entre las versiones x86 y arm64 de la función y comparar el rendimiento y la latencia.
Para obtener más información acerca de cómo crear un entorno de código para la arquitectura arm64, incluida información específica del lenguaje para Java, Go, .NET y Python, consulte el repositorio de GitHub [Introducción a Graviton de AWS](https://github.com/aws/aws-graviton-getting-started).
## Configuración de la arquitectura del conjunto de instrucciones
Puede configurar la arquitectura del conjunto de instrucciones para las funciones de Lambda nuevas y existentes mediante la consola de Lambda, los AWS SDK, la AWS Command Line Interface (AWS CLI) o CloudFormation. Siga estos pasos para cambiar la arquitectura del conjunto de instrucciones para una función de Lambda existente desde la consola.
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija el nombre de la función para la que desea configurar la arquitectura del conjunto de instrucciones.
1. En la pestaña **Código** principal, en la sección **Configuración del tiempo de ejecución**, seleccione **Editar**.
1. En **Arquitectura**, elija la arquitectura del conjunto de instrucciones que quiere que utilice la función.
1. Seleccione **Save**.
# Configuración del tiempo de espera de la función de Lambda
Lambda ejecuta el código durante un período de tiempo determinado antes de que se agote el tiempo de espera. El *tiempo de espera* es la cantidad máxima de tiempo en segundos que una función de Lambda puede ejecutarse. El valor predeterminado de esta configuración es de 3 segundos, pero puede ajustarlo en incrementos de 1 segundo hasta un valor máximo de 900 segundos (15 minutos).
En esta página se describe cómo y cuándo actualizar la configuración de tiempo de espera de una función de Lambda.
**Topics**
+ [
## Determinación del valor de tiempo de espera adecuado de una función de Lambda
](#configuration-timeout-use-cases)
+ [
## Configuración del tiempo de espera (consola)
](#configuration-timeout-console)
+ [
## Configuración del tiempo de espera (AWS CLI)
](#configuration-timeout-cli)
+ [
## Configuración del tiempo de espera (AWS SAM)
](#configuration-timeout-sam)
## Determinación del valor de tiempo de espera adecuado de una función de Lambda
Si el valor del tiempo de espera se acerca a la duración media de una función, existe un mayor riesgo de que se agote el tiempo de espera de la función inesperadamente. La duración de una función puede variar en función de la cantidad de datos transferidos y procesados y de la latencia de cualquier servicio con el que interactúe la función. Algunas de las causas más comunes del tiempo de espera agotado son las siguientes:
+ Las descargas desde Amazon Simple Storage Service (Amazon S3) son más grandes o tardan más que la media.
+ Una función realiza una solicitud a otro servicio, lo que aumenta el tiempo de respuesta.
+ Los parámetros proporcionados a una función requieren una mayor complejidad computacional en la función, lo que hace que la invocación tarde más tiempo.
Al probar la aplicación, asegúrese de que las pruebas reflejen con precisión el tamaño y la cantidad de datos y de que los valores de los parámetros sean realistas. Las pruebas suelen utilizar muestras pequeñas por motivos de comodidad, pero debe utilizar conjuntos de datos que se sitúen en el límite superior de lo que cabe esperar razonablemente para su carga de trabajo.
## Configuración del tiempo de espera (consola)
Se puede configurar el tiempo de espera de la función en la consola de Lambda.
**Modificación del tiempo de espera de una función**
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija una función.
1. Seleccione **Configuración** y, a continuación, **Configuración general**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/configuration-tab.png)
1. En **Configuración general**, seleccione la pestaña **Etiquetas**.
1. En **Tiempo de espera**, establezca un valor comprendido entre 1 y 900 segundos (15 minutos).
1. Seleccione **Save**.
## Configuración del tiempo de espera (AWS CLI)
Puede usar el comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) para configurar el valor del tiempo de espera, en segundos. El siguiente comando de ejemplo aumenta el tiempo de espera de la función a 120 segundos (2 minutos).
**Example**
```
aws lambda update-function-configuration \
--function-name my-function \
--timeout 120
```
## Configuración del tiempo de espera (AWS SAM)
Puede usar [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) para configurar el valor de tiempo de espera de su función. Actualice la propiedad [Timeout](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-timeout) de su archivo `template.yaml` y, a continuación, ejecute [sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html).
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 128
Timeout: 120
# Other function properties...
```
# Configuración de las funciones duraderas de Lambda
Para habilitar una ejecución duradera de la función de Lambda, debe configurar ajustes específicos que controlen cuánto tiempo puede ejecutarse la función, cuánto tiempo se retienen los datos de estado y qué permisos se requieren.
## Habilitación de la ejecución duradera
Para habilitar la ejecución duradera de la función de Lambda, configúrela en `DurableConfig` en la configuración de la función. Esta configuración controla el tiempo de espera de la ejecución, la retención del estado y el comportamiento del control de versiones.
------
#### [ AWS CLI ]
```
aws lambda update-function-configuration \
--function-name my-durable-function \
--durable-config '{
"ExecutionTimeout": 3600,
"RetentionPeriodInDays": 30,
"AllowInvokeLatest": true
}'
```
------
#### [ CloudFormation ]
```
Resources:
MyDurableFunction:
Type: AWS::Lambda::Function
Properties:
FunctionName: my-durable-function
Runtime: nodejs18.x
Handler: index.handler
Code:
ZipFile: |
// Your durable function code
DurableConfig:
ExecutionTimeout: 3600
RetentionPeriodInDays: 30
AllowInvokeLatest: true
```
------
**Parámetros de configuración:**
+ `ExecutionTimeout`: tiempo máximo de ejecución en segundos (hasta 31 536 000 en 1 año)
+ `RetentionPeriodInDays`: cuánto tiempo se retendrá el estado y el historial de ejecución (de 1 a 365 días)
+ `AllowInvokeLatest`: si se debe permitir la invocación de la versión \$1LATEST para una ejecución duradera.
## Permisos de IAM para funciones duraderas
Las funciones duraderas requieren permisos de IAM adicionales a los de los roles de ejecución estándar de Lambda. El rol de ejecución de la función debe incluir permisos de administración de estados y ejecución duradera para las API.
**Permisos mínimos necesarios:**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction",
"lambda:GetFunction",
"lambda:ManageDurableState",
"lambda:GetDurableExecution",
"lambda:ListDurableExecutions"
],
"Resource": "arn:aws:lambda:*:*:function:*"
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:*"
}
]
}
```
**Ejemplo de rol de ejecución de CloudFormation:**
```
DurableFunctionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: sts:AssumeRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Policies:
- PolicyName: DurableFunctionPolicy
PolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Action:
- lambda:ManageDurableState
- lambda:GetDurableExecution
- lambda:ListDurableExecutions
Resource: '*'
```
## Prácticas recomendadas de configuración
Siga estas prácticas recomendadas cuando configure funciones duraderas para uso en producción:
+ **Establezca los tiempos de espera de ejecución adecuados**: configure `ExecutionTimeout` en función de la duración máxima esperada de su flujo de trabajo. No establezca tiempos de espera innecesariamente prolongados, ya que afectan la asignación de costos y recursos.
+ **Equilibre la retención con los costos de almacenamiento**: configure `RetentionPeriodInDays` en función de sus requisitos de depuración y auditoría. Los períodos de retención más prolongados aumentan los costos de almacenamiento.
+ **Utilice el control de versiones en producción**: configure `AllowInvokeLatest` en `false` en entornos de producción y utilice versiones o alias de funciones específicas para lograr ejecuciones duraderas.
+ **Supervise el tamaño del estado**: los objetos de estado grandes aumentan los costos de almacenamiento y pueden afectar el rendimiento. Mantenga el estado mínimo y utilice almacenamiento externo para datos de gran tamaño.
+ **Configure el registro adecuado**: habilite el registro detallado para solucionar problemas de flujos de trabajo de larga duración, pero tenga en cuenta el volumen y los costos del registro.
**Ejemplo de configuración de producción:**
```
{
"ExecutionTimeout": 86400,
"RetentionPeriodInDays": 7,
"AllowInvokeLatest": false
}
```
# Trabajar con variables de entorno de Lambda
Puede usar variables de entorno para ajustar el comportamiento de su función sin actualizar el código. Una variable de entorno es un par de cadenas almacenadas en la configuración específica de la versión de una función. El tiempo de ejecución de Lambda hace que las variables de entorno estén disponibles para el código y establece variables de entorno adicionales que contienen información sobre la función y la solicitud de invocación.
**nota**
Para aumentar la seguridad, se recomienda utilizar AWS Secrets Manager en lugar de variables de entorno para almacenar las credenciales de la base de datos y otra información confidencial, como claves de API o tokens de autorización. Para obtener más información, consulte [Uso de secretos de Secrets Manager en Funciones de Lambda](with-secrets-manager.md).
Las variables de entorno no se evalúan antes de la invocación de la función. Cualquier valor que defina se considera una cadena literal y no expandida. Evalúe las variables en el código de la función.
## Crear variables de entorno de Lambda
Puede configurar las variables de entorno en Lambda mediante la consola de Lambda, la AWS Command Line Interface (AWS CLI), AWS Serverless Application Model (AWS SAM) o con un AWS SDK.
------
#### [ Console ]
Las variables de entorno se definen en la versión no publicada de la función. Al publicar una versión, las variables de entorno se bloquean para esa versión junto con otra [configuración específica de la versión](configuration-versions.md).
Puede crear una variable de entorno para su función al definir una clave y un valor. Su función utiliza el nombre de la clave para recuperar el valor de la variable de entorno.
**Para establecer variables de entorno en la consola de Lambda**
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija una función.
1. Elija la pestaña **Configuración** y, a continuación, elija **Variables de entorno**.
1. En **Variables de entorno**, elija **Editar**.
1. Elija **Add environment variable** (Añadir variable de entorno).
1. Introduzca una clave y un valor.
**Requisitos**
+ Las claves comienzan con una letra y tienen como mínimo dos caracteres.
+ Las claves solo contienen letras, números y guiones bajos (`_`).
+ Las llaves no están [reservadas por Lambda](#configuration-envvars-runtime).
+ El tamaño total de todas las variables de entorno no supera los 4 KB.
1. Seleccione **Save**.
**Para generar una lista de variables de entorno en el editor de código de la consola**
Puede generar una lista de variables de entorno en el editor de código de Lambda. Esta es una forma rápida de hacer referencia a las variables de entorno mientras se codifica.
1. Elija la pestaña **Código**.
1. Desplácese hacia abajo hasta la sección **VARIABLES DE ENTORNO** del editor de código. Las variables de entorno existentes se muestran aquí:
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/env-var.png)
1. Para crear nuevas variables de entorno, elija el signo más (![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/add-plus.png)):
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/create-env-var.png)
Las variables de entorno permanecen cifradas cuando aparecen en el editor de código de la consola. Si habilitó los ayudantes de cifrado para el cifrado en tránsito, esa configuración permanecerá sin cambios. Para obtener más información, consulte [Asegurar las variables de entorno Lambda](configuration-envvars-encryption.md).
La lista de variables de entorno es de solo lectura y de uso exclusivo en la consola de Lambda. Este archivo no se incluye al descargar el archivo .zip de la función y no puede agregar variables de entorno al cargar este archivo.
------
#### [ AWS CLI ]
En el ejemplo siguiente se establecen dos variables de entorno en una función denominada `my-function`.
```
aws lambda update-function-configuration \
--function-name my-function \
--environment "Variables={BUCKET=amzn-s3-demo-bucket,KEY=file.txt}"
```
Cuando se aplican variables de entorno con el comando `update-function-configuration`, se remplaza todo el contenido de la `Variables` estructura. Para conservar las variables de entorno existentes al agregar una nueva, incluya todos los valores existentes en la solicitud.
Para obtener la configuración actual, use el comando `get-function-configuration`.
```
aws lambda get-function-configuration \
--function-name my-function
```
Debería ver los siguientes datos de salida:
```
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:111122223333:function:my-function",
"Runtime": "nodejs24.x",
"Role": "arn:aws:iam::111122223333:role/lambda-role",
"Environment": {
"Variables": {
"BUCKET": "amzn-s3-demo-bucket",
"KEY": "file.txt"
}
},
"RevisionId": "0894d3c1-2a3d-4d48-bf7f-abade99f3c15",
...
}
```
Puede pasar el ID de revisión de la salida de `get-function-configuration` como parámetro a `update-function-configuration`. Esto garantiza que los valores no cambien entre el momento en que lee la configuración y el momento en que la actualiza.
Para configurar la clave de cifrado de una función, establezca la opción `KMSKeyARN`.
```
aws lambda update-function-configuration \
--function-name my-function \
--kms-key-arn arn:aws:kms:us-east-2:111122223333:key/055efbb4-xmpl-4336-ba9c-538c7d31f599
```
------
#### [ AWS SAM ]
Puede utilizar [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) para configurar las variables de entorno de la función. Actualice las propiedades [Environment](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-environment) y [Variables](https://docs.aws.amazon.com//AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-environment.html#cfn-lambda-function-environment-variables) del archivo `template.yaml` y, a continuación, ejecute [sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html).
**Example template.yaml**
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: An AWS Serverless Application Model template describing your function.
Resources:
my-function:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Description: ''
MemorySize: 128
Timeout: 120
Handler: index.handler
Runtime: nodejs24.x
Architectures:
- x86_64
EphemeralStorage:
Size: 10240
Environment:
Variables:
BUCKET: amzn-s3-demo-bucket
KEY: file.txt
# Other function properties...
```
------
#### [ AWS SDKs ]
Para administrar variables de entorno con un SDK de AWS, utilice las siguientes operaciones de la API.
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
Para obtener más información, consulte la [documentación del SDK de AWS](https://aws.amazon.com/developer/tools/) para el lenguaje de programación preferido.
------
## Escenario de ejemplo para variables de entorno
Puede usar variables de entorno para personalizar el comportamiento de la función en su entorno de prueba y entorno de producción. Por ejemplo, puede crear dos funciones con el mismo código pero con configuración diferente. Una función se conecta a una base de datos de prueba y la otra se conecta a una base de datos de producción. En esta situación, utiliza variables de entorno para pasar el nombre de host y otros detalles de conexión de la base de datos a la función.
En el ejemplo siguiente se muestra cómo definir el host de base de datos y el nombre de base de datos como variables de entorno.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/console-env.png)
Si desea que su entorno de prueba genere más información de depuración que el entorno de producción, puede establecer una variable de entorno para configurar su entorno de prueba para utilizar un registro más detallado o un seguimiento más detallado.
Por ejemplo, en su entorno de prueba, puede establecer una variable de entorno con la clave `LOG_LEVEL` y un valor que indique un nivel de registro de depuración o rastreo. En el código de la función de Lambda, puede utilizar esta variable de entorno para establecer el nivel de registro.
Los siguientes ejemplos de código en Python y Node.js ilustran cómo puede hacerlo. En estos ejemplos se supone que la variable de entorno tiene un valor de `DEBUG` en Python o `debug` en Node.js.
------
#### [ Python ]
**Example Código de Python para establecer el nivel de registro**
```
import os
import logging
# Initialize the logger
logger = logging.getLogger()
# Get the log level from the environment variable and default to INFO if not set
log_level = os.environ.get('LOG_LEVEL', 'INFO')
# Set the log level
logger.setLevel(log_level)
def lambda_handler(event, context):
# Produce some example log outputs
logger.debug('This is a log with detailed debug information - shown only in test environment')
logger.info('This is a log with standard information - shown in production and test environments')
```
------
#### [ Node.js (ES module format) ]
**Example Código de Node.js para establecer el nivel de registro**
En este ejemplo se utiliza la biblioteca de registro de `winston`. Use npm para agregar esta biblioteca al paquete de implementación de la función. Para obtener más información, consulte [Creación de un paquete de despliegue .zip con dependencias](nodejs-package.md#nodejs-package-create-dependencies).
```
import winston from 'winston';
// Initialize the logger using the log level from environment variables, defaulting to INFO if not set
const logger = winston.createLogger({
level: process.env.LOG_LEVEL || 'info',
format: winston.format.json(),
transports: [new winston.transports.Console()]
});
export const handler = async (event) => {
// Produce some example log outputs
logger.debug('This is a log with detailed debug information - shown only in test environment');
logger.info('This is a log with standard information - shown in production and test environment');
};
```
------
## Recuperar variables de entorno Lambda
Para recuperar variables de entorno en el código de función, utilice el método estándar para el lenguaje de programación.
------
#### [ Node.js ]
```
let region = process.env.AWS_REGION
```
------
#### [ Python ]
```
import os
region = os.environ['AWS_REGION']
```
**nota**
En algunos casos, es posible que deba usar el siguiente formato:
```
region = os.environ.get('AWS_REGION')
```
------
#### [ Ruby ]
```
region = ENV["AWS_REGION"]
```
------
#### [ Java ]
```
String region = System.getenv("AWS_REGION");
```
------
#### [ Go ]
```
var region = os.Getenv("AWS_REGION")
```
------
#### [ C\$1 ]
```
string region = Environment.GetEnvironmentVariable("AWS_REGION");
```
------
#### [ PowerShell ]
```
$region = $env:AWS_REGION
```
------
Lambda almacena variables de entorno de forma segura cifrándolas en reposo. Puede [configurar Lambda para que utilice una clave de cifrado diferente](configuration-envvars-encryption.md), cifrar valores de variables de entorno del lado del cliente o establezca variables de entorno en una plantilla de CloudFormation con AWS Secrets Manager.
## Variables definidas de entorno de tiempo de ejecución
Los [tiempos de ejecución](lambda-runtimes.md) de Lambda establecen varias variables de entorno durante la inicialización. La mayoría de las variables de entorno proporcionan información sobre la función o el tiempo de ejecución. Las claves para estas variables de entorno están *reservadas* y no se pueden establecer en la configuración de la función.
**Variables de entorno reservadas**
+ `_HANDLER`: la localización del controlador configurada en la función.
+ `_X_AMZN_TRACE_ID`: el [encabezado de rastreo de X-Ray](services-xray.md). Esta variable de entorno cambia con cada invocación.
+ Esta variable de entorno no está definida para los tiempos de ejecución exclusivos del sistema operativo (la familia de tiempos de ejecución `provided`). Puede configurar `_X_AMZN_TRACE_ID` para tiempos de ejecución personalizados mediante el encabezado de respuesta `Lambda-Runtime-Trace-Id` de la [Siguiente invocación](runtimes-api.md#runtimes-api-next).
+ En las versiones 17 y posteriores de Java Runtime no se utiliza esta variable de entorno. En su lugar, Lambda almacena la información de rastreo en la propiedad del sistema `com.amazonaws.xray.traceHeader`.
+ `AWS_DEFAULT_REGION`: la Región de AWS predeterminada donde se ejecuta la función de Lambda.
+ `AWS_REGION`: la Región de AWS donde se ejecuta la función de Lambda. Si se define, este valor anula la `AWS_DEFAULT_REGION`.
+ Para obtener más información sobre cómo usar las variables de entorno de la Región de AWS con los AWS SDK, consulte [Región de AWS](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html#feature-region-sdk-compat) en la *Guía de referencia de las herramientas y los AWS SDK*.
+ `AWS_EXECUTION_ENV`: [identificador del tiempo de ejecución](lambda-runtimes.md), precedido de `AWS_Lambda_` (por ejemplo, `AWS_Lambda_java8`). Esta variable de entorno no está definida para los tiempos de ejecución exclusivos del sistema operativo (la familia de tiempos de ejecución de `provided`).
+ `AWS_LAMBDA_FUNCTION_NAME`: el nombre de la función.
+ `AWS_LAMBDA_FUNCTION_MEMORY_SIZE`: la cantidad de memoria disponible para la función en MB.
+ `AWS_LAMBDA_FUNCTION_VERSION`: la versión de la función que se está ejecutando.
+ `AWS_LAMBDA_INITIALIZATION_TYPE`: el tipo de inicialización de la función, que es `on-demand`, `provisioned-concurrency`, `snap-start` o `lambda-managed-instances`. Para obtener información, consulte [Configuración de concurrencia aprovisionada](provisioned-concurrency.md), [Mejora del rendimiento de inicio con Lambda SnapStart](snapstart.md) o [Instancias administradas de Lambda](lambda-managed-instances.md).
+ `AWS_LAMBDA_LOG_GROUP_NAME`, `AWS_LAMBDA_LOG_STREAM_NAME`: el nombre del grupo de Registros de Amazon CloudWatch y flujo para la función. Las [variables de entorno](#configuration-envvars-runtime) `AWS_LAMBDA_LOG_GROUP_NAME` y `AWS_LAMBDA_LOG_STREAM_NAME` no están disponibles en las funciones de Lambda SnapStart.
+ `AWS_ACCESS_KEY`, `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`: las claves de acceso obtenidas del [rol de ejecución](lambda-intro-execution-role.md) de la función.
+ `AWS_LAMBDA_RUNTIME_API`: ([Tiempo de ejecución personalizado](runtimes-custom.md)) El host y el puerto de la [API de tiempo de ejecución](runtimes-api.md).
+ `LAMBDA_TASK_ROOT`: la ruta al código de la función de Lambda.
+ `LAMBDA_RUNTIME_DIR`: la ruta a las bibliotecas de tiempos de ejecución.
+ `AWS_LAMBDA_MAX_CONCURRENCY`: (solo instancias administradas de Lambda) el número máximo de invocaciones simultáneas que Lambda enviará a un entorno de ejecución.
+ `AWS_LAMBDA_METADATA_API`: la dirección del servidor del [punto de conexión de metadatos](configuration-metadata-endpoint.md) en el formato `{ipv4_address}:{port}` (por ejemplo, `169.254.100.1:9001`).
+ `AWS_LAMBDA_METADATA_TOKEN`: un token de autenticación único para el entorno de ejecución actual que sirve para autenticar solicitudes al [punto de conexión de metadatos](configuration-metadata-endpoint.md). Lambda genera este token automáticamente durante la inicialización.
Las siguientes variables de entorno adicionales no están reservadas y pueden ampliarse en la configuración de la función.
**Variables de entorno sin reserva**
+ `LANG` – configuración regional del tiempo de ejecución (`en_US.UTF-8`).
+ `PATH` – ruta de ejecución (`/usr/local/bin:/usr/bin/:/bin:/opt/bin`).
+ `LD_LIBRARY_PATH` – ruta de la biblioteca del sistema (`/var/lang/lib:/lib64:/usr/lib64:$LAMBDA_RUNTIME_DIR:$LAMBDA_RUNTIME_DIR/lib:$LAMBDA_TASK_ROOT:$LAMBDA_TASK_ROOT/lib:/opt/lib`).
+ `NODE_PATH`: ([Node.js](lambda-nodejs.md)) La ruta de la biblioteca Node.js (`/opt/nodejs/node12/node_modules/:/opt/nodejs/node_modules:$LAMBDA_RUNTIME_DIR/node_modules`).
+ `NODE_OPTIONS`: ([Node.js](lambda-nodejs.md)) en los tiempos de ejecución de Node.js, puede utilizar `NODE_OPTIONS` para volver a habilitar las características experimentales que Lambda desactiva por defecto.
+ `PYTHONPATH`: ([Python](lambda-python.md)) la ruta de la biblioteca de Python (`$LAMBDA_RUNTIME_DIR`).
+ `GEM_PATH`: ([Ruby](lambda-ruby.md)) La ruta de la biblioteca Ruby (`$LAMBDA_TASK_ROOT/vendor/bundle/ruby/3.3.0:/opt/ruby/gems/3.3.0`).
+ `AWS_XRAY_CONTEXT_MISSING`: para el seguimiento de X-Ray, Lambda establece esto en `LOG_ERROR` para evitar arrojar errores de tiempo de ejecución desde el SDK de X-Ray.
+ `AWS_XRAY_DAEMON_ADDRESS`: para el rastreo de X-Ray, la dirección IP y el puerto del daemon de X-Ray.
+ `AWS_LAMBDA_DOTNET_PREJIT`: ([.NET](lambda-csharp.md)) establezca esta variable para habilitar o deshabilitar optimizaciones específicas de tiempo de ejecución de .NET. Los valores incluyen `always`, `never`, y `provisioned-concurrency`. Para obtener más información, consulte [Configuración de simultaneidad aprovisionada para una función](provisioned-concurrency.md).
+ `TZ` – la zona horaria del entorno (`:UTC`). El entorno de ejecución utiliza NTP para sincronizar el reloj del sistema.
Los valores de muestra presentados reflejan los últimos tiempos de ejecución. La presencia de variables específicas o sus valores pueden variar en tiempos de ejecución anteriores.
# Asegurar las variables de entorno Lambda
A fin de proteger las variables de entorno, puede utilizar el cifrado en el servidor para proteger los datos en reposo y el cifrado del lado del cliente para proteger los datos en tránsito.
**nota**
Para aumentar la seguridad de la base de datos, se recomienda utilizar AWS Secrets Manager en lugar de variables de entorno para almacenar las credenciales de la base de datos. Para obtener más información, consulte [Uso de secretos de Secrets Manager en Funciones de Lambda](with-secrets-manager.md).
**Seguridad en reposo**
Lambda siempre proporciona cifrado en el servidor en reposo con una AWS KMS key. De forma predeterminada, Lambda utiliza una Clave administrada de AWS. Si este comportamiento predeterminado se ajusta a su flujo de trabajo, no tiene que configurar nada más. Lambda crea la Clave administrada de AWS en su cuenta y administra los permisos por usted. AWS no cobra por usar esta clave.
Si lo prefiere, puede proporcionar una clave administrada por el cliente de AWS KMS en su lugar. Puede hacerlo para tener control sobre la rotación de la clave de KMS o para cumplir con los requisitos de su organización para administrar claves de KMS. Cuando usa una clave administrada por el usuario, solo los usuarios de su cuenta con acceso a la clave de KMS pueden ver o administrar las variables de entorno de la función.
Las claves administradas por el cliente ocasionan cargos de AWS KMS estándar. Para más información, consulte [Precios de AWS Key Management Service](https://aws.amazon.com/kms/pricing/).
**Seguridad en tránsito**
Para mayor seguridad, puede habilitar las funciones auxiliares del cifrado en tránsito, de modo que garantiza que las variables de entorno se cifren en el lado del cliente para su protección en tránsito.
**Configuración del cifrado de las variables de entorno**
1. Use AWS Key Management Service (AWS KMS) a fin de crear claves administradas por el cliente para que Lambda las utilice para el cifrado del lado del cliente y del servidor. Para obtener más información, consulte [Creación de claves](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) en la *Guía para desarrolladores de AWS Key Management Service*.
1. Mediante la consola de Lambda, vaya a la página **Editar variables de entorno**.
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija una función.
1. Elija **Configuración** y, a continuación, elija **Variables de entorno** en la barra de navegación izquierda.
1. En la sección **Variables de entorno**, elija **Editar**.
1. Expanda **Configuración de cifrado**.
1. (Opcional) Habilite las funciones auxiliares de cifrado de la consola para que utilicen el cifrado del cliente a fin de proteger los datos en tránsito.
1. En **Cifrado en tránsito**, elija **Activar funciones auxiliares para el cifrado en tránsito**.
1. Para cada variable de entorno para la que desee habilitar las funciones auxiliares de cifrado de la consola, elija **Cifrar** junto a la variable de entorno.
1. En la AWS KMS key para el cifrado en tránsito, elija una clave administrada por el cliente que haya creado al principio de este procedimiento.
1. Elija **Política de rol de ejecución** y copie la política. Esta política concede permiso al rol de ejecución de la función para descifrar las variables de entorno.
Guarde esta política para usarla en el último paso de este procedimiento.
1. Agregue el código a la función que descifre las variables de entorno. Para ver un ejemplo, elija **Fragmento para descifrar secretos**.
1. (Opcional) Especifique su clave administrada por el cliente para el cifrado en reposo.
1. Elija **Use una clave maestra del cliente**.
1. Elija una clave administrada por el cliente que haya creado al principio de este procedimiento.
1. Seleccione **Save**.
1. Configure los permisos.
Si está utilizando una clave administrada por el cliente con cifrado en el servidor, conceda permisos a cualquier usuario o rol que desee que pueda ver o administrar variables de entorno en la función. Para obtener más información, consulte [Administración de permisos para la clave de KMS de cifrado en el servidor](#managing-permissions-to-your-server-side-encryption-key).
Si habilita el cifrado del lado del cliente para la seguridad en tránsito, su función necesita permiso para llamar a la operación de la API `kms:Decrypt`. Agregue la política que guardó anteriormente en este procedimiento al [rol de ejecución](lambda-intro-execution-role.md) de la función.
## Administración de permisos para la clave de KMS de cifrado en el servidor
No se requieren permisos de AWS KMS para el usuario o el rol de ejecución de la función para utilizar la clave de cifrado predeterminada. Para utilizar una clave administrada por el cliente, necesita permisos de uso de la clave. Lambda usa sus permisos para crear una concesión en la clave. Esto permite a Lambda usarlo para el cifrado.
+ `kms:ListAliases`: para ver las teclas en la consola de Lambda.
+ `kms:CreateGrant`, `kms:Encrypt`: para configurar una clave administrada por el cliente en una función.
+ `kms:Decrypt`: para ver y administrar variables de entorno cifradas con una clave administrada por el cliente.
Puede obtener estos permisos de su Cuenta de AWS o de la política de permisos basada en recursos de una clave. `ListAliases` surge de las [políticas administradas en Lambda](access-control-identity-based.md). Las políticas clave conceden los permisos restantes a los usuarios del grupo **Usuarios clave** .
Los usuarios sin permisos `Decrypt` todavía pueden administrar funciones, pero no pueden ver variables de entorno ni administrarlas en la consola de Lambda. Para evitar que un usuario vea variables de entorno, añada una instrucción a los permisos del usuario que deniegue el acceso a la clave predeterminada, a una clave administrada por el cliente o a todas las claves.
**Example Política de IAM: denegar acceso por ARN de clave**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Deny",
"Action": [
"kms:Decrypt"
],
"Resource": "arn:aws:kms:us-east-2:111122223333:key/3be10e2d-xmpl-4be4-bc9d-0405a71945cc"
}
]
}
```
Para obtener información detallada sobre la administración de permisos de clave, consulte [Uso de políticas de claves en AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) en la *Guía para desarrolladores de AWS Key Management Service*.
# Otorgamiento a las funciones de Lambda de acceso a los recursos de una Amazon VPC
Con Amazon Virtual Private Cloud (Amazon VPC), usted puede crear redes privadas en su Cuenta de AWS para alojar recursos, como por ejemplo instancias de Amazon Elastic Compute Cloud (Amazon EC2), instancias de Amazon Relational Database Service (Amazon RDS) e instancias de Amazon ElastiCache. Puede conceder a su función de Lambda acceso a los recursos alojados en una Amazon VPC al adjuntar su función a la VPC a través de las subredes privadas que contienen los recursos. Siga las instrucciones de las siguientes secciones para adjuntar una función de Lambda a una Amazon VPC mediante la consola de Lambda, la AWS Command Line Interface (AWS CLI) o el AWS SAM.
**nota**
Cada función de Lambda se ejecuta dentro de una VPC que pertenece y es administrada por el servicio Lambda. Lambda gestiona automáticamente estas VPC y no se encuentran visibles para los clientes. La configuración de la función para acceder a otros recursos de AWS en una Amazon VPC no afecta a la VPC gestionada por Lambda en la que se ejecuta la función.
**Topics**
+ [
## Permisos de IAM necesarios
](#configuration-vpc-permissions)
+ [
## Conexión de las funciones de Lambda a una Amazon VPC en su Cuenta de AWS
](#configuration-vpc-attaching)
+ [
## Acceso a Internet cuando está conectado a una VPC
](#configuration-vpc-internet-access)
+ [
## Compatibilidad con IPv6
](#configuration-vpc-ipv6)
+ [
## Prácticas recomendadas para utilizar Lambda con Amazon VPC
](#configuration-vpc-best-practice)
+ [
## Introducción a las interfaces de red elástica (ENI) de hiperplano
](#configuration-vpc-enis)
+ [
## Uso de claves de condición de IAM para la configuración de la VPC
](#vpc-conditions)
+ [
## Tutoriales de VPC
](#vpc-tutorials)
## Permisos de IAM necesarios
Para adjuntar una función de Lambda a una Amazon VPC en su Cuenta de AWS, Lambda necesita permisos para crear y administrar las interfaces de red que utiliza para que su función acceda a los recursos de la VPC.
Las interfaces de red que Lambda crea se conocen como interfaces de red elásticas de hiperplano o ENI de hiperplano. Para obtener más información acerca de estas interfaces de red, consulte [Introducción a las interfaces de red elástica (ENI) de hiperplano](#configuration-vpc-enis).
Puede conceder a la función los permisos que necesita al adjuntar la política administrada de AWS [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) al rol de ejecución de la función. Cuando crea una función nueva en la consola de Lambda y la conecta a una VPC, Lambda añade automáticamente esta política de permisos.
Si prefiere crear su propia política de permisos de IAM, asegúrese de agregar los siguientes permisos y permitirlos en todos los recursos (`"Resource": "*"`):
+ ec2:CreateNetworkInterface
+ ec2:DescribeNetworkInterfaces
+ ec2:DescribeSubnets
+ ec2:DeleteNetworkInterface
+ ec2:AssignPrivateIpAddresses
+ ec2:UnassignPrivateIpAddresses
Tenga en cuenta que el rol de su función solo necesita estos permisos para crear las interfaces de red, no para invocar su función. Puede invocar correctamente la función cuando está conectada a una Amazon VPC, incluso si elimina estos permisos del rol de ejecución de la función.
Para adjuntar la función a una VPC, Lambda también necesita verificar los recursos de la red mediante su rol de usuario de IAM. Asegúrese de que su rol de usuario tenga los siguientes permisos de IAM:
+ **ec2:DescribeSecurityGroups**
+ **ec2:DescribeSubnets**
+ **ec2:DescribeVpcs**
+ **ec2:GetSecurityGroupsForVpc**
**nota**
El servicio de Lambda utiliza los permisos de Amazon EC2 que concede al rol de ejecución de la función para adjuntar la función a una VPC. Sin embargo, estos permisos también se otorgan implícitamente al código de la función. Esto significa que su código de función puede realizar estas llamadas a la API de Amazon EC2. Para obtener consejos sobre prácticas recomendadas de seguridad, consulte [Prácticas recomendadas de seguridad](#configuration-vpc-best-practice-security).
## Conexión de las funciones de Lambda a una Amazon VPC en su Cuenta de AWS
Adjunte su función a una Amazon VPC en su Cuenta de AWS mediante la consola de Lambda, la AWS CLI o el AWS SAM. Si utiliza AWS CLI o AWS SAM, o si adjunta una función existente a una VPC mediante la consola de Lambda, asegúrese de que el rol de ejecución de la función tenga los permisos necesarios que se indican en la sección anterior.
Las funciones Lambda no pueden conectarse directamente a una VPC con [tenencia de instancias dedicada](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-instance.html). Para conectarse a los recursos de una VPC dedicada, [interconéctela con una segunda VPC con tenencia predeterminada](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-dedicated-vpc/).
------
#### [ Lambda console ]
**Cómo adjuntar una función a una Amazon VPC al crearla**
1. Abra la página [Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda y elija **Crear función**.
1. En **Basic information (Información básica)**, para **Function name (Nombre de función)**, escriba un nombre para la función.
1. Para configurar los ajustes de la VPC para la función, haga lo siguiente:
1. Amplíe **Configuración avanzada**.
1. Seleccione **Habilitar VPC** y, a continuación, elija la VPC a la que desea adjuntar la función.
1. (Opcional) Para permitir el [tráfico IPv6 saliente](#configuration-vpc-ipv6), seleccione **Permitir tráfico IPv6 para subredes de doble pila**.
1. Elija las subredes y los grupos de seguridad para crear la interfaz de red. Si seleccionó **Permitir tráfico IPv6 para subredes de pila doble**, todas las subredes seleccionadas deben tener un bloque de CIDR IPv4 y un bloque de CIDR IPv6.
**nota**
Para acceder a recursos privados, conecte la función a subredes privadas. Si la función necesita acceso a Internet, consulte [Habilitación del acceso a Internet para funciones de Lambda conectadas a VPC](configuration-vpc-internet.md). La conexión de una función a una subred pública no le concede acceso a Internet ni una dirección IP pública.
1. Seleccione **Creación de función**.
**Cómo adjuntar una función existente a una Amazon VPC**
1. Abra la [página Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda y seleccione su función.
1. Elija la pestaña **Configuración** y, a continuación, elija **VPC**.
1. Elija **Edit (Edición de)**.
1. En **VPC**, seleccione la Amazon VPC a la que quiera adjuntar su función.
1. (Opcional) Para permitir el [tráfico IPv6 saliente](#configuration-vpc-ipv6), seleccione **Permitir tráfico IPv6 para subredes de doble pila**.
1. Elija las subredes y los grupos de seguridad para crear la interfaz de red. Si seleccionó **Permitir tráfico IPv6 para subredes de pila doble**, todas las subredes seleccionadas deben tener un bloque de CIDR IPv4 y un bloque de CIDR IPv6.
**nota**
Para acceder a recursos privados, conecte la función a subredes privadas. Si la función necesita acceso a Internet, consulte [Habilitación del acceso a Internet para funciones de Lambda conectadas a VPC](configuration-vpc-internet.md). La conexión de una función a una subred pública no le concede acceso a Internet ni una dirección IP pública.
1. Seleccione **Save**.
------
#### [ AWS CLI ]
**Cómo adjuntar una función a una Amazon VPC al crearla**
+ Para crear una función de Lambda y asociarla a una VPC, ejecute el siguiente comando de CLI `create-function`.
```
aws lambda create-function --function-name my-function \
--runtime nodejs24.x --handler index.js --zip-file fileb://function.zip \
--role arn:aws:iam::123456789012:role/lambda-role \
--vpc-config Ipv6AllowedForDualStack=true,SubnetIds=subnet-071f712345678e7c8,subnet-07fd123456788a036,SecurityGroupIds=sg-085912345678492fb
```
Especifique sus propias subredes y grupos de seguridad y configure `Ipv6AllowedForDualStack` a `true` o `false` según su caso de uso.
**Cómo adjuntar una función existente a una Amazon VPC**
+ Para asociar una función existente a una VPC, ejecute el siguiente comando de CLI `update-function-configuration`.
```
aws lambda update-function-configuration --function-name my-function \
--vpc-config Ipv6AllowedForDualStack=true, SubnetIds=subnet-071f712345678e7c8,subnet-07fd123456788a036,SecurityGroupIds=sg-085912345678492fb
```
**Cómo desvincular la función de una VPC**
+ Para desvincular la función de una VPC, ejecute el siguiente comando de CLI `update-function-configuration` con una lista vacía de subredes y grupos de seguridad de la VPC.
```
aws lambda update-function-configuration --function-name my-function \
--vpc-config SubnetIds=[],SecurityGroupIds=[]
```
------
#### [ AWS SAM ]
**Cómo adjuntar la función a una VPC**
+ Para adjuntar una función de Lambda a una VPC de Amazon, añada la propiedad `VpcConfig` a la definición de la función, tal y como se muestra en la siguiente plantilla de ejemplo. Para obtener más información sobre esta propiedad, consulte [::Lambda::Function VpcConfig de AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-vpcconfig.html) en la *Guía del usuario de CloudFormation* (la propiedad `VpcConfig` de AWS SAM se pasa directamente a la propiedad `VpcConfig` de un recurso de CloudFormation `AWS::Lambda::Function`).
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./lambda_function/
Handler: lambda_function.handler
Runtime: python3.12
VpcConfig:
SecurityGroupIds:
- !Ref MySecurityGroup
SubnetIds:
- !Ref MySubnet1
- !Ref MySubnet2
Policies:
- AWSLambdaVPCAccessExecutionRole
MySecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: Security group for Lambda function
VpcId: !Ref MyVPC
MySubnet1:
Type: AWS::EC2::Subnet
Properties:
VpcId: !Ref MyVPC
CidrBlock: 10.0.1.0/24
MySubnet2:
Type: AWS::EC2::Subnet
Properties:
VpcId: !Ref MyVPC
CidrBlock: 10.0.2.0/24
MyVPC:
Type: AWS::EC2::VPC
Properties:
CidrBlock: 10.0.0.0/16
```
Para obtener más información sobre la configuración de la VPC en AWS SAM, consulte [AWS::EC2::VPC](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html) en la *Guía del usuario de CloudFormation*.
------
## Acceso a Internet cuando está conectado a una VPC
De forma predeterminada, las funciones de Lambda tienen acceso al Internet público. Cuando asocie la función a una VPC, esta solo puede tener acceso a los recursos disponibles dentro de esa VPC. Para conceder a la función acceso a internet, también necesita configurar la VPC para tener acceso a Internet. Para obtener más información, consulte [Habilitación del acceso a Internet para funciones de Lambda conectadas a VPC](configuration-vpc-internet.md).
## Compatibilidad con IPv6
Su función puede conectarse a recursos en subredes de VPC de doble pila a través de IPv6. Esta opción está desactivada de forma predeterminada. Para permitir el tráfico IPv6 saliente, use la consola o la opción `--vpc-config Ipv6AllowedForDualStack=true` con el comando [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) o el comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html).
**nota**
Para permitir el tráfico IPv6 saliente en una VPC, todas las subredes que estén conectadas a la función deben ser subredes de doble pila. Lambda no admite conexiones IPv6 salientes para subredes exclusivas de IPv6 en una VPC o conexiones IPv6 salientes para funciones que no están conectadas a una VPC.
Puede actualizar el código de función para conectarse explícitamente a los recursos de subred a través de IPv6. El siguiente ejemplo de Python abre un socket y se conecta a un servidor IPv6.
**Example — Conectarse al servidor IPv6**
```
def connect_to_server(event, context):
server_address = event['host']
server_port = event['port']
message = event['message']
run_connect_to_server(server_address, server_port, message)
def run_connect_to_server(server_address, server_port, message):
sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM, 0)
try:
# Send data
sock.connect((server_address, int(server_port), 0, 0))
sock.sendall(message.encode())
BUFF_SIZE = 4096
data = b''
while True:
segment = sock.recv(BUFF_SIZE)
data += segment
# Either 0 or end of data
if len(segment) < BUFF_SIZE:
break
return data
finally:
sock.close()
```
## Prácticas recomendadas para utilizar Lambda con Amazon VPC
Para asegurarse de que la configuración de su Lambda VPC cumpla con las guías de las prácticas recomendadas, siga los consejos de las siguientes secciones.
### Prácticas recomendadas de seguridad
Para adjuntar la función de Lambda a una VPC, debe otorgar a su rol de ejecución de la función una cantidad de permisos de Amazon EC2. Estos permisos son necesarios para crear las interfaces de red que utiliza su función para acceder a los recursos de la VPC. Sin embargo, estos permisos también se otorgan implícitamente al código de la función. Esto significa que su código de función tiene permiso para realizar estas llamadas a la API de Amazon EC2.
Para seguir el principio del acceso con el privilegio mínimo, añada una política de denegación como la del siguiente ejemplo al rol de ejecución de la función. Esta política impide que su función realice llamadas a las API de Amazon EC2, pero sí permite que el servicio Lambda gestione los recursos de VPC en su nombre. La política utiliza la clave de condición `lambda:SourceFunctionArn`, que solo se aplica a las llamadas a la API realizadas por el código de la función durante la ejecución. Para obtener más información, consulte [Uso del ARN de la función de origen para controlar el comportamiento de acceso a la función](permissions-source-function-arn.md).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DeleteNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DescribeSubnets",
"ec2:DetachNetworkInterface",
"ec2:AssignPrivateIpAddresses",
"ec2:UnassignPrivateIpAddresses"
],
"Resource": [ "*" ],
"Condition": {
"ArnEquals": {
"lambda:SourceFunctionArn": [
"arn:aws:lambda:us-west-2:123456789012:function:my_function"
]
}
}
}
]
}
```
------
AWS proporciona *[grupos de seguridad](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html)* y *[listas de control de acceso (ACL) de la red](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html)* para aumentar la seguridad en la VPC. Los grupos de seguridad controlan el tráfico de entrada y salida de los recursos, mientras que las ACL de red controlan el tráfico de entrada y salida de las subredes. Los grupos de seguridad proporcionan suficiente control de acceso para la mayoría de las subredes. Puede utilizar las ACL de red si desea agregar un nivel de seguridad adicional en la VPC. Para obtener instrucciones generales sobre las prácticas recomendadas de seguridad al utilizar Amazon VPC, consulte [Prácticas recomendadas de seguridad para su VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-security-best-practices.html) en la *Guía del usuario de Amazon Virtual Private Cloud*.
### Prácticas recomendadas de rendimiento
Al conectar la función a una VPC, Lambda comprueba si hay algún recurso de red disponible (ENI de hiperplano) al que pueda conectarse. Las ENI de hiperplano están asociadas a una combinación particular de grupos de seguridad y subredes de VPC. Si ya ha asociado una función a una VPC, especificando las mismas subredes y grupos de seguridad al adjuntar otra función, Lambda puede compartir los recursos de la red y evitar la necesidad de crear una nueva ENI de hiperplano. Para obtener más información sobre las ENI de hiperplano y su ciclo de vida, consulte [Introducción a las interfaces de red elástica (ENI) de hiperplano](#configuration-vpc-enis).
## Introducción a las interfaces de red elástica (ENI) de hiperplano
Una ENI de hiperplano es un recurso gestionado que actúa como una interfaz de red entre la función de Lambda y los recursos a los que desea que se conecte la función. El servicio de Lambda crea y administra estas ENI automáticamente al conectar la función a una VPC.
Las ENI de hiperplano no son visibles directamente para usted y no necesita configurarlas ni administrarlas. Sin embargo, saber cómo funcionan puede ayudarle a comprender el comportamiento de su función cuando la adjunta a una VPC.
La primera vez que se asocia una función a una VPC mediante una combinación de subred y grupo de seguridad en particular, Lambda crea una ENI de hiperplano. Otras funciones de su cuenta que utilizan la misma combinación de subred y grupo de seguridad también pueden utilizar esta ENI. Siempre que es posible, Lambda reutiliza las ENI existentes para optimizar la utilización de los recursos y minimizar la creación de nuevas ENI. Sin embargo, cada ENI de hiperplano admite hasta 65 000 conexiones o puertos. Si el número de conexiones supera este límite, Lambda escala el número de ENI automáticamente en función del tráfico de red y los requisitos de simultaneidad.
En el caso de las funciones nuevas, mientras Lambda crea una ENI de hiperplano, la función permanece en el estado Pendiente y no se puede invocar. La función pasa al estado Activo solo cuando la ENI de hiperplano está lista, lo que puede tardar varios minutos. En el caso de las funciones existentes, no es posible realizar operaciones adicionales sobre la función, como crear nuevas versiones o actualizar su código, aunque aún se pueden invocar versiones anteriores de la misma.
Como parte de la administración del ciclo de vida de la interfaz de red elástica (ENI), Lambda puede eliminar y recrear ENI para equilibrar la carga del tráfico de red en las ENI o para solucionar los problemas encontrados en las comprobaciones de estado de las ENI. Además, si una función de Lambda permanece inactiva durante 14 días, Lambda recupera cualquier ENI de Hyperplane no utilizada y establece el estado de la función a `Inactive`. La siguiente invocación fallará y la función reingresa al estado Pendiente hasta que Lambda completa la creación o asignación de una ENI de hiperplano. Recomendamos que el diseño no dependa de la persistencia de las ENI.
Cuando se actualiza una función para eliminar la configuración de VPC, Lambda necesita hasta 20 minutos para eliminar la ENI de hiperplano adjunta. Lambda solo elimina la ENI si ninguna otra función (o versión de función publicada) utiliza esa ENI de hiperplano.
Lambda depende de los permisos de la función [ rol de ejecución](lambda-intro-execution-role.md) para eliminar la ENI de hiperplano. Si elimina la función de ejecución antes de que Lambda elimine la ENI de hiperplano, Lambda no podrá eliminar la ENI de hiperplano. Puede realizar la eliminación de forma manual.
## Uso de claves de condición de IAM para la configuración de la VPC
Puede utilizar claves de condición específicas de Lambda para la configuración de la VPC para proporcionar controles de permisos adicionales para sus funciones de Lambda. Por ejemplo, puede requerir que todas las funciones de la organización estén conectadas a una VPC. También puede especificar las subredes y los grupos de seguridad que los usuarios de la función pueden y no pueden utilizar.
Lambda admite las siguientes claves de condición en las políticas de IAM:
+ **lambda:VpcIds**: permiten o deniegan una o varias VPC.
+ **lambda:SubnetIds**: permiten o deniegan una o varias subredes.
+ **lambda:SecurityGroupIds**: permiten o deniegan uno o varios grupos de seguridad.
Las operaciones de la API de Lambda [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html) y [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html) admiten estas claves de condición. Para obtener más información acerca de las claves de condición en las políticas de IAM, consulte [Elementos de la política de JSON de IAM: Condición](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html) en la *Guía del usuario de IAM*.
**sugerencia**
Si su función ya incluye una configuración de VPC de una solicitud de la API anterior, puede enviar una solicitud `UpdateFunctionConfiguration` sin la configuración de la VPC.
### Políticas de ejemplo con claves de condición para la configuración de la VPC
En los ejemplos siguientes se muestra cómo utilizar claves de condición para la configuración de la VPC. Después de crear una instrucción de política con las restricciones deseadas, agregue la instrucción de política para el usuario o rol de destino.
#### Asegúrese de que los usuarios implementen solo funciones conectadas a la VPC
Para asegurarse de que todos los usuarios implementen solo funciones conectadas a la VPC, puede denegar operaciones de creación y actualización de funciones que no incluyan un ID de VPC válido.
Tenga en cuenta que el ID de VPC no es un parámetro de entrada para la solicitud `CreateFunction` o `UpdateFunctionConfiguration`. Lambda recupera el valor ID de la VPC en función de los parámetros de subred y grupo de seguridad.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EnforceVPCFunction",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"Null": {
"lambda:VpcIds": "true"
}
}
}
]
}
```
------
#### Denegar a los usuarios el acceso a VPC, subredes o grupos de seguridad específicos
Para denegar a los usuarios el acceso a VPC específicas, utilice `StringEquals` para comprobar el valor de la condición `lambda:VpcIds`. En el ejemplo siguiente se deniega a los usuarios el acceso a `vpc-1` y `vpc-2`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EnforceOutOfVPC",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"StringEquals": {
"lambda:VpcIds": [
"vpc-1",
"vpc-2"
]
}
}
}
]
}
```
------
Para denegar a los usuarios el acceso a subredes específicas, utilice `StringEquals` para comprobar el valor de la condición `lambda:SubnetIds`. En el ejemplo siguiente se deniega a los usuarios el acceso a `subnet-1` y `subnet-2`.
```
{
"Sid": "EnforceOutOfSubnet",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"lambda:SubnetIds": ["subnet-1", "subnet-2"]
}
}
}
```
Para denegar a los usuarios el acceso a grupos de seguridad específicos, utilice `StringEquals` para comprobar el valor de la condición `lambda:SecurityGroupIds`. En el ejemplo siguiente se deniega a los usuarios el acceso a `sg-1` y `sg-2`.
```
{
"Sid": "EnforceOutOfSecurityGroups",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"lambda:SecurityGroupIds": ["sg-1", "sg-2"]
}
}
}
]
}
```
#### Permitir a los usuarios crear y actualizar funciones con configuraciones específicas de VPC
Para permitir a los usuarios acceder a VPC específicas, utilice `StringEquals` para comprobar el valor de la condición `lambda:VpcIds`. En el siguiente ejemplo se permite a los usuarios acceder a `vpc-1` y `vpc-2`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EnforceStayInSpecificVpc",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"lambda:VpcIds": [
"vpc-1",
"vpc-2"
]
}
}
}
]
}
```
------
Para permitir a los usuarios acceder a subredes específicas, utilice `StringEquals` para comprobar el valor de la condición `lambda:SubnetIds`. En el siguiente ejemplo se permite a los usuarios acceder a `subnet-1` y `subnet-2`.
```
{
"Sid": "EnforceStayInSpecificSubnets",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"ForAllValues:StringEquals": {
"lambda:SubnetIds": ["subnet-1", "subnet-2"]
}
}
}
```
Para permitir a los usuarios acceder a grupos de seguridad específicos, utilice `StringEquals` para comprobar el valor de la condición `lambda:SecurityGroupIds`. En el siguiente ejemplo se permite a los usuarios acceder a `sg-1` y `sg-2`.
```
{
"Sid": "EnforceStayInSpecificSecurityGroup",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"ForAllValues:StringEquals": {
"lambda:SecurityGroupIds": ["sg-1", "sg-2"]
}
}
}
]
}
```
## Tutoriales de VPC
En los siguientes tutoriales, se conecta una función de Lambda a los recursos de la VPC.
+ [Tutorial: Uso de una función de Lambda para obtener acceso a Amazon RDS en una Amazon VPC](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-lambda-tutorial.html)
+ [Tutorial: Configuración de una función de Lambda para obtener acceso a Amazon ElastiCache en una Amazon VPC](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/LambdaRedis.html)
# Otorgamiento a las funciones de Lambda de acceso a un recurso de Amazon VPC en otra cuenta
Puede conceder a su función de AWS Lambda acceso a un recurso de Amazon VPC en Amazon Virtual Private Cloud gestionado por otra cuenta sin exponer ninguna de las VPC a Internet. Este patrón de acceso le permite compartir datos con otras organizaciones que utilicen AWS. Con este patrón de acceso, puede compartir datos entre VPC con un mayor nivel de seguridad y rendimiento que a través de Internet. Configure su función de Lambda para usar una conexión de emparejamiento de Amazon VPC para acceder a estos recursos.
**aviso**
Cuando permita el acceso entre cuentas o VPC, compruebe que su plan cumpla con los requisitos de seguridad de las respectivas organizaciones que administran estas cuentas. Seguir las instrucciones de este documento afectará a la seguridad de sus recursos.
En este tutorial, conectará dos cuentas mediante una conexión de pares mediante IPv4. Configure una función de Lambda que aún no esté conectada a una Amazon VPC. La resolución de DNS se configura para conectar la función a los recursos que no proporcionan direcciones IP estáticas. Para adaptar estas instrucciones a otros escenarios de emparejamiento, consulte la [Guía de emparejamiento de VPC](https://docs.aws.amazon.com//vpc/latest/peering/what-is-vpc-peering.html).
## Requisitos previos
Para conceder acceso a una función de Lambda a un recurso de otra cuenta, debe tener:
+ Una función de Lambda configurada para autenticarse con el recurso y, a continuación, leerlo.
+ Un recurso de otra cuenta, como un clúster de Amazon RDS, disponible a través de Amazon VPC.
+ Credenciales para la cuenta de su función de Lambda y la cuenta de su recurso. Si tiene autorización para usar la cuenta de su recurso, contacte con un usuario autorizado para que prepare esa cuenta.
+ Permiso para crear y actualizar una VPC (y los recursos de Amazon VPC compatibles) para asociarla a su función de Lambda.
+ Permiso para actualizar el rol de ejecución y la configuración de VPC de la función de Lambda.
+ Permiso para crear una conexión de emparejamiento de VPC en la cuenta de su función de Lambda.
+ Permiso para aceptar una conexión de emparejamiento de VPC en la cuenta de su recurso.
+ Permiso para actualizar la configuración de la VPC de su recurso (y los recursos de Amazon VPC compatibles).
+ Permiso para invocar una función de Lambda.
## Creación de una Amazon VPC en la cuenta de su función
Cree una Amazon VPC, subredes, tablas de enrutamiento y un grupo de seguridad en la cuenta de su función de Lambda.
**Para crear una VPC, subredes y otros recursos de la VPC mediante la consola**
1. Abra la consola de Amazon VPC en [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. En el panel, elija **Crear VPC**.
1. Para el **bloque de CIDR de IPv4**, proporcione un bloque de CIDR privado. El bloque de CIDR no se debe solapar con los bloques utilizados en la VPC de su recurso. No elija un bloque que utilice la VPC de sus recursos para asignar direcciones IP a los recursos ni un bloque ya definido en las tablas de enrutamiento de la VPC de sus recursos. Para obtener más información sobre cómo definir los bloques de CIDR adecuados, consulte [Bloques de CIDR de VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html).
1. Elija **Personalizar las zonas de disponibilidad**.
1. Seleccione las mismas zonas de disponibilidad que su recurso.
1. Para **Cantidad de subredes públicas**, elija **0**.
1. Para **VPC endpoints** (Puntos de conexión de la VPC), elija **None** (Ninguno).
1. Seleccione **Creación de VPC**.
## Concesión de permisos de VPC al rol de ejecución de la función
Adjunte [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) al rol de ejecución de la función para permitir que se conecte a las VPC.
**Concesión de permisos de VPC al rol de ejecución de la función**
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija el nombre de su función.
1. Elija **Configuración**.
1. Elija **Permisos**.
1. En **Nombre del rol**, elija el rol de ejecución.
1. En la sección **Políticas de permisos**, elija **Agregar permisos**.
1. En la lista desplegable, elija **Adjuntar políticas**.
1. En el cuadro de búsqueda, escriba `AWSLambdaVPCAccessExecutionRole`.
1. A la izquierda del nombre de la política, elija la casilla de verificación.
1. Elija **Añadir permisos**.
**Asociación de la función a su Amazon VPC**
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija el nombre de su función.
1. Elija la pestaña **Configuración** y, a continuación, elija **VPC**.
1. Elija **Edit (Edición de)**.
1. En **VPC**, seleccione la VPC.
1. En **Subredes**, elija sus subredes.
1. En **Grupo de seguridad**, seleccione el grupo de seguridad predeterminado de la VPC.
1. Seleccione **Save**.
## Creación de una solicitud de conexión de emparejamiento de VPC
Cree una solicitud de conexión de emparejamiento de VPC desde la VPC de su función (la VPC solicitante) a la VPC de su recurso (la VPC receptora).
**Solicitud de una conexión de emparejamiento de VPC desde la VPC de su función**
1. Abra [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. En el panel de navegación, elija **Peering Connections** (Conexiones de emparejamiento).
1. Elija **Create peering connection** (Crear conexión de emparejamiento).
1. En **ID de VPC (solicitante)**, seleccione la VPC de su función.
1. En **ID de cuenta**, ingrese el ID de la cuenta de su recurso.
1. En **ID de VPC (receptora)**, ingrese la VPC de su recurso.
## Preparación de la cuenta del recurso
Para crear la conexión de emparejamiento y preparar la VPC del recurso para usarla, inicie sesión en la cuenta del recurso con un rol que posea los permisos que se indican en los requisitos previos. Los pasos para iniciar sesión pueden variar según la forma en que esté protegida la cuenta. Para obtener más información sobre el inicio de sesión en una cuenta de AWS, consulte la [Guía del usuario de Inicio de sesión en AWS](https://docs.aws.amazon.com//signin/latest/userguide/what-is-sign-in.html). En la cuenta de su recurso, lleve a cabo los siguientes procedimientos.
**Aceptación de una solicitud de conexión de emparejamiento de VPC**
1. Abra [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. En el panel de navegación, elija **Peering Connections** (Conexiones de emparejamiento).
1. Seleccione la conexión de emparejamiento de VPC pendiente (con el estado aceptación pendiente).
1. Elija **Acciones**.
1. En la lista desplegable, elija **Aceptar solicitud**.
1. Cuando se le pida confirmación, elija **Aceptar solicitud**.
1. Elija **Modificar mis tablas de ruteo ahora** para agregar una ruta a la tabla de enrutamiento principal de la VPC y, así, poder enviar y recibir tráfico a través de la conexión de emparejamiento.
Inspeccione las tablas de enrutamiento de la VPC del recurso. Es posible que la ruta generada por Amazon VPC no establezca la conectividad en función de cómo esté configurada la VPC de su recurso. Compruebe si hay conflictos entre la nueva ruta y la configuración existente de la VPC. Para obtener más información sobre la solución de problemas, consulte [Solución de problemas de conexión de emparejamiento de VPC](https://docs.aws.amazon.com/vpc/latest/peering/troubleshoot-vpc-peering-connections.html) en la *Guía de emparejamiento de Amazon Virtual Private Cloud (VPC)*.
**Actualización del grupo de seguridad de su recurso**
1. Abra [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. En el panel de navegación, elija **Grupos de seguridad**.
1. Seleccione el grupo de seguridad de su recurso.
1. Elija **Acciones**.
1. En la lista desplegable, elija **Editar reglas de entrada**.
1. Seleccione **Agregar regla**.
1. En **Origen**, ingrese el ID de cuenta de la función y el ID del grupo de seguridad, separados por una barra diagonal (como, por ejemplo, 111122223333/sg-1a2b3c4d).
1. Elija **Edit outbound rules**.
1. Compruebe si el tráfico saliente está restringido. La configuración de VPC predeterminada permite todo el tráfico saliente. Si el tráfico saliente está restringido, continúe con el siguiente paso.
1. Seleccione **Agregar regla**.
1. En **Destino**, ingrese el ID de cuenta de la función y el ID del grupo de seguridad, separados por una barra diagonal (como, por ejemplo, 111122223333/sg-1a2b3c4d).
1. Seleccione **Guardar reglas**.
**Habilitación de la resolución de DNS para la interconexión**
1. Abra [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. En el panel de navegación, elija **Peering Connections** (Conexiones de emparejamiento).
1. Seleccione la conexión de emparejamiento.
1. Elija **Acciones**.
1. Elija **Editar configuración de DNS**.
1. En la sección **Resolución de DNS de receptora**, seleccione **Permitir al VPC solicitante resolver el DNS de los host de VPC receptores a una IP privada**.
1. Seleccione **Save changes (Guardar cambios)**.
## Actualización de la configuración de VPC en la cuenta de la función
Inicie sesión en la cuenta de la función y, a continuación, actualice la configuración de VPC.
**Adición de una ruta para su conexión de emparejamiento de VPC**
1. Abra [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. En el panel de navegación, elija **Tablas de enrutamiento**.
1. Seleccione la casilla de verificación situada junto al nombre de la tabla de enrutamiento para la subred que asoció a su función.
1. Elija **Acciones**.
1. Elija **Edit routes** (Editar rutas).
1. Seleccione **Añadir ruta**.
1. En **Destino**, ingrese el bloque de CIDR de la VPC de su recurso.
1. En **Objetivo**, seleccione la conexión de emparejamiento de VPC.
1. Seleccione **Save changes (Guardar cambios)**.
Para obtener más información sobre las consideraciones que pueden surgir al actualizar las tablas de enrutamiento, consulte [Actualice sus tablas de enrutamiento para interconexiones de VPC](https://docs.aws.amazon.com//vpc/latest/peering/vpc-peering-routing.html).
**Actualización del grupo de seguridad de la función de Lambda**
1. Abra [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. En el panel de navegación, elija **Grupos de seguridad**.
1. Elija **Acciones**.
1. Elija **Editar reglas de entrada**.
1. Seleccione **Agregar regla**.
1. En **Origen**, ingrese el ID de cuenta y el ID del grupo de seguridad del recurso, separados por una barra diagonal (por ejemplo, 111122223333/sg-1a2b3c4d).
1. Seleccione **Guardar reglas**.
**Habilitación de la resolución de DNS para la interconexión**
1. Abra [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. En el panel de navegación, elija **Peering Connections** (Conexiones de emparejamiento).
1. Seleccione la conexión de emparejamiento.
1. Elija **Acciones**.
1. Elija **Editar configuración de DNS**.
1. En la sección **Resolución de DNS de solicitante**, seleccione **Permitir al VPC receptor resolver el DNS de los host de VPC solicitantes a una IP privada**.
1. Seleccione **Save changes (Guardar cambios)**.
## Comprobación de la función de
**Creación de un evento de prueba e inspección del resultado de la función**
1. En el panel **Código fuente**, elija **Probar**.
1. Seleccione **Crear un evento nuevo**.
1. En el panel **Evento JSON**, sustituya los valores predeterminados por una entrada adecuada para la función de Lambda.
1. Elija **Invoke (Invocar)**.
1. En la pestaña **Resultados de ejecución**, confirme que **Respuesta** contenga el resultado esperado.
Además, puede comprobar los registros de su función para verificar que sean los esperados.
**Visualización de los registros de invocación de la función en Registros de CloudWatch**
1. Elija la pestaña **Supervisar**.
1. Seleccione **Ver Registros en CloudWatch**.
1. En la pestaña **Flujos de registro**, elija el flujo de registro para la invocación de la función.
1. Confirme que los registros son los esperados.
# Habilitación del acceso a Internet para funciones de Lambda conectadas a VPC
De forma predeterminada, las funciones de Lambda se ejecutan en una VPC administrada por Lambda que tiene acceso a Internet. Para acceder a los recursos de una VPC de su cuenta, puede agregar una configuración de VPC a una función. Esto restringe la función a los recursos de esa VPC, a menos que la VPC tenga acceso a Internet. En esta página, se explica cómo proporcionar acceso a Internet a las funciones de Lambda conectadas por VPC.
## Aún no tengo una VPC
### Creación de la VPC
El **Flujo de trabajo de creación de VPC** crea todos los recursos de VPC necesarios para que una función de Lambda acceda a la Internet pública desde una subred privada, incluidas las subredes, la puerta de enlace NAT, la puerta de enlace de Internet y las entradas de la tabla de enrutamiento.
**Para crear la VPC**
1. Abra la consola de Amazon VPC en [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. En el panel, elija **Crear VPC**.
1. En **Recursos para crear**, elija **VPC y más**.
1. **Configurar la VPC**
1. En **Generación automática de etiquetas de nombre**, ingrese un nombre para la VPC.
1. En **Bloque de CIDR IPv4**, puede conservar la sugerencia predeterminada o, como alternativa, ingresar el bloque de CIDR necesario para su aplicación o red.
1. Si la aplicación se comunica mediante direcciones IPv6, elija **Bloque de CIDR IPv6**, **Bloque de CIDR IPv6 proporcionado por Amazon**.
1. **Configurar las subredes**
1. Para **Número de zonas de disponibilidad**, elija **2**. Se recomiendan como mínimo dos AZ para una alta disponibilidad.
1. Para **Número de subredes públicas**, elija **2**.
1. Para **Número de subredes privadas**, elija **2**.
1. Puede conservar el bloque de CIDR predeterminado para la subred pública o, si lo prefiere, puede ampliar **Personalizar los bloques de CIDR de la subred** e introducir un bloque de CIDR. Para obtener más información, consulte [Subred de bloques CIDR](https://docs.aws.amazon.com/vpc/latest/userguide/subnet-sizing.html).
1. En **Puertas de enlace NAT**, elija **1 por AZ** para mejorar la resiliencia.
1. Para **Puerta de enlace de Internet de solo salida**, elija **Sí** si optó por incluir un bloque CIDR de IPv6.
1. En **Puntos de conexión de VPC**, mantenga el valor predeterminado (**Puerta de enlace de S3**). Esta opción no tiene ningún costo. Para obtener más información, consulte [Tipos de puntos de conexión de VPC de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/privatelink-interface-endpoints.html#types-of-vpc-endpoints-for-s3).
1. Mantenga la configuración predeterminada para **las opciones DNS**.
1. Seleccione **Creación de VPC**.
### Configuración de la función de Lambda
**Para configurar una VPC al crear una función**
1. Abra la página de [Functions](https://console.aws.amazon.com/lambda/home#/functions) (Funciones) en la consola de Lambda.
1. Seleccione **Creación de función**.
1. En **Basic information (Información básica)**, para **Function name (Nombre de función)**, escriba un nombre para la función.
1. Amplíe **Configuración avanzada**.
1. Seleccione **Habilitar VPC** y, a continuación, elija una VPC.
1. (Opcional) Para permitir el [tráfico IPv6 saliente](configuration-vpc.md#configuration-vpc-ipv6), seleccione **Permitir tráfico IPv6 para subredes de doble pila**.
1. En **Subredes**, seleccione todas las subredes privadas. Las subredes privadas pueden obtener acceso a Internet a través de una puerta de enlace NAT. La conexión de una función a una subred pública no le concede acceso a Internet.
**nota**
Si seleccionó **Permitir tráfico IPv6 para subredes de pila doble**, todas las subredes seleccionadas deben tener un bloque de CIDR IPv4 y un bloque de CIDR IPv6.
1. En el caso de los **Grupos de seguridad**, seleccione un grupo de seguridad que permita el tráfico saliente.
1. Seleccione **Creación de función**.
Lambda crea automáticamente un rol de ejecución con la política [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) administrada por AWS. Los permisos de esta política solo son necesarios para crear interfaces de redes elásticas para la configuración de la VPC, no para invocar la función. Para aplicar permisos con privilegios mínimos, puede eliminar la política **AWSLambdaVPCAccessExecutionRole** de su rol de ejecución después de crear la función y la configuración de VPC. Para obtener más información, consulte [Permisos de IAM necesarios](configuration-vpc.md#configuration-vpc-permissions).
**Para configurar una VPC para una función existente**
Para agregar una configuración de VPC a una función existente, el rol de ejecución de la función debe tener [permiso para crear y administrar interfaces de redes elásticas](configuration-vpc.md#configuration-vpc-permissions). La política [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) administrada por AWS incluye los permisos requeridos. Para aplicar permisos con privilegios mínimos, puede eliminar la política **AWSLambdaVPCAccessExecutionRole** de su rol de ejecución después de crear la configuración de VPC.
1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija una función.
1. Elija la pestaña **Configuración** y, a continuación, elija **VPC**.
1. En **VPC**, elija **Edit (Editar)**.
1. Seleccione la VPC.
1. (Opcional) Para permitir el [tráfico IPv6 saliente](configuration-vpc.md#configuration-vpc-ipv6), seleccione **Permitir tráfico IPv6 para subredes de doble pila**.
1. En **Subredes**, seleccione todas las subredes privadas. Las subredes privadas pueden obtener acceso a Internet a través de una puerta de enlace NAT. La conexión de una función a una subred pública no le concede acceso a Internet.
**nota**
Si seleccionó **Permitir tráfico IPv6 para subredes de pila doble**, todas las subredes seleccionadas deben tener un bloque de CIDR IPv4 y un bloque de CIDR IPv6.
1. En el caso de los **Grupos de seguridad**, seleccione un grupo de seguridad que permita el tráfico saliente.
1. Seleccione **Save**.
### Prueba de la función
Use el siguiente código de ejemplo para confirmar que su función conectada a VPC puede llegar a la Internet pública. Si se ejecuta correctamente, el código devuelve un código de estado `200`. Si no funciona, la función agota el tiempo de espera.
------
#### [ Node.js ]
1. En el panel **Código fuente** de la consola de Lambda, pegue el siguiente código en el archivo **index.mjs**. La función realiza una solicitud HTTP GET a un punto de conexión público y devuelve el código de respuesta HTTP para comprobar si la función tiene acceso a la Internet pública.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/code-source-nodejs.png)
**Example — Solicitud HTTP con async/await**
```
const url = "https://aws.amazon.com/";
export const handler = async(event) => {
try {
const res = await fetch(url);
console.info("status", res.status);
return res.status;
}
catch (e) {
console.error(e);
return 500;
}
};
```
1. En la sección **IMPLEMENTAR** elija **Implementar** para actualizar el código de la función:
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. Elija la pestaña **Prueba**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/test-tab.png)
1. Seleccione **Probar**
1. La función devuelve un código de estado `200`. Esto significa que la función tiene acceso saliente a Internet.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/test-successful-200.png)
Si la función no puede acceder a la Internet pública, aparecerá un mensaje de error como este:
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
#### [ Python ]
1. En el panel **Código fuente** de la consola de Lambda, pegue el siguiente código en el archivo **lambda\$1function.py**. La función realiza una solicitud HTTP GET a un punto de conexión público y devuelve el código de respuesta HTTP para comprobar si la función tiene acceso a la Internet pública.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/code-source-python.png)
```
import urllib.request
def lambda_handler(event, context):
try:
response = urllib.request.urlopen('https://aws.amazon.com')
status_code = response.getcode()
print('Response Code:', status_code)
return status_code
except Exception as e:
print('Error:', e)
raise e
```
1. En la sección **IMPLEMENTAR** elija **Implementar** para actualizar el código de la función:
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. Elija la pestaña **Prueba**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/test-tab.png)
1. Seleccione **Probar**
1. La función devuelve un código de estado `200`. Esto significa que la función tiene acceso saliente a Internet.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/test-successful-200.png)
Si la función no puede acceder a la Internet pública, aparecerá un mensaje de error como este:
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
## Ya tengo una VPC
Si ya tiene una VPC, pero necesita configurar el acceso público a Internet para una función de Lambda, siga estos pasos. Este procedimiento supone que la VPC tiene, como mínimo, dos subredes. Si no tiene dos subredes, consulte [Crear una subred](https://docs.aws.amazon.com/vpc/latest/userguide/create-subnets.html) en la *Guía del usuario de Amazon VPC*.
### Verifique la configuración de la tabla de enrutamiento
1. Abra la consola de Amazon VPC en [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. Elija el **ID de la VPC**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/vpc-id.png)
1. Desplácese hasta la sección **Mapa de recursos**. Tenga en cuenta las asignaciones de tablas de enrutamiento. Abra cada tabla de enrutamiento que esté mapeada a una subred.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/route-table-associations.png)
1. Desplácese hasta la pestaña **Rutas**. Revise las rutas para determinar si su VPC tiene las siguientes tablas de enrutamiento. Cada uno de estos requisitos debe cumplirse mediante una tabla de enrutamiento independiente.
+ El tráfico con destino a Internet (`0.0.0.0/0` para IPv4, `::/0` para IPv6) se enruta a una puerta de enlace de Internet (`igw-xxxxxxxxxx`). Esto significa que la subred asociada a la tabla de enrutamiento es una subred pública.
**nota**
Si su subred no tiene un bloque CIDR de IPv6, solo verá la ruta IPv4 (`0.0.0.0/0`).
**Example tabla de enrutamiento de la subred pública**
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/routes-public.png)
+ El tráfico con destino a Internet para IPv4 (`0.0.0.0/0`) se enruta a una puerta de enlace NAT (`nat-xxxxxxxxxx`) que está asociada a una subred pública. Esto significa que la subred es privada y puede obtener acceso a Internet a través de una puerta de enlace NAT.
**nota**
Si la subred tiene un bloque de CIDR IPv6, la tabla de enrutamiento también debe direccionar el tráfico IPv6 entrante (`::/0`) a una puerta de enlace de Internet de solo salida (`eigw-xxxxxxxxxx`). Si su subred no tiene un bloque CIDR de IPv6, solo verá la ruta IPv4 (`0.0.0.0/0`).
**Example tabla de enrutamiento de subred privada**
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/routes-private.png)
1. Repita el paso anterior hasta que haya revisado cada tabla de enrutamiento asociada a una subred en su VPC y haya confirmado que tiene una tabla de enrutamiento con una puerta de enlace de Internet y una tabla de enrutamiento con una puerta de enlace NAT.
Si no tiene dos tablas de enrutamiento, una con una ruta a una puerta de enlace de Internet y otra con una ruta a una puerta de enlace NAT, siga estos pasos para crear los recursos y las entradas de la tabla de enrutamiento que faltan.
### Crear una tabla de enrutamiento
Siga estos pasos para crear una tabla de enrutamiento y asociarla a una subred.
**Creación de una tabla de enrutamiento personalizada mediante la consola de Amazon VPC**
1. Abra la consola de Amazon VPC en [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. En el panel de navegación, elija **Tablas de enrutamiento**.
1. Elija **Create Route Table (Crear tabla de enrutamiento)**.
1. (Opcional) En **Name** (Etiqueta), escriba el nombre de la tabla de enrutamiento.
1. En **VPC**, elija su VPC.
1. (Opcional) Para agregar una etiqueta, elija **Add new tag** (Agregar etiqueta nueva) e ingrese la clave y el valor de la etiqueta.
1. Elija **Create Route Table (Crear tabla de enrutamiento)**.
1. En la pestaña **Subnet associations** (Asociaciones de subred), elija **Edit subnet associations** (Editar asociaciones de subred).
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/route-table-subnet.png)
1. Seleccione la casilla de verificación para la subred que desee asociar a la tabla de enrutamiento.
1. Seleccione **Save associations** (Guardar asociaciones).
### Cree un puerta de enlace de Internet
Siga estos pasos para crear una puerta de enlace de Internet, adjuntarla a su VPC y agregarla a la tabla de enrutamiento de la subred pública.
**Para crear una puerta de enlace de Internet**
1. Abra la consola de Amazon VPC en [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. En el panel de navegación, elija **Internet Gateways** (Puertas de enlace de Internet).
1. Elija **Crear puerta de enlace de Internet**.
1. (Opcional) Ingrese un nombre para la puerta de enlace de Internet.
1. (Opcional) Para agregar una etiqueta, elija **Agregar etiqueta nueva** e ingrese la clave y el valor de la etiqueta.
1. Elija **Crear puerta de enlace de Internet**.
1. Elija **Asociar a una VPC** en el banner de la parte superior de la pantalla, seleccione una VPC disponible y, a continuación, elija **Conectar puerta de enlace de Internet**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/igw-attach-vpc.png)
1. Elija el **ID de la VPC**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/igw-subnet-1.png)
1. Elija el **ID de la VPC** para abrir la página de detalles de VPC.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/igw-your-vpcs.png)
1. Desplácese hacia abajo hasta la sección **Mapa de recursos** y, a continuación, elija una subred. Los detalles de la subred se mostrarán en una nueva pestaña.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/vpc-subnets.png)
1. Elija el enlace en **Tabla de enrutamiento**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/subnet-route-table.png)
1. Elija el **ID de la tabla de enrutamiento** para abrir la página de detalles de la tabla de enrutamiento.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/route-table-id.png)
1. En **Rutas**, elija **Editar rutas**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/edit-routes.png)
1. Seleccione **Agregar ruta** y, a continuación, introduzca `0.0.0.0/0` en el cuadro **Destino**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/create-route-1.png)
1. En **Objetivo**, seleccione **Puerta de enlace de Internet** y, a continuación, elija la puerta de enlace de Internet que creó anteriormente. Si la subred tiene un bloque de CIDR IPv6, también debe agregar una ruta `::/0` para la misma puerta de enlace de Internet.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/create-route-2.png)
1. Seleccione **Save changes (Guardar cambios)**.
### Creación de una gateway NAT
Siga estos pasos para crear una puerta de enlace NAT, asociarla a una subred pública y, a continuación, agregarla a la tabla de enrutamiento de la subred privada.
**Creación de una puerta de enlace NAT y asociación a una subred pública**
1. En el panel de navegación, elija **Puertas de enlace de NAT**.
1. Elija **Crear una puerta de enlace de NAT**.
1. (Opcional) Ingrese un nombre para la puerta de enlace NAT.
1. En **Subred**, seleccione la subred pública de su VPC. (Una subred pública es una subred que tiene una ruta directa a una puerta de enlace de Internet en su tabla de enrutamiento).
**nota**
Las puertas de enlace NAT están asociadas a una subred pública, pero la entrada de la tabla de enrutamiento se encuentra en la subred privada.
1. Para el **ID de asignación de IP elástica**, seleccione una dirección IP elástica o elija **Asignar IP elástica**.
1. Elija **Crear una puerta de enlace de NAT**.
**Adición de una ruta a la puerta de enlace NAT en la tabla de enrutamiento de la subred privada**
1. En el panel de navegación, elija **Subnets (Subredes)**.
1. Seleccione una subred privada en su VPC. (La subred privada es una subred que no dispone de una ruta a una puerta de enlace de Internet en su tabla de enrutamiento).
1. Elija el enlace en **Tabla de enrutamiento**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/subnet-route-table.png)
1. Elija el **ID de la tabla de enrutamiento** para abrir la página de detalles de la tabla de enrutamiento.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/route-table-id.png)
1. Desplácese hacia abajo y elija la pestaña **Rutas** y, a continuación, **Editar rutas**
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/route-table-edit-routes.png)
1. Seleccione **Agregar ruta** y, a continuación, introduzca `0.0.0.0/0` en el cuadro **Destino**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/create-route-1.png)
1. En **Destino**, seleccione **Puerta de enlace NAT** y, a continuación, elija la puerta de enlace NAT que creó anteriormente.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/create-route-nat.png)
1. Seleccione **Save changes (Guardar cambios)**.
### Creación de una puerta de enlace de Internet de solo salida (solo IPv6)
Siga estos pasos para crear una puerta de enlace de Internet de solo salida y agregar la tabla de enrutamiento de su subred privada.
**Para crear una gateway de internet de solo salida**
1. En el panel de navegación, elija **Puertas de enlace de Internet de solo salida**.
1. Elija **Crear puerta de enlace de Internet de solo salida**.
1. (Opcional) Escriba un nombre.
1. Seleccione la VPC en la que desea crear el puerto de enlace a Internet de solo salida.
1. Elija **Crear puerta de enlace de Internet de solo salida**.
1. Elija el enlace que aparece en el **ID de VPC asociada**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/eigw-details.png)
1. Seleccione el enlace en el **ID de la VPC** para abrir la página de detalles de VPC.
1. Desplácese hacia abajo hasta la sección **Mapa de recursos** y, a continuación, elija una subred privada. (La subred privada es una subred que no dispone de una ruta a una puerta de enlace de Internet en su tabla de enrutamiento). Los detalles de la subred se mostrarán en una nueva pestaña.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/vpc-subnet-private.png)
1. Elija el enlace en **Tabla de enrutamiento**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/private-subnet-route-table.png)
1. Elija el **ID de la tabla de enrutamiento** para abrir la página de detalles de la tabla de enrutamiento.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/route-table-id.png)
1. En **Rutas**, elija **Editar rutas**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/edit-routes.png)
1. Seleccione **Agregar ruta** y, a continuación, introduzca `::/0` en el cuadro **Destino**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/create-route-1.png)
1. En **Destino**, seleccione **Puerta de enlace de Internet de solo salida** y, a continuación, elija la puerta de enlace que creó anteriormente.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/eigw-route.png)
1. Seleccione **Save changes (Guardar cambios)**.
### Configuración de la función de Lambda
**Para configurar una VPC al crear una función**
1. Abra la página de [Functions](https://console.aws.amazon.com/lambda/home#/functions) (Funciones) en la consola de Lambda.
1. Seleccione **Creación de función**.
1. En **Basic information (Información básica)**, para **Function name (Nombre de función)**, escriba un nombre para la función.
1. Amplíe **Configuración avanzada**.
1. Seleccione **Habilitar VPC** y, a continuación, elija una VPC.
1. (Opcional) Para permitir el [tráfico IPv6 saliente](configuration-vpc.md#configuration-vpc-ipv6), seleccione **Permitir tráfico IPv6 para subredes de doble pila**.
1. En **Subredes**, seleccione todas las subredes privadas. Las subredes privadas pueden obtener acceso a Internet a través de una puerta de enlace NAT. La conexión de una función a una subred pública no le concede acceso a Internet.
**nota**
Si seleccionó **Permitir tráfico IPv6 para subredes de pila doble**, todas las subredes seleccionadas deben tener un bloque de CIDR IPv4 y un bloque de CIDR IPv6.
1. En el caso de los **Grupos de seguridad**, seleccione un grupo de seguridad que permita el tráfico saliente.
1. Seleccione **Creación de función**.
Lambda crea automáticamente un rol de ejecución con la política [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) administrada por AWS. Los permisos de esta política solo son necesarios para crear interfaces de redes elásticas para la configuración de la VPC, no para invocar la función. Para aplicar permisos con privilegios mínimos, puede eliminar la política **AWSLambdaVPCAccessExecutionRole** de su rol de ejecución después de crear la función y la configuración de VPC. Para obtener más información, consulte [Permisos de IAM necesarios](configuration-vpc.md#configuration-vpc-permissions).
**Para configurar una VPC para una función existente**
Para agregar una configuración de VPC a una función existente, el rol de ejecución de la función debe tener [permiso para crear y administrar interfaces de redes elásticas](configuration-vpc.md#configuration-vpc-permissions). La política [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) administrada por AWS incluye los permisos requeridos. Para aplicar permisos con privilegios mínimos, puede eliminar la política **AWSLambdaVPCAccessExecutionRole** de su rol de ejecución después de crear la configuración de VPC.
1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija una función.
1. Elija la pestaña **Configuración** y, a continuación, elija **VPC**.
1. En **VPC**, elija **Edit (Editar)**.
1. Seleccione la VPC.
1. (Opcional) Para permitir el [tráfico IPv6 saliente](configuration-vpc.md#configuration-vpc-ipv6), seleccione **Permitir tráfico IPv6 para subredes de doble pila**.
1. En **Subredes**, seleccione todas las subredes privadas. Las subredes privadas pueden obtener acceso a Internet a través de una puerta de enlace NAT. La conexión de una función a una subred pública no le concede acceso a Internet.
**nota**
Si seleccionó **Permitir tráfico IPv6 para subredes de pila doble**, todas las subredes seleccionadas deben tener un bloque de CIDR IPv4 y un bloque de CIDR IPv6.
1. En el caso de los **Grupos de seguridad**, seleccione un grupo de seguridad que permita el tráfico saliente.
1. Seleccione **Save**.
### Prueba de la función
Use el siguiente código de ejemplo para confirmar que su función conectada a VPC puede llegar a la Internet pública. Si se ejecuta correctamente, el código devuelve un código de estado `200`. Si no funciona, la función agota el tiempo de espera.
------
#### [ Node.js ]
1. En el panel **Código fuente** de la consola de Lambda, pegue el siguiente código en el archivo **index.mjs**. La función realiza una solicitud HTTP GET a un punto de conexión público y devuelve el código de respuesta HTTP para comprobar si la función tiene acceso a la Internet pública.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/code-source-nodejs.png)
**Example — Solicitud HTTP con async/await**
```
const url = "https://aws.amazon.com/";
export const handler = async(event) => {
try {
const res = await fetch(url);
console.info("status", res.status);
return res.status;
}
catch (e) {
console.error(e);
return 500;
}
};
```
1. En la sección **IMPLEMENTAR** elija **Implementar** para actualizar el código de la función:
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. Elija la pestaña **Prueba**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/test-tab.png)
1. Seleccione **Probar**
1. La función devuelve un código de estado `200`. Esto significa que la función tiene acceso saliente a Internet.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/test-successful-200.png)
Si la función no puede acceder a la Internet pública, aparecerá un mensaje de error como este:
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
#### [ Python ]
1. En el panel **Código fuente** de la consola de Lambda, pegue el siguiente código en el archivo **lambda\$1function.py**. La función realiza una solicitud HTTP GET a un punto de conexión público y devuelve el código de respuesta HTTP para comprobar si la función tiene acceso a la Internet pública.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/code-source-python.png)
```
import urllib.request
def lambda_handler(event, context):
try:
response = urllib.request.urlopen('https://aws.amazon.com')
status_code = response.getcode()
print('Response Code:', status_code)
return status_code
except Exception as e:
print('Error:', e)
raise e
```
1. En la sección **IMPLEMENTAR** elija **Implementar** para actualizar el código de la función:
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
1. Elija la pestaña **Prueba**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/test-tab.png)
1. Seleccione **Probar**
1. La función devuelve un código de estado `200`. Esto significa que la función tiene acceso saliente a Internet.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/test-successful-200.png)
Si la función no puede acceder a la Internet pública, aparecerá un mensaje de error como este:
```
{
"errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds"
}
```
------
# Conexión de puntos de conexión de VPC de la interfaz de entrada para Lambda
Si utiliza Amazon Virtual Private Cloud (Amazon VPC) para alojar sus recursos de AWS, puede establecer una conexión entre su VPC y Lambda. Puede utilizar esta conexión para invocar la función de Lambda sin pasar por la red pública de Internet.
Puede establecer una conexión privada entre la VPC y Lambda mediante la creación de un [punto de enlace de la VPC de interfaz](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html). Los puntos de enlace de interfaz cuentan con la tecnología de [AWS PrivateLink](https://aws.amazon.com/privatelink), lo que les permite acceder de forma privada a las API de Lambda sin utilizar una puerta de enlace de Internet, un dispositivo NAT, una conexión de VPN o una conexión AWS Direct Connect. Las instancias de la VPC no necesitan direcciones IP públicas para comunicarse con las API de Lambda. El tráfico entre la VPC y Lambda no sale de la red de AWS.
Cada punto de enlace de la interfaz está representado por una o más [interfaces de redes elásticas](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) en las subredes. Una interfaz de red proporciona una dirección IP privada que sirve como punto de entrada del tráfico dirigido a Lambda.
**Topics**
+ [
## Consideraciones para los puntos de enlace de la interfaz Lambda
](#vpc-endpoint-considerations)
+ [
## Creación de un punto de enlace de interfaz para Lambda
](#vpc-endpoint-create)
+ [
## Creación de una política de punto de enlace de interfaz para Lambda
](#vpc-endpoint-policy)
## Consideraciones para los puntos de enlace de la interfaz Lambda
Antes de configurar un punto de enlace de la interfaz para Lambda, revise el tema [Propiedades y limitaciones de los puntos de enlace de interfaz](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#vpce-interface-limitations) en la *Guía del usuario de Amazon VPC*.
Puede llamar a cualquiera de las operaciones de API de Lambda desde su VPC. Por ejemplo, puede invocar la función de Lambda llamando a la API de `Invoke` desde su VPC. Para ver la lista completa de las API de Lambda, consulte [Actions (Acciones)](https://docs.aws.amazon.com/lambda/latest/dg/API_Operations.html) en la Referencia de las API de Lambda.
`use1-az3` es una región de capacidad limitada para las funciones de la VPC de Lambda. No debe utilizar subredes en esta zona de disponibilidad con las funciones de Lambda, ya que esto puede reducir la redundancia zonal en caso de una interrupción.
### Directiva ”keep-alive” para conexiones persistentes
Con el tiempo, Lambda depura las conexiones inactivas, por lo que es necesario utilizar una directiva keep-alive para conservar las conexiones persistentes. Si intenta reutilizar una conexión inactiva al invocar una función, se producirá un error de conexión. Para mantener la conexión persistente, use la directiva keep-alive asociada al tiempo de ejecución. Para ver un ejemplo, consulte [Reutilización de conexiones con Keep-Alive en Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html) en la *Guía del desarrollador de AWS SDK para JavaScript*.
### Consideraciones de facturación
No se generan costos adicionales por acceder a una función de Lambda a través de un punto de enlace. Para obtener más información sobre los precios de Lambda, consulte los [Precios de AWS Lambda](https://aws.amazon.com/lambda/pricing/).
Los precios estándar de AWS PrivateLink se aplica a los puntos de enlace de la interfaz para Lambda. Su cuenta de AWS se facturará cada hora de aprovisionamiento de un punto de enlace de interfaz en cada zona de disponibilidad y los datos procesados a través del punto de enlace de la interfaz. Para obtener más información sobre los precios de los puntos de enlace de tipo interfaz, consulte [Precios de AWS PrivateLink](https://aws.amazon.com/privatelink/pricing/).
### Consideraciones sobre la interconexión de VPC
Puede conectar una VPC a otra con puntos de enlace de interfaz mediante [Interconexión con VPC](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html). El emparejamiento de VPC es una conexión de red entre dos VPC. Puede establecer una interconexión de VPC entre dos VPC propias o con una VPC de otra cuenta de AWS. Las VPC también pueden estar en dos regiones de AWS diferentes.
El tráfico entre las VPC emparejadas permanece en la red de AWS y no pasa por la red pública de Internet. Una vez que las VPC están interconectadas, algunos recursos como las instancias de Amazon Elastic Compute Cloud (Amazon EC2), las instancias de Amazon Relational Database Service (Amazon RDS) o las funciones de Lambda habilitadas para VPC pueden acceder a la API de Lambda a través de puntos de enlace de interfaz creados en una de las VPC.
## Creación de un punto de enlace de interfaz para Lambda
Puede crear un punto de enlace de interfaz para Lambda mediante la consola de Amazon VPC o la AWS Command Line Interface (AWS CLI). Para más información, consulte [Creación de un punto de conexión de interfaz](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#create-interface-endpoint) en la *Guía del usuario de Amazon VPC*.
**Para crear un punto de enlace de interfaz para Lambda (consola)**
1. Abra la página [Endpoints (Puntos de enlace)](https://console.aws.amazon.com/vpc/home?#Endpoints) de la consola de Amazon VPC.
1. Seleccione **Crear punto de conexión**.
1. En **Categoría de servicio**, verifique que **Servicios de AWS** esté seleccionada.
1. En **Service Name (Nombre del servicio)**, elija **com.amazonaws.*región*.lambda**. Compruebe que el valor de **Type (Tipo)** es **Interface (Interfaz)**.
1. Elija una VPC y las subredes.
1. Para habilitar un DNS privado para el punto de enlace de interfaz, seleccione **Enable DNS Name (Habilitar nombre de DNS)**, en la casilla de verificación. Le recomendamos que habilite nombres DNS privados para su punto de conexión de VPC para los Servicios de AWS. Esto garantiza que las solicitudes que utilizan los puntos de conexión de servicio público, como las solicitudes realizadas a través de un SDK de AWS, se resuelvan en su punto de conexión de VPC.
1. En **Security group (Grupo de seguridad)**, elija uno o varios grupos de seguridad.
1. Elija **Crear punto de conexión**.
Para poder utilizar la opción de DNS privado, debe definir `enableDnsHostnames` y `enableDnsSupportattributes` en su VPC. Para obtener más información, consulte [Viewing and updating DNS support for your VPC (Visualización y actualización de la compatibilidad de DNS para su VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-updating) en la *Guía del usuario de Amazon VPC*. Si habilita DNS privado para el punto de enlace de interfaz, puede realizar solicitudes a la API para Lambda usando su nombre de DNS predeterminado para la región, por ejemplo `lambda.us-east-1.amazonaws.com`. Para ver otros puntos de enlace de servicio, consulte [Service endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) en la *Referencia general de AWS*.
Para más información, consulte [Acceso a un servicio a través de un punto de conexión de interfaz](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#access-service-though-endpoint) en la *Guía del usuario de Amazon VPC*.
Para obtener información acerca de cómo se crea y configura un punto de enlace mediante CloudFormation, consulte el recurso [AWS::EC2::VPCEndpoint](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html) en la *Guía del usuario de AWS CloudFormation*.
**Si desea crear un punto de enlace de la interfaz para Lambda (AWS CLI)**
Utilice el comando [create-vpc-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html) y especifique el ID de la VPC, el tipo de punto de conexión de VPC (interfaz), el nombre del servicio, las subredes que usarán el punto de conexión y los grupos de seguridad que se asociarán a las interfaces de red del punto de conexión. Por ejemplo:
```
aws ec2 create-vpc-endpoint
--vpc-id vpc-ec43eb89
--vpc-endpoint-type Interface
--service-name com.amazonaws.us-east-1.lambda
--subnet-id subnet-abababab
--security-group-id sg-1a2b3c4d
```
## Creación de una política de punto de enlace de interfaz para Lambda
Para controlar quién puede usar en punto de enlace de la interfaz y a qué funciones de Lambda tiene acceso el usuario, puede asociar una política al punto de enlace. La política especifica la siguiente información:
+ La entidad principal que puede realizar acciones.
+ Acciones que la entidad principal puede realizar.
+ Recursos en los que la entidad principal puede realizar acciones.
Para más información, consulte [Control del acceso a los servicios con puntos de enlace de la VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html) en la *Guía del usuario de Amazon VPC*.
**Ejemplo: Política de puntos de enlace de tipo interfaz para acciones de Lambda**
A continuación, se muestra un ejemplo de una política de puntos de enlace de Lambda. Cuando la política se asocia a un punto de enlace, permite que el usuario `MyUser` invoque la función `my-function`.
**nota**
Debe incluir el ARN completo e incompleto de la función en el recurso.
```
{
"Statement":[
{
"Principal":
{
"AWS": "arn:aws:iam::111122223333:user/MyUser"
},
"Effect":"Allow",
"Action":[
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:us-east-2:123456789012:function:my-function",
"arn:aws:lambda:us-east-2:123456789012:function:my-function:*"
]
}
]
}
```
# Configuración del acceso al sistema de archivos para las funciones de Lambda
Puede configurar una función para montar un sistema de archivos Amazon Elastic File System (Amazon EFS) a un directorio local. Con Amazon EFS, el código de función puede acceder y modificar los recursos compartidos de forma segura y en alta concurrencia.
## Regiones compatibles
Amazon EFS para Lambda está disponible en todas [las regiones comerciales](https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#region) excepto Asia-Pacífico (Nueva Zelanda), Asia-Pacífico (Taipéi), Asia-Pacífico (Malasia), México (centro), Asia-Pacífico (Tailandia) y Oeste de Canadá (Calgary).
**Topics**
+ [
## Regiones compatibles
](#configuration-filesystem-supported-regions)
+ [
## Permisos de usuario y rol de ejecución
](#configuration-filesystem-permissions)
+ [
## Configuración de un sistema de archivos y un punto de acceso
](#configuration-filesystem-setup)
+ [
## Conexión a un sistema de archivos (consola)
](#configuration-filesystem-config)
## Permisos de usuario y rol de ejecución
Si el sistema de archivos no tiene una política de AWS Identity and Access Management (IAM) configurada por el usuario, EFS utiliza una política predeterminada que otorga acceso completo a cualquier cliente que pueda conectarse al sistema de archivos mediante un destino de montaje del sistema de archivos. Si el sistema de archivos tiene una política de IAM configurada por el usuario, el rol de ejecución de la función debe tener los permisos de `elasticfilesystem` correctos.
**Permisos de rol de ejecución**
+ **elasticfilesystem:ClientMount**
+ **elasticfilesystem:ClientWrite (no se necesita para conexiones de solo lectura)**
Estos permisos se incluyen en la política administrada **AmazonElasticFileSystemClientReadWriteAccess**. Además, el rol de ejecución debe tener los [permisos necesarios para conectarse a la VPC del sistema de archivos](configuration-vpc.md#configuration-vpc-permissions).
Cuando configura un sistema de archivos, Lambda utiliza sus permisos para verificar los destinos de montaje. Para configurar una función para conectarse a un sistema de archivos, el usuario necesita los siguientes permisos:
**Permisos de usuario**
+ **elasticfilesystem:DescribeMountTargets**
## Configuración de un sistema de archivos y un punto de acceso
Cree un sistema de archivos en Amazon EFS con un destino de montaje en cada zona de disponibilidad a la que se conecte su función. Para obtener rendimiento y resistencia, utilice al menos dos zonas de disponibilidad. Por ejemplo, en una configuración simple, podría tener una VPC con dos subredes privadas en zonas de disponibilidad separadas. La función se conecta a ambas subredes y un destino de montaje está disponible en cada una. Asegúrese de que los grupos de seguridad utilizados por la función y los destinos de montaje permiten el tráfico NFS (puerto 2049).
**nota**
Cuando crea un sistema de archivos, elige un modo de rendimiento que no se puede cambiar más adelante. El modo **Propósito general** tiene menor latencia, y el modo **E/S Max** admite un rendimiento e IOPS máximos más altos. Para obtener ayuda sobre cómo elegir, consulte [Rendimiento de Amazon EFS](https://docs.aws.amazon.com/efs/latest/ug/performance.html) en la *Guía del usuario de Amazon Elastic File System*.
Un punto de acceso conecta cada instancia de la función con el destino de montaje correcto para la zona de disponibilidad a la que se conecta. Para obtener el mejor rendimiento, cree un punto de acceso con una ruta que no sea raíz y limite el número de archivos que crea en cada directorio. En el siguiente ejemplo se crea un directorio denominado `my-function` en el sistema de archivos y se establece el identificador de propietario en 1001 con permisos de directorio estándar (755).
**Example configuración de punto de acceso**
+ **Nombre** – `files`
+ **ID de usuario** – `1001`
+ **ID del grupo** – `1001`
+ **Ruta** – `/my-function`
+ **Permisos** – `755`
+ **ID de usuario del propietario** – `1001`
+ **ID de usuario de grupo** – `1001`
Cuando una función utiliza el punto de acceso, se le da el ID de usuario 1001 y tiene acceso completo al directorio.
Para obtener más información, consulte los siguientes temas en la *Guía del usuario de Amazon Elastic File System*:
+ [Creación de recursos para Amazon EFS](https://docs.aws.amazon.com/efs/latest/ug/creating-using.html)
+ [Trabajar con usuarios, grupos y permisos](https://docs.aws.amazon.com/efs/latest/ug/accessing-fs-nfs-permissions.html)
## Conexión a un sistema de archivos (consola)
Una función se conecta a un sistema de archivos a través de la red local en una VPC. Las subredes a las que se conecta la función pueden ser las mismas subredes que contienen puntos de montaje para el sistema de archivos, o subredes en la misma zona de disponibilidad que pueden enrutar el tráfico NFS (puerto 2049) al sistema de archivos.
**nota**
Si la función aún no está conectada a una VPC, consulte [Otorgamiento a las funciones de Lambda de acceso a los recursos de una Amazon VPC](configuration-vpc.md).
**Para configurar el acceso al sistema de archivos**
1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija una función.
1. Elija **Configuración** y, a continuación, elija **Sistemas de archivos**.
1. En **Sistema de archivos**, elija **Agregar sistema de archivos**.
1. Configure las siguientes propiedades:
+ **Sistema de archivos EFS**: el punto de acceso para un sistema de archivos de la misma VPC.
+ **Ruta de montaje local**: la ubicación en la que se monta el sistema de archivos en la función de Lambda, empezando por `/mnt/`.
**Precios**
Amazon EFS tiene cargos por almacenamiento y rendimiento, con tarifas que varían según la clase de almacenamiento. Para obtener más información, consulte [Precios de Amazon EFS](https://aws.amazon.com/efs/pricing).
Cargos de Lambda por transferencia de datos entre VPC. Esto solo se aplica si la VPC de su función está pegada a otra VPC con un sistema de archivos. Las tasas son las mismas que para la transferencia de datos de Amazon EC2 entre VPC de la misma región. Para obtener más información, consulte [Precios de Lambda](https://aws.amazon.com/lambda/pricing).
# Crear un alias para una función de Lambda
Puede crear alias para una función de Lambda. Un alias de Lambda es un puntero a una versión de la función que se puede actualizar. Los usuarios de la función pueden acceder a la versión de la función utilizando el nombre de recurso de Amazon (ARN) del alias. Cuando se implementa una versión nueva, se puede actualizar el alias para usar la nueva versión o dividir el tráfico entre dos versiones.
------
#### [ Console ]
**Para crear un alias mediante la consola**
1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija una función.
1. Elija **Alias** y, a continuación, elija **Crear alias**.
1. En la página **Crear alias**, haga lo siguiente:
1. En **Nombre**, escriba el nombre del alias.
1. (Opcional) En **Descripción**, escriba una descripción del alias.
1. En **Versión**, elija la versión de la función a la que desee que apunte el alias.
1. (Opcional) Para configurar el direccionamiento del alias, expanda **Weighted alias (Alias ponderado)**. Para obtener más información, consulte [Aplicar implementaciones canarias de Lambda con un alias ponderado](configuring-alias-routing.md).
1. Elija **Save (Guardar)**.
------
#### [ AWS CLI ]
Para crear un alias a través de AWS Command Line Interface (AWS CLI), utilice el comando [create-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-alias.html).
```
aws lambda create-alias \
--function-name my-function \
--name alias-name \
--function-version version-number \
--description " "
```
Si desea cambiar un alias para que apunte a una nueva versión de la función, utilice el comando [update-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-alias.html).
```
aws lambda update-alias \
--function-name my-function \
--name alias-name \
--function-version version-number
```
Para eliminar un alias, utilice el comando [delete-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/delete-alias.html).
```
aws lambda delete-alias \
--function-name my-function \
--name alias-name
```
Los comandos de la AWS CLI mencionados en los pasos anteriores se corresponden con las siguientes operaciones de la API de Lambda:
+ [CreateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_CreateAlias.html)
+ [UpdateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateAlias.html)
+ [DeleteAlias](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteAlias.html)
------
# Uso de alias de Lambda en las fuentes de eventos y las políticas de permisos
Cada alias tiene un ARN único. Un alias solo puede apuntar a una versión de una función, no a otro alias. Puede actualizar un alias para que apunte a una nueva versión de la función.
Las fuentes de eventos como Amazon Simple Storage Service (Amazon S3) invocan su función Lambda. Estos orígenes de eventos mantienen un mapeo que identifica la función que invocarán cuando se produzcan eventos. Si especifica un alias de función de Lambda en la configuración de mapeo, no es necesario actualizar el mapeo cuando cambie la versión de la función. Para obtener más información, consulte [Cómo procesa Lambda registros de orígenes de eventos basados en secuencias y colas](invocation-eventsourcemapping.md).
En una política de recursos, puede conceder permisos para que las fuentes de eventos utilicen la función de Lambda. Si especifica un ARN de alias en la política, no es necesario que actualice la política cuando cambie la versión de la función.
## Políticas de recursos
Puede utilizar una [política basada en recursos](access-control-resource-based.md) para proporcionar a la función acceso a un servicio, recurso o cuenta. El ámbito de ese permiso dependerá de si se aplica a un alias, a una versión o a toda la función. Por ejemplo, si utiliza un nombre de alias (como `helloworld:PROD`), el permiso le permitirá invocar la función `helloworld` utilizando el ARN del alias (`helloworld:PROD`).
Si intenta invocar la función sin un alias o una versión específica, se producirá un error con los permisos. Este error de los permisos tendrá lugar aunque intente invocar directamente la versión de la función asociada al alias.
Por ejemplo, el siguiente comando de AWS CLI otorga permisos a Amazon S3 para invocar el alias PROD de la función `helloworld` cuando Amazon S3 actúa en nombre de `amzn-s3-demo-bucket`.
```
aws lambda add-permission \
--function-name helloworld \
--qualifier PROD \
--statement-id 1 \
--principal s3.amazonaws.com \
--action lambda:InvokeFunction \
--source-arn arn:aws:s3:::amzn-s3-demo-bucket \
--source-account 123456789012
```
Para obtener más información sobre el uso de nombres de recursos en las políticas, consulte [Afinar las secciones de recursos y condiciones de las políticas](lambda-api-permissions-ref.md).
# Aplicar implementaciones canarias de Lambda con un alias ponderado
Puede utilizar un alias ponderado para dividir el tráfico entre dos [versiones](configuration-versions.md) diferentes de la misma función. Bajo este enfoque, puede probar nuevas versiones de las funciones con un pequeño porcentaje del tráfico y revertir rápidamente si es necesario. Esto se conoce como [implementación canaria](https://docs.aws.amazon.com/whitepapers/latest/overview-deployment-options/canary-deployments.html). Las implementaciones canarias difieren de las azules/verdes en la medida en que exponen la nueva versión únicamente a una parte de las solicitudes, en lugar de cambiar todo el tráfico a la vez.
Puede apuntar un alias a un máximo de dos versiones de una función de Lambda. Las versiones deben cumplir los siguientes criterios:
+ Ambas versiones deben tener el mismo [rol de ejecución](lambda-intro-execution-role.md).
+ Ambas versiones deben tener la misma configuración de [cola de mensajes fallidos](invocation-async-retain-records.md#invocation-dlq) o ninguna configuración de cola de mensajes fallidos.
+ Ambas versiones deben publicarse. El alias no puede apuntar a `$LATEST`.
**nota**
Lambda utiliza un modelo probabilístico simple para distribuir el tráfico entre las dos versiones de funciones. En niveles de tráfico bajos, es posible que vea una gran variación entre el porcentaje configurado y el porcentaje real de tráfico en cada versión. Si su función utiliza la concurrencia aprovisionada, puede evitar [Invocaciones de casos de superación](monitoring-metrics-types.md#invocation-metrics) configurando un mayor número de instancias de simultaneidad aprovisionadas durante el tiempo en que el enrutamiento de alias está activo.
## Creación de un alias ponderado
------
#### [ Console ]
**Para configurar el direccionamiento en un alias con la consola**
**nota**
Verifique que la función tenga al menos dos versiones publicadas. Si necesita crear otras versiones, siga las instrucciones que se indican en [Creación de versiones de funciones](configuration-versions.md#configuration-versions-config).
1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija una función.
1. Elija **Alias** y, a continuación, elija **Crear alias**.
1. En la página **Crear alias**, haga lo siguiente:
1. En **Nombre**, escriba el nombre del alias.
1. (Opcional) En **Descripción**, escriba una descripción del alias.
1. En **Versión**, elija la primera versión de la función a la que desea que apunte el alias.
1. Expanda **Weighted alias (Alias ponderados)**.
1. En **Versión adicional**, elija la segunda versión de la función a la que desea que apunte el alias.
1. En **Weight (%) [Ponderación (%)]**, especifique la ponderación de la función. La *ponderación* es el porcentaje de tráfico que se asigna a dicha versión cuando se invoca el alias. La primera versión recibe la ponderación residual. Por ejemplo, si especifica un 10 por ciento en **Additional version (Versión adicional)**, a la primera versión se asigna automáticamente el 90 %.
1. Seleccione **Save**.
------
#### [ AWS CLI ]
Utilice los comandos [create-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-alias.html) y [update-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-alias.html) de AWS CLI para configurar las ponderaciones de tráfico entre dos versiones de funciones. Cuando se crea o actualiza el alias, se especifica la ponderación del tráfico en el parámetro `routing-config`.
En el ejemplo siguiente se crea un alias de una función de Lambda llamado **routing-alias** que apunta a la versión 1 de la función. La versión 2 de la función recibe el 3 por ciento del tráfico. El 97 por ciento restante del tráfico se dirige a la versión 1.
```
aws lambda create-alias \
--name routing-alias \
--function-name my-function \
--function-version 1 \
--routing-config AdditionalVersionWeights={"2"=0.03}
```
Utilice el comando `update-alias` para aumentar el porcentaje de tráfico entrante a la versión 2. En el ejemplo siguiente, aumenta el tráfico al 5 por ciento.
```
aws lambda update-alias \
--name routing-alias \
--function-name my-function \
--routing-config AdditionalVersionWeights={"2"=0.05}
```
So desea dirigir todo el tráfico a la versión 2, utilice el comando `update-alias` para cambiar la propiedad `function-version` y dirigir el alias a la versión 2. El comando también restablece la configuración de direccionamiento.
```
aws lambda update-alias \
--name routing-alias \
--function-name my-function \
--function-version 2 \
--routing-config AdditionalVersionWeights={}
```
Los comandos de la AWS CLI mencionados en los pasos anteriores se corresponden con las siguientes operaciones de la API de Lambda:
+ [CreateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_CreateAlias.html)
+ [UpdateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateAlias.html)
------
## Cómo saber qué versión se invocó
Al configurar las ponderaciones de tráfico entre dos versiones de función, hay dos formas de determinar la versión de la función de Lambda que se ha invocado:
+ **Registros de CloudWatch:** Lambda emite automáticamente una entrada de registro `START` que contiene el ID de la versión invocada para cada invocación de función. Ejemplo:
`START RequestId: 1dh194d3759ed-4v8b-a7b4-1e541f60235f Version: 2`
En las invocaciones de alias, Lambda utiliza la dimensión `ExecutedVersion` para filtrar los datos de las métricas por la versión ejecutada. Para obtener más información, consulte [Visualización de métricas para funciones de Lambda](monitoring-metrics-view.md).
+ **Carga de respuesta (invocaciones sincrónicas)**: las respuestas a invocaciones de funciones sincrónicas incluyen un encabezado `x-amz-executed-version` para indicar qué versión de función se ha invocado.
## Creación de una implementación continua con alias ponderados
Utilice AWS CodeDeploy y AWS Serverless Application Model (AWS SAM) para crear una implementación continua que detecte automáticamente los cambios en el código de la función, implemente una nueva versión de la función y aumente gradualmente la cantidad de tráfico que fluye hacia la nueva versión. La cantidad de tráfico y la tasa de aumento son parámetros que puede configurar.
En una implementación continua, AWS SAM realiza las siguientes tareas:
+ Configura la función de Lambda y crea un alias. La configuración de direccionamiento de alias ponderado es la capacidad subyacente que implementa la implementación continua.
+ Crea una aplicación CodeDeploy y un grupo de implementación. El grupo de implementación administra la implementación continua y la reversión, si es necesario.
+ Detecta cuando se crea una nueva versión de la función de Lambda.
+ Activa CodeDeploy para iniciar la implementación de la nueva versión.
### Plantilla de AWS SAM de ejemplo
En el siguiente ejemplo se muestra una [plantilla de AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html) para una implementación continua simple.
```
AWSTemplateFormatVersion : '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: A sample SAM template for deploying Lambda functions
Resources:
# Details about the myDateTimeFunction Lambda function
myDateTimeFunction:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
Handler: myDateTimeFunction.handler
Runtime: nodejs24.x
# Creates an alias named "live" for the function, and automatically publishes when you update the function.
AutoPublishAlias: live
DeploymentPreference:
# Specifies the deployment configuration
Type: Linear10PercentEvery2Minutes
```
Esta plantilla define una función de Lambda denominada `myDateTimeFunction` con las siguientes propiedades.
**AutoPublishAlias **
La propiedad `AutoPublishAlias` crea un alias denominado `live`. Además, el marco de AWS SAM detecta automáticamente cuando guarda código nuevo para la función. A continuación, el marco publica una nueva versión de función y actualiza el alias `live` para que apunte a la nueva versión.
**DeploymentPreference**
La propiedad `DeploymentPreference` determina la velocidad a la que la aplicación CodeDeploy cambia el tráfico de la versión original de la función de Lambda a la nueva versión. El valor `Linear10PercentEvery2Minutes` desplaza un diez por ciento adicional del tráfico a la nueva versión cada dos minutos.
Para obtener una lista de las configuraciones de implementación predefinidas, consulte [Configuraciones de implementación](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-configurations.html).
Para obtener más información sobre cómo crear implementaciones continuas con CodeDeploy y AWS SAM, consulte lo siguiente:
+ [Tutorial: Implementación de una función de Lambda actualizada con CodeDeploy y el AWS Serverless Application Model](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-lambda-sam.html)
+ [Implementación de aplicaciones sin servidor de forma gradual con AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/automating-updates-to-serverless-apps.html)
# Administrar las versiones de la función de Lambda
Puede usar versiones para administrar la implementación de funciones. Por ejemplo, puede publicar una nueva versión de una función para pruebas beta sin afectar a los usuarios de la versión de producción estable. Lambda crea una nueva versión de la función de cada vez que se publica la función. La nueva versión es una copia de la versión no publicada de la función. La versión no publicada se denomina `$LATEST`.
Es importante destacar que cada vez que despliega el código de su función, sobrescribe el código actual en `$LATEST`. Para guardar la iteración actual de `$LATEST`, cree una nueva versión de la función. Si `$LATEST` es idéntica a una versión publicada anteriormente, no podrá crear una nueva versión hasta que implemente los cambios en `$LATEST`. Estos cambios pueden incluir la actualización del código o la modificación de los ajustes de la función.
Tras publicar la versión de una función, su código, tiempo de ejecución, arquitectura, memoria, capas y la mayoría de las demás configuraciones son inmutables. Esto significa que no puede cambiar estas configuraciones sin publicar una nueva versión de `$LATEST`. Puede configurar los siguientes elementos para una versión de función publicada:
+ [Desencadenadores](lambda-services.md#lambda-invocation-trigger)
+ [Destinos](invocation-async-retain-records.md#create-destination)
+ [Simultaneidad aprovisionada](provisioned-concurrency.md)
+ [Invocación asincrónica](invocation-async.md)
+ [Conexiones y proxies de bases de datos](services-rds.md#rds-configuration)
**nota**
Cuando se utilizan los [controles de administración del tiempo de ejecución](runtimes-update.md#runtime-management-controls) con el modo **Automático**, la versión del tiempo de ejecución utilizada por la versión de la función se actualiza automáticamente. Cuando se utilizan los modos **Function update** (Actualización de funciones) o **Manual**, no se actualiza la versión del tiempo de ejecución. Para obtener más información, consulte [Cómo entender la forma en que Lambda administra las actualizaciones de las versiones de tiempo de ejecución](runtimes-update.md).
**Topics**
+ [
## Creación de versiones de funciones
](#configuration-versions-config)
+ [
## Uso de versiones
](#versioning-versions-using)
+ [
## Concesión de permisos
](#versioning-permissions)
## Creación de versiones de funciones
Puede cambiar el código y la configuración de la función solo en la versión no publicada de una función. Cuando se publica una versión, Lambda bloquea el código y la mayoría de las opciones de configuración para garantizar una experiencia uniforme a los usuarios de dicha versión.
Puede crear una versión de función usando la consola de Lambda.
**Para crear una nueva versión de función**
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija una función y, a continuación, elija la pestaña **Versiones**.
1. En la página de configuración de versiones, elija **Publicar nueva versión**.
1. (Opcional) Especifique una descripción de la versión.
1. Elija **Publicar**.
También puede publicar una versión de una función con la operación de la API [PublishVersion](https://docs.aws.amazon.com/lambda/latest/api/API_PublishVersion.html).
El siguiente comando AWS CLI publica una nueva versión de una función. La respuesta devuelve la información de configuración sobre la nueva versión, incluido el número de la versión y el ARN de la función con el sufijo de la versión.
```
aws lambda publish-version --function-name my-function
```
Debería ver los siguientes datos de salida:
```
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function:1",
"Version": "1",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Handler": "function.handler",
"Runtime": "nodejs24.x",
...
}
```
**nota**
Lambda asigna números de secuencia que aumentan de manera monótona para el control de versiones. Lambda nunca vuelve a utilizar los números de versión, ni siquiera después de eliminar y volver a crear una función.
## Uso de versiones
Puede hacer referencia a la función de Lambda utilizando un ARN completo o incompleto.
+ **ARN completo**: ARN de la función con el sufijo de la versión. El siguiente ejemplo hace referencia a la versión 42 de la función `helloworld`.
```
arn:aws:lambda:aws-region:acct-id:function:helloworld:42
```
+ **ARN incompleto**: ARN de la función sin el sufijo de la versión.
```
arn:aws:lambda:aws-region:acct-id:function:helloworld
```
Puede utilizar un ARN completo o incompleto en todas las operaciones de API que corresponda. Sin embargo, no puede utilizar un ARN incompleto para crear un alias.
Si decide no publicar versiones de las funciones, puede utilizar tanto el ARN completo como incompleto en la [asignación de orígenes de eventos](invocation-eventsourcemapping.md). Cuando se invoca una función usando un ARN incompleto, Lambda invoca `$LATEST` implícitamente.
El ARN completo de cada versión de una función de Lambda es único. Después de publicar una versión, no puede cambiar el ARN o el código de función.
Lambda solo publica una nueva versión de la función si el código nunca se ha publicado o si este ha cambiado desde la última versión publicada. Si no hay ningún cambio, la versión de la función sigue siendo la que se publicó más recientemente.
Al publicar una versión, Lambda crea una instantánea inmutable del código y de la configuración de la función. No todos los cambios de configuración provocan la publicación de una nueva versión. Los siguientes cambios de configuración permiten que una función se publique en una versión:
+ Código de función
+ Variables de entorno
+ Tiempo de ejecución
+ Controlador
+ Capas
+ Tamaño de memoria
+ Tiempo de espera
+ Configuración de la VPC
+ Configuración de cola de mensajes fallidos (DLQ)
+ rol de IAM
+ Descripción
+ Arquitectura (x86\$164 o arm64)
+ Tamaño de almacenamiento efímero
+ Tipo de paquete
+ Configuración de registro
+ Configuración del sistema de archivos
+ SnapStart
+ Configuración de seguimiento
Los ajustes operativos, como la [simultaneidad reservada](configuration-concurrency.md), no activan la publicación de una nueva versión cuando se modifican.
## Concesión de permisos
Puede utilizar una [política basada en recursos](access-control-resource-based.md) o una [política basada en identidades](access-control-identity-based.md) para conceder acceso a la función. El ámbito del permiso dependerá de si la política se aplica a una función o a una versión de la función. Para obtener más información sobre los nombres de recursos de funciones en las políticas, consulte [Afinar las secciones de recursos y condiciones de las políticas](lambda-api-permissions-ref.md).
Puede simplificar la administración de los orígenes de eventos y las políticas de AWS Identity and Access Management (IAM) utilizando un alias de función. Para obtener más información, consulte [Crear un alias para una función de Lambda](configuration-aliases.md).
# Uso de etiquetas en funciones de Lambda
Puede etiquetar funciones para organizar y administrar los recursos. Las etiquetas son pares de clave-valor de formato libre que se asocian a los recursos y que son compatibles con todos los Servicios de AWS. Para obtener más información sobre los casos de uso de las etiquetas, consulte [Estrategias de etiquetado habituales](https://docs.aws.amazon.com//tag-editor/latest/userguide/best-practices-and-strats.html#tag-strategies) en la *Guía del editor de etiquetas y recursos de etiquetado de AWS*.
Las etiquetas se aplican en el nivel de las funciones, no de las versiones ni de los alias. Las etiquetas no forman parte de la configuración específica de la versión que AWS Lambda crea una instantánea al publicar una versión. Puede usar la API de Lambda para ver y actualizar las etiquetas. También puede ver y actualizar las etiquetas mientras administra una función específica en la consola de Lambda.
**Topics**
+ [
## Permisos necesarios para trabajar con etiquetas
](#fxn-tags-required-permissions)
+ [
## Uso de etiquetas con la consola de Lambda
](#using-tags-with-the-console)
+ [
## Uso de etiquetas con la AWS CLI
](#configuration-tags-cli)
## Permisos necesarios para trabajar con etiquetas
Para permitir que una identidad de AWS Identity and Access Management (IAM) (usuario, grupo o rol) lea o establezca etiquetas en un recurso, conceda los permisos correspondientes:
+ **lambda:ListTags**: cuando un recurso tiene etiquetas, conceda este permiso a cualquier persona que necesite llamar a `ListTags` en este. En el caso de las funciones etiquetadas, este permiso también es necesario para `GetFunction`.
+ **lambda:TagResource**: conceda este permiso a cualquier persona que necesite llamar a `TagResource` o efectuar una etiqueta en la creación.
Si lo desea, considere conceder el permiso **lambda:UntagResource** y permitir las llamadas `UntagResource` al recurso.
Para obtener más información, consulte [Políticas de IAM basadas en identidad para Lambda](access-control-identity-based.md).
## Uso de etiquetas con la consola de Lambda
Puede utilizar la consola de Lambda para crear funciones que tengan etiquetas, agregar etiquetas a funciones existentes y filtrar funciones por las etiquetas que se agregan.
**Para agregar etiquetas al momento de crear una función**
1. Abra la página de [Functions](https://console.aws.amazon.com/lambda/home#/functions) (Funciones) en la consola de Lambda.
1. Elija **Crear función**.
1. Elija **Author from scratch** (Crear desde cero) o **Container image** (Imagen de contenedor).
1. En **Información básica**, configure la función. Para obtener más información acerca de la configuración de funciones, consulte [Configuración de funciones de AWS Lambda](lambda-functions.md).
1. Expanda **Advanced settings** (Configuración avanzada) y, a continuación, seleccione **Enable tags** (Habilitar etiquetas).
1. Elija **Add new tag** (Agregar nueva etiqueta) y, a continuación, escriba una **clave** y el **valor** opcional. Para añadir más etiquetas, repita este paso.
1. Seleccione **Creación de función**.
**Para agregar etiquetas a una función existente**
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija el nombre de una función.
1. Elija **Configuration** (Configuración) y, a continuación, elija **Tags** (Etiquetas).
1. En **Etiquetas**, elija **Administrar etiquetas**.
1. Elija **Add new tag** (Agregar nueva etiqueta) y, a continuación, escriba una **clave** y el **valor** opcional. Para añadir más etiquetas, repita este paso.
1. Seleccione **Save**.
**Para filtrar funciones con etiquetas**
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija el cuadro de búsqueda para ver una lista de las propiedades de función y las claves de etiqueta.
1. Elija una clave de etiqueta para ver la lista de valores que están en uso en la región de AWS actual.
1. Seleccione **Usar: "etiqueta-nombre"** para ver todas las funciones etiquetadas con esta clave o elija un **operador** para filtrar aún más por valor.
1. Seleccione el valor de la etiqueta para filtrarla por una combinación de clave y valor de la etiqueta.
La barra de búsqueda también permite buscar claves de etiqueta. Escriba `tag` para ver de forma exclusiva una lista de claves de etiqueta o escriba el nombre de una clave para encontrarla en la lista.
## Uso de etiquetas con la AWS CLI
Puede agregar y eliminar etiquetas en los recursos de Lambda existentes, incluidas las funciones, con la API de Lambda. También puede agregar etiquetas al crear una función, lo que le permite mantener un recurso etiquetado durante todo su ciclo de vida.
### Actualización de etiquetas con las API de etiquetas de Lambda
Puede agregar y eliminar etiquetas para los recursos de Lambda compatibles mediante las operaciones de API [TagResource](https://docs.aws.amazon.com/lambda/latest/api/API_TagResource.html) y [UntagResource](https://docs.aws.amazon.com/lambda/latest/api/API_UntagResource.html).
También puede llamar a estas operaciones mediante la AWS CLI. Para agregar etiquetas a un recurso existente, utilice el comando `tag-resource`. En este ejemplo se agregan dos etiquetas, una con la clave *Department* y otra con la clave *CostCenter*.
```
aws lambda tag-resource \
--resource arn:aws:lambda:us-east-2:123456789012:resource-type:my-resource \
--tags Department=Marketing,CostCenter=1234ABCD
```
Para eliminar etiquetas, utilice el comando `untag-resource`. En este ejemplo, se elimina la etiqueta con la clave *Department*.
```
aws lambda untag-resource --resource arn:aws:lambda:us-east-1:123456789012:resource-type:resource-identifier \
--tag-keys Department
```
### Adición de etiquetas al crear una función
Para crear una nueva función de Lambda con etiquetas, utilice la operación de la API [CreateFunction](https://docs.aws.amazon.com//lambda/latest/api/API_CreateFunction.html). Especifique el parámetro `Tags`. Puede llamar a esta operación con el comando `create-function` de la CLI y la opción --tags. Antes de usar el parámetro de etiquetas con `CreateFunction`, asegúrese de que su rol tenga permiso para etiquetar los recursos junto con los permisos habituales necesarios para esta operación. Para obtener más información sobre permisos de etiquetado, consulte [Permisos necesarios para trabajar con etiquetas](#fxn-tags-required-permissions). En este ejemplo se agregan dos etiquetas, una con la clave *Department* y otra con la clave *CostCenter*.
```
aws lambda create-function --function-name my-function
--handler index.js --runtime nodejs24.x \
--role arn:aws:iam::123456789012:role/lambda-role \
--tags Department=Marketing,CostCenter=1234ABCD
```
### Visualización de etiquetas de una función
Para ver las etiquetas que se aplican a un recurso de Lambda específico, utilice la operación de la API `ListTags`. Para obtener más información, consulte [ListTags](https://docs.aws.amazon.com/lambda/latest/api/API_ListTags.html).
Puede llamar a esta operación con el comando `list-tags` de la AWS CLI si proporciona un ARN (nombre de recurso de Amazon).
```
aws lambda list-tags --resource arn:aws:lambda:us-east-1:123456789012:resource-type:resource-identifier
```
Puede ver las etiquetas que se aplican a un recurso específico con la operación de la API de [GetFunction](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html). No hay funcionalidades comparables disponibles para otros tipos de recursos.
Puede llamar a esta operación mediante el comando `get-function` de la CLI:
```
aws lambda get-function --function-name my-function
```
### Filtrado de recursos por etiqueta
Puede utilizar la operación de la API de AWS Resource Groups Tagging API [GetResources](https://docs.aws.amazon.com/resourcegroupstagging/latest/APIReference/API_GetResources.html) para filtrar los recursos por etiquetas. La operación `GetResources` recibe hasta 10 filtros y cada uno contiene una clave de etiqueta y hasta 10 valores de etiqueta. Usted proporciona `GetResources` con un `ResourceType` para filtrar por tipos de recurso específicos.
Puede llamar a esta operación mediante el comando `get-resources` de la AWS CLI. Para ver ejemplos de uso de `get-resources`, consulte [get-resources](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/resourcegroupstaggingapi/get-resources.html#examples) en la *Referencia de comandos de la AWS CLI*.
# Transmisión de respuestas para funciones de Lambda
Las funciones de Lambda pueden transmitir nativamente las cargas útiles de respuesta a los clientes a través de las [URL de las funciones de Lambda](urls-configuration.md) o mediante la API [InvokeWithResponseStream](https://docs.aws.amazon.com/lambda/latest/api/API_InvokeWithResponseStream.html) (a través de AWS SDK o llamadas directas a la API). La función de Lambda también puede transmitir cargas útiles de respuesta a través de la [integración de proxy de Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/response-transfer-mode-lambda.html), que utiliza la API [InvokeWithResponseStream](https://docs.aws.amazon.com/lambda/latest/api/API_InvokeWithResponseStream.html) para invocar la función. La transmisión de respuestas puede beneficiar a las aplicaciones sensibles a la latencia al mejorar el rendimiento del tiempo hasta el primer byte (TTFB). Esto se debe a que puede volver respuestas parciales al cliente a medida que estén disponibles. Además, las funciones de transmisión de respuestas pueden devolver cargas útiles de hasta 200 MB, en comparación con el máximo de 6 MB para las respuestas almacenadas en búfer. Transmitir una respuesta también significa que la función no necesita incluir toda la respuesta en la memoria. Para respuestas muy grandes, esto puede reducir la cantidad de memoria que necesita configurar para la función.
**nota**
El flujo de respuesta de Lambda todavía no está disponible en todas las Regiones de AWS. Consulte las [Capacidades de AWS por región](https://builder.aws.com/build/capabilities) de Builder Center para ver la disponibilidad de las características por región.
La velocidad a la que Lambda transmite las respuestas depende del tamaño de la respuesta. La velocidad de transmisión de los primeros 6 MB de la respuesta de la función es ilimitada. Para las respuestas de más de 6 MB, el resto de la respuesta está sujeto a un límite de ancho de banda. Para obtener más información sobre el ancho de banda de transmisión, consulte [Límites de ancho de banda para la transmisión de respuestas](#config-rs-bandwidth-cap).
El flujo de respuesta conlleva un costo y las respuestas transmitidas no se interrumpen ni se detienen cuando se interrumpe la conexión del cliente que las invoca. A los clientes se les facturará por la duración total de la función, por lo que los clientes deben tener cuidado al configurar tiempos de espera prolongados de las funciones.
Lambda admite la transmisión de respuestas en tiempos de ejecución administrados por Node.js. Para otros lenguajes, como Python, puede [utilizar un tiempo de ejecución personalizado con una integración de API de tiempo de ejecución personalizada](runtimes-custom.md#runtimes-custom-response-streaming) para lograr el flujo de respuesta o utilizar [Lambda Web Adapter](https://github.com/awslabs/aws-lambda-web-adapter).
**nota**
Cuando pruebe la función en la consola de Lambda, siempre verá las respuestas en búfer.
**Topics**
+ [
## Límites de ancho de banda para la transmisión de respuestas
](#config-rs-bandwidth-cap)
+ [
## Compatibilidad de VPC con transmisión de respuestas
](#config-rs-vpc-compatibility)
+ [
# Escritura de funciones de Lambda habilitadas para la transmisión de respuestas
](config-rs-write-functions.md)
+ [
# Invocación de una función habilitada para la transmisión de respuestas con URL de la función de Lambda
](config-rs-invoke-furls.md)
+ [
# Tutorial: Creación de una función de Lambda de transmisión de respuesta con una URL de función
](response-streaming-tutorial.md)
## Límites de ancho de banda para la transmisión de respuestas
Los primeros 6 MB de la carga útil de respuesta de la función tienen un ancho de banda ilimitado. Tras esta ráfaga inicial, Lambda transmite la respuesta a una velocidad máxima de 2 MBps. Si las respuestas de la función nunca superan los 6 MB, este límite de ancho de banda nunca se aplica.
**nota**
Los límites de ancho de banda solo se aplican a la carga de respuesta de la función y no al acceso de la función a la red.
La velocidad del ancho de banda ilimitado varía en función de diversos factores, incluida la velocidad de procesamiento de la función. Por lo general, puede esperar una velocidad superior a 2 MBps para los primeros 6 MB de respuesta de la función. Si la función transmite una respuesta a un destino externo a AWS, la velocidad de transmisión también depende de la velocidad de la conexión a Internet externa.
## Compatibilidad de VPC con transmisión de respuestas
Cuando se utilizan funciones de Lambda en un entorno de VPC, hay consideraciones importantes para la transmisión de respuestas:
+ Las URL de las funciones de Lambda no admiten la transmisión de respuestas en un entorno de VPC.
+ Puede utilizar la transmisión de respuestas dentro de una VPC invocando su función de Lambda a través del SDK de AWS mediante la API `InvokeWithResponseStream`. Esto requiere configurar los puntos de conexión de VPC adecuados para Lambda.
+ Para los entornos de VPC, tendrá que crear un punto de conexión de VPC de interfaz para Lambda que permita la comunicación entre los recursos de la VPC y el servicio de Lambda.
Una arquitectura típica para la transmisión de respuestas en una VPC podría incluir:
```
Client in VPC -> Interface VPC endpoint for Lambda -> Lambda function -> Response streaming back through the same path
```
# Escritura de funciones de Lambda habilitadas para la transmisión de respuestas
Escribir el controlador para las funciones de transmisión de respuestas es diferente a escribir los patrones de controlador típicos. Al escribir funciones de transmisión, asegúrese de realizar lo siguiente:
+ Encapsula la función con el decorador `awslambda.streamifyResponse()`. El entorno de tiempo de ejecución Node.js de Lambda proporciona el objeto global `awslambda`.
+ Finalice la transmisión de manera correcta para asegurarse de que se haya completado todo el procesamiento de datos.
## Configuración de una función de controlador para transmitir respuestas
Para indicar al tiempo de ejecución que Lambda debe transmitir las respuestas de su función, debe ajustar la función al decorador `streamifyResponse()`. Esto indica al tiempo de ejecución que utilice la ruta lógica adecuada para transmitir las respuestas y permite que la función transmita las respuestas.
El decorador `streamifyResponse()` acepta una función que acepta los siguientes parámetros:
+ `event`: proporciona información sobre el evento de invocación de la URL de función, como el método HTTP, los parámetros de consulta y el cuerpo de la solicitud.
+ `responseStream`: proporciona una transmisión con escritura permitida.
+ `context`: proporciona métodos y propiedades con información acerca de la invocación, la función y el entorno de ejecución.
El objeto `responseStream` es un [`writableStream` de Node.js](https://nodesource.com/blog/understanding-streams-in-nodejs/). Al igual que con cualquier transmisión de este tipo, debe utilizar el método `pipeline()`.
**nota**
El entorno de tiempo de ejecución Node.js de Lambda proporciona automáticamente el objeto global `awslambda` y no se requiere ninguna importación.
**Example controlador habilitado para transmisión de respuestas**
```
import { pipeline } from 'node:stream/promises';
import { Readable } from 'node:stream';
export const echo = awslambda.streamifyResponse(async (event, responseStream, _context) => {
// As an example, convert event to a readable stream.
const requestStream = Readable.from(Buffer.from(JSON.stringify(event)));
await pipeline(requestStream, responseStream);
});
```
Si bien `responseStream` ofrece el método `write()` para escribir en la transmisión, le recomendamos que utilice [https://nodejs.org/api/stream.html#streampipelinesource-transforms-destination-callback](https://nodejs.org/api/stream.html#streampipelinesource-transforms-destination-callback) siempre que sea posible. El uso de `pipeline()` garantiza que la transmisión con escritura permitida no se sature por una transmisión legible más rápida.
## Finalización de la transmisión
Asegúrese de finalizar la transmisión correctamente antes de que el controlador regrese. El método `pipeline()` gestiona esto de manera automática.
Para otros casos de uso, llame al método `responseStream.end()` para finalizar correctamente una transmisión. Este método indica que no se deben escribir más datos en la transmisión. Este método no es necesario si escribe a la transmisión con `pipeline()` o `pipe()`.
A partir de Node.js 24, Lambda ya no espera a que se cumplan las promesas no resueltas una vez que el controlador regrese o finalice el flujo de respuesta. Si su función depende de operaciones asíncronas adicionales, como temporizadores o recuperaciones, debería incluirlas en la `await` de su controlador.
**Example Ejemplo de finalización de una transmisión con pipeline()**
```
import { pipeline } from 'node:stream/promises';
export const handler = awslambda.streamifyResponse(async (event, responseStream, _context) => {
await pipeline(requestStream, responseStream);
});
```
**Example Ejemplo de finalización de una transmisión sin pipeline()**
```
export const handler = awslambda.streamifyResponse(async (event, responseStream, _context) => {
responseStream.write("Hello ");
responseStream.write("world ");
responseStream.write("from ");
responseStream.write("Lambda!");
responseStream.end();
});
```
# Invocación de una función habilitada para la transmisión de respuestas con URL de la función de Lambda
**nota**
Su función de Lambda ahora puede transmitir cargas útiles de respuesta a través de la [integración de proxy de Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/response-transfer-mode-lambda.html).
Puede invocar funciones habilitadas para la transmisión de respuestas si cambia el modo de invocación de la URL de función. El modo de invocación determina qué operación de API utiliza Lambda para invocar la función. Estos son los modos de invocación disponibles:
+ `BUFFERED`: esta es la opción predeterminada. Lambda invoca su función mediante la operación de la API `Invoke`. Los resultados de la invocación estarán disponibles cuando se complete la carga. El tamaño de carga máximo es de 6 MB.
+ `RESPONSE_STREAM`: permite que la función transmita los resultados de la carga a medida que estén disponibles. Lambda invoca su función mediante la operación de la API `InvokeWithResponseStream`. El tamaño máximo de carga útil de respuesta es de 200 MB.
Aún puede invocar la función sin transmisión de respuestas al llamar directamente a la operación de la API `Invoke`. Sin embargo, Lambda transmite todas las cargas de respuesta para las invocaciones que llegan a través de la URL de función hasta que cambie el modo de invocación a `BUFFERED`.
------
#### [ Console ]
**Para establecer el modo de invocación de una URL de función (consola)**
1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija el nombre de la función para la que desea establecer el modo de invocación.
1. Elija la pestaña **Configuration** (Configuración) y, a continuación, elija **Function URL** (URL de función).
1. Elija **Editar** y, a continuación, elija **Configuración adicional**.
1. En **Modo de invocación**, elija el modo de invocación que desee.
1. Seleccione **Save**.
------
#### [ AWS CLI ]
**Para establecer el modo de invocación de la URL de una función (AWS CLI)**
```
aws lambda update-function-url-config \
--function-name my-function \
--invoke-mode RESPONSE_STREAM
```
------
#### [ CloudFormation ]
**Para establecer el modo de invocación de la URL de una función (CloudFormation)**
```
MyFunctionUrl:
Type: AWS::Lambda::Url
Properties:
AuthType: AWS_IAM
InvokeMode: RESPONSE_STREAM
```
------
Para obtener más información acerca de la configuración de las URL de función, consulte las [URL de función de Lambda](urls-configuration.md).
# Tutorial: Creación de una función de Lambda de transmisión de respuesta con una URL de función
En este tutorial, se crea una función de Lambda definida como un archivo .zip con un punto de conexión de URL de función que devuelve una transmisión de respuesta. Para obtener más información acerca de la configuración de las URL de funciones, consulte [URL de funciones](urls-configuration.md).
## Requisitos previos
En este tutorial, se presupone que tiene algunos conocimientos sobre las operaciones básicas de Lambda y la consola de Lambda. Si aún no lo ha hecho, siga las instrucciones de [Cree una función de Lambda con la consola.](getting-started.md#getting-started-create-function) para crear su primera función de Lambda.
Para completar los siguientes pasos, necesita la [versión 2 de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). Los comandos y la salida esperada se enumeran en bloques separados:
```
aws --version
```
Debería ver los siguientes datos de salida:
```
aws-cli/2.13.27 Python/3.11.6 Linux/4.14.328-248.540.amzn2.x86_64 exe/x86_64.amzn.2
```
Para comandos largos, se utiliza un carácter de escape (`\`) para dividir un comando en varias líneas.
En Linux y macOS, use su administrador de intérprete de comandos y paquetes preferido.
**nota**
En Windows, algunos comandos de la CLI de Bash que se utilizan habitualmente con Lambda (por ejemplo, `zip`) no son compatibles con los terminales integrados del sistema operativo. Para obtener una versión de Ubuntu y Bash integrada con Windows, [instale el subsistema de Windows para Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Los comandos de la CLI de ejemplo de esta guía utilizan el formato Linux. Los comandos que incluyen documentos JSON en línea deben reformatearse si utiliza la CLI de Windows.
## Creación de un rol de ejecución
Cree el [rol de ejecución](lambda-intro-execution-role.md) que concederá a su función de Lambda permiso para obtener acceso a los recursos de AWS.
**Para crear un rol de ejecución**
1. Abra la página de [Roles](https://console.aws.amazon.com/iam/home#/roles) de la consola de AWS Identity and Access Management (IAM).
1. Elija **Creación de rol**.
1. Cree un rol con las propiedades siguientes:
+ **Tipo de entidad de confianza**: **servicio de AWS**
+ **Caso de uso**: **Lambda**
+ **Permisos**: **AWSLambdaBasicExecutionRole**
+ **Role name (Nombre de rol** – **response-streaming-role**
La política **AWSLambdaBasicExecutionRole** tiene permisos que la función necesita para escribir registros a Registros de Amazon CloudWatch. Después de crear el rol, anote su nombre de recurso de Amazon (ARN). Lo necesitará en el siguiente paso.
## Crear una función de transmisión de respuestas (AWS CLI)
Cree una función de Lambda de transmisión de respuesta con un punto de conexión de URL de función mediante la AWS Command Line Interface (AWS CLI).
**Para crear una función que pueda transmitir respuestas**
1. Copie el siguiente código de ejemplo en un archivo denominado `index.js`. Esta función transmite tres respuestas, separadas por 1 segundo.
```
exports.handler = awslambda.streamifyResponse(
async (event, responseStream, _context) => {
// Metadata is a JSON serializable JS object. Its shape is not defined here.
const metadata = {
statusCode: 200,
headers: {
"Content-Type": "application/json",
"CustomHeader": "outerspace"
}
};
// Assign to the responseStream parameter to prevent accidental reuse of the non-wrapped stream.
responseStream = awslambda.HttpResponseStream.from(responseStream, metadata);
responseStream.write("Streaming with Helper \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.write("Hello 0 \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.write("Hello 1 \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.write("Hello 2 \n");
await new Promise(r => setTimeout(r, 1000));
responseStream.end();
await responseStream.finished();
}
);
```
1. Cree un paquete de implementación.
```
zip function.zip index.js
```
1. Cree una función de Lambda con el comando `create-function`. Reemplace el valor de `--role` por el ARN del rol del paso anterior. Este comando establece el tiempo de espera de la función en 10 segundos, lo que le permite transmitir tres respuestas.
```
aws lambda create-function \
--function-name my-streaming-function \
--runtime nodejs24.x \
--zip-file fileb://function.zip \
--handler index.handler \
--timeout 10 \
--role arn:aws:iam::123456789012:role/response-streaming-role
```
**Para crear una URL de función**
1. Agregue una política basada en recursos a la función que otorgue permisos`lambda:InvokeFunctionUrl` y `lambda:InvokeFunction`. Cada declaración debe añadirse en un comando independiente. Reemplace el valor de `--principal` por su ID de Cuenta de AWS.
```
aws lambda add-permission \
--function-name my-streaming-function \
--action lambda:InvokeFunctionUrl \
--statement-id UrlPolicyInvokeURL \
--principal 123456789012 \
--function-url-auth-type AWS_IAM
```
```
aws lambda add-permission \
--function-name my-streaming-function \
--action lambda:InvokeFunction \
--statement-id UrlPolicyInvokeFunction \
--principal 123456789012
```
1. Cree un punto de conexión de la URL para la función con el comando `create-function-url-config`.
```
aws lambda create-function-url-config \
--function-name my-streaming-function \
--auth-type AWS_IAM \
--invoke-mode RESPONSE_STREAM
```
**nota**
Si recibe un error acerca de `--invoke-mode`, puede que necesite actualizar a una [versión más reciente de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
## Prueba del punto de conexión de la URL de función
Invoque la función para probar la integración. Puede abrir la URL de función en un navegador o puede usar curl.
```
curl --request GET "https://abcdefghijklm7nop7qrs740abcd.lambda-url.us-east-1.on.aws/" --user "AKIAIOSFODNN7EXAMPLE" --aws-sigv4 "aws:amz:us-east-1:lambda" --no-buffer
```
Nuestra URL de función utiliza el tipo de autenticación `IAM_AUTH`. Esto significa que debe firmar las solicitudes con las [clave de acceso y clave secreta de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html). En el comando anterior, reemplace `AKIAIOSFODNN7EXAMPLE` por el ID de clave de acceso de AWS. Ingrese su clave secreta de AWS cuando se le solicite. Si no tiene su clave secreta de AWS, puede [utilizar credenciales de AWS temporales](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) en su lugar.
Debería ver una respuesta como la siguiente:
```
Streaming with Helper
Hello 0
Hello 1
Hello 2
```
## Eliminación de sus recursos
A menos que desee conservar los recursos que creó para este tutorial, puede eliminarlos ahora. Si elimina los recursos de AWS que ya no utiliza, evitará gastos innecesarios en su Cuenta de AWS.
**Cómo eliminar el rol de ejecución**
1. Abra la página [Roles](https://console.aws.amazon.com/iam/home#/roles) en la consola de IAM.
1. Seleccione el rol de ejecución que creó.
1. Elija **Eliminar**.
1. Si desea continuar, escriba el nombre del rol en el campo de entrada de texto y elija **Delete** (Eliminar).
**Cómo eliminar la función de Lambda**
1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Seleccione la función que ha creado.
1. Elija **Acciones**, **Eliminar**.
1. Escriba **confirm** en el campo de entrada de texto y seleccione **Delete** (Eliminar).
# Uso del punto de conexión de metadatos de Lambda
El punto de conexión de metadatos de Lambda permite que sus funciones identifiquen en qué zona de disponibilidad (AZ) se ejecutan, de manera que puede optimizar la latencia al enrutar hacia recursos en la misma AZ, como puntos de conexión de Amazon ElastiCache y Amazon RDS, y aplicar patrones de resiliencia con reconocimiento de AZ.
El punto de conexión devuelve metadatos en un formato JSON simple mediante una API de HTTP en localhost dentro del entorno de ejecución y está disponible tanto para tiempos de ejecución como para extensiones.
**Topics**
+ [
## Introducción
](#metadata-endpoint-getting-started)
+ [
## Explicación sobre los identificadores de zona de disponibilidad
](#metadata-endpoint-az-ids)
+ [
## Referencia de la API
](#metadata-endpoint-api-reference)
## Introducción
[Powertools para AWS Lambda](https://docs.aws.amazon.com/powertools/) proporciona una utilidad para acceder al punto de conexión de metadatos de Lambda en Python, TypeScript, Java y .NET. La utilidad almacena en caché la respuesta después de la primera llamada y gestiona automáticamente la invalidación de caché de SnapStart.
Utilice la utilidad de metadatos Powertools para AWS Lambda o llame directamente al punto de conexión de metadatos.
------
#### [ Python ]
Instale el paquete de Powertools:
```
pip install "aws-lambda-powertools"
```
Utilice la utilidad de metadatos en su controlador:
**Example Obtención del identificador de AZ con Powertools (Python)**
```
from aws_lambda_powertools.utilities.lambda_metadata import get_lambda_metadata
def handler(event, context):
metadata = get_lambda_metadata()
az_id = metadata.availability_zone_id # e.g., "use1-az1"
return {"az_id": az_id}
```
------
#### [ TypeScript ]
Instale el paquete de Powertools:
```
npm install @aws-lambda-powertools/commons
```
Utilice la utilidad de metadatos en su controlador:
**Example Obtención del identificador de AZ con Powertools (TypeScript)**
```
import { getMetadata } from '@aws-lambda-powertools/commons/utils/metadata';
const metadata = await getMetadata();
export const handler = async () => {
const { AvailabilityZoneID: azId } = metadata;
return azId;
};
```
------
#### [ Java ]
Agregue la dependencia de Powertools a su `pom.xml`:
```
software.amazon.lambda
powertools-lambda-metadata
2.10.0
```
Utilice el cliente de metadatos en su controlador:
**Example Obtención del identificador de AZ con Powertools (Java)**
```
import software.amazon.lambda.powertools.metadata.LambdaMetadata;
import software.amazon.lambda.powertools.metadata.LambdaMetadataClient;
public class App implements RequestHandler {
@Override
public String handleRequest(Object input, Context context) {
LambdaMetadata metadata = LambdaMetadataClient.get();
String azId = metadata.getAvailabilityZoneId(); // e.g., "use1-az1"
return "{\"azId\": \"" + azId + "\"}";
}
}
```
------
#### [ .NET ]
Instale el paquete de Powertools:
```
dotnet add package AWS.Lambda.Powertools.Metadata
```
Utilice la clase de metadatos en su controlador:
**Example Obtención del identificador de AZ con Powertools (.NET)**
```
using AWS.Lambda.Powertools.Metadata;
public class Function
{
public string Handler(object input, ILambdaContext context)
{
var azId = LambdaMetadata.AvailabilityZoneId;
return $"Running in AZ: {azId}";
}
}
```
------
#### [ All Runtimes ]
Todos los tiempos de ejecución de Lambda admiten el punto de conexión de metadatos, incluidos los tiempos de ejecución personalizados y las imágenes de contenedor. Guíese con el siguiente ejemplo para acceder directamente a la API de metadatos desde su función mediante las variables de entorno que Lambda configura automáticamente en el entorno de ejecución.
**Example Acceso directo al punto de conexión de metadatos**
```
# Variables are automatically set by Lambda
METADATA_ENDPOINT="http://${AWS_LAMBDA_METADATA_API}/2026-01-15/metadata/execution-environment"
# Make the request
RESPONSE=$(curl -s -H "Authorization: Bearer ${AWS_LAMBDA_METADATA_TOKEN}" "$METADATA_ENDPOINT")
# Parse the AZ ID
AZ_ID=$(echo "$RESPONSE" | jq -r '.AvailabilityZoneID')
echo "Function is running in AZ ID: $AZ_ID"
```
------
## Explicación sobre los identificadores de zona de disponibilidad
Los identificadores de AZ (por ejemplo, `use1-az1`) siempre hacen referencia a la misma ubicación física en todas las cuentas de AWS, mientras que los nombres de AZ (por ejemplo, `us-east-1a`) pueden asignarse a infraestructuras físicas diferentes en cada cuenta de AWS en determinadas regiones. Para obtener más información, consulte [Identificadores de AZ para coherencia entre cuentas](https://docs.aws.amazon.com/global-infrastructure/latest/regions/az-ids.html).
**Convertir un identificador de AZ en un nombre de AZ:**
Para convertir un identificador de AZ en un nombre de AZ, utilice la API [DescribeAvailabilityZones de Amazon EC2.](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html) Para usar esta API, agregue el permiso de `ec2:DescribeAvailabilityZones` al rol de ejecución de su función.
## Referencia de la API
### Variables de entorno
Lambda configura automáticamente las siguientes variables de entorno en cada entorno de ejecución:
+ `AWS_LAMBDA_METADATA_API`: la dirección del servidor de metadatos en el formato `{ipv4_address}:{port}` (por ejemplo, `169.254.100.1:9001`).
+ `AWS_LAMBDA_METADATA_TOKEN`: un token de autenticación único para el entorno de ejecución actual. Lambda genera este token automáticamente durante la inicialización. Inclúyalo en todas las solicitudes a la API de metadatos.
### Punto de conexión
`GET http://${AWS_LAMBDA_METADATA_API}/2026-01-15/metadata/execution-environment`
### Solicitud
**Encabezados obligatorios:**
+ `Authorization`: el valor del token de la variable de entorno `AWS_LAMBDA_METADATA_TOKEN` con el esquema Bearer: `Bearer `. Esta autenticación basada en tokens proporciona protección en profundidad frente a vulnerabilidades de falsificación de solicitudes del lado del servidor (SSRF). Cada entorno de ejecución recibe un token único generado de forma aleatoria durante la inicialización.
### Respuesta
**Estado:** `200 OK`
**Content-Type:** `application/json`
**Cache-Control (Control de caché):** `private, max-age=43200, immutable`
La respuesta es inmutable dentro de un entorno de ejecución. Los clientes deben almacenar la respuesta en caché y respetar el `Cache-Control` TTL. En el caso de las funciones con SnapStart, el TTL se reduce durante la inicialización para que los clientes actualicen los metadatos después de la restauración cuando el entorno de ejecución pueda estar en una AZ diferente. Si utiliza Powertools, el almacenamiento en caché y la invalidación de SnapStart se gestionan automáticamente.
**Body (Cuerpo):**
```
{
"AvailabilityZoneID": "use1-az1"
}
```
El campo `AvailabilityZoneID` contiene el identificador único de la zona de disponibilidad en la que se ejecuta el entorno de ejecución.
**nota**
Se podrían agregar campos adicionales a la respuesta en futuras actualizaciones. Los clientes deben ignorar los campos desconocidos y no fallar si aparecen nuevos campos.
### Respuestas de error
+ **401 Unauthorized** (No autorizado): falta el encabezado `Authorization` o contiene un token no válido. Verifique que esté pasando `Bearer ${AWS_LAMBDA_METADATA_TOKEN}`.
+ **405 Method Not Allowed** (Método no permitido): el método de la solicitud no es `GET`.
+ **500 Internal Server Error** (Error interno del servidor): error de procesamiento del lado del servidor.