Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Creación de capas Lambda en AWS SAM
Se puede utilizar AWS SAM para crear capas Lambda personalizadas. Las capas de Lambda permiten extraer código de una función de Lambda que luego se puede reutilizar en varias funciones de Lambda. Compilar solo capas de Lambda (en lugar de compilar toda la aplicación) puede beneficiarle de varias maneras. Puede ayudarle a reducir el tamaño de sus paquetes de implementación, separar la lógica de las funciones principales de las dependencias y permitirle compartir las dependencias entre varias funciones. Para obtener más información acerca de las capas, consulta [Capas Lambda de AWS](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html), en la *Guía para desarrolladores de AWS Lambda *.
## Cómo crear una capa Lambda en AWS SAM
**nota**
Antes de poder crear una capa Lambda, primero debe escribir una capa Lambda en la plantilla. AWS SAM Para obtener más información y ejemplos, consulte [Aumente la eficiencia con las capas Lambda con AWS SAM](serverless-sam-cli-layers.md).
Para crear una capa personalizada, declárala en tu archivo de plantilla AWS Serverless Application Model (AWS SAM) e incluye una sección de atributos del `Metadata` recurso con una `BuildMethod` entrada. Los valores válidos `BuildMethod` son los identificadores de un tiempo [de ejecución de AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html), o`makefile`. Incluya una entrada `BuildArchitecture` para especificar las arquitecturas del conjunto de instrucciones que admite la capa. Los valores válidos para `BuildArchitecture` son las [arquitecturas de conjuntos de instrucciones Lambda](https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html).
Si quieres especifiar `makefile`, proporciona el archivo Make personalizado, en el que se declara el destino de compilación del formulario `build-layer-logical-id` que contiene los comandos de creación de la capa. El archivo Make se encarga de compilar la capa, si es necesario, y de copiar los artefactos de compilación en la ubicación adecuada para los siguientes pasos del flujo de trabajo. La ubicación del archivo Make viene especificada por la propiedad `ContentUri` del recurso de capa y debe tener un nombre `Makefile`.
**nota**
Al crear una capa personalizada, AWS Lambda depende de las variables de entorno para encontrar el código de la capa. Los tiempos de ejecución de Lambda incluyen rutas en el directorio `/opt` en el que se copia el código de capa. La estructura de carpetas de artefactos de compilación del proyecto debe coincidir con la estructura de carpetas esperada para el tiempo de ejecución para poder encontrar el código de capa personalizado.
Por ejemplo, para Python, puedes colocar el código en el subdirectorio `python/`. Por ejemplo, para NodeJS, puedes colocar el código en el subdirectorio `nodejs/node_modules/`.
Para obtener más información, consulta [Incluir las dependencias de biblioteca en una capa](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html#configuration-layers-path) en la *Guía para desarrolladores de AWS Lambda *.
A continuación, se muestra un ejemplo de una sección de atributos de recursos `Metadata`.
```
Metadata:
BuildMethod: python3.12
BuildArchitecture: arm64
```
**nota**
Si no incluye la sección de atributos del `Metadata` recurso, AWS SAM no crea la capa. En su lugar, copia los artefactos de compilación de la ubicación especificada en la propiedad `CodeUri` del recurso de la capa. Para obtener más información, consulta la propiedad [ContentUri](sam-resource-layerversion.md#sam-layerversion-contenturi) del tipo de recurso `AWS::Serverless::LayerVersion`.
Al incluir la sección de atributos de `Metadata` recursos, puede usar el `sam build` comando para crear la capa, como un objeto independiente o como una dependencia de una AWS Lambda función.
+ ****Como objeto independiente.**** Es posible que solo quieras crear el objeto de la capa, por ejemplo, cuando estés probando localmente un cambio de código en la capa y no necesites compilar toda la aplicación. Para crear la capa de forma independiente, especifica el recurso de la capa con el comando `sam build layer-logical-id`.
+ **Como dependencia de una función de Lambda.** Al incluir el ID lógico de una capa en la propiedad `Layers` de una función de Lambda del mismo archivo de plantilla de AWS SAM , la capa es una dependencia de esa función de Lambda. Cuando esa capa también incluye una sección de atributos de recursos `Metadata` con una entrada `BuildMethod`, se crea la capa creando toda la aplicación con el comando `sam build` o especificando el recurso de la función con el comando `sam build function-logical-id`.
## Ejemplos
### Ejemplo de plantilla 1: Crear una capa en el entorno de ejecución de Python 3.12
La siguiente AWS SAM plantilla de ejemplo crea una capa en el entorno de ejecución de Python 3.12.
```
Resources:
MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
ContentUri: my_layer
CompatibleRuntimes:
- python3.12
Metadata:
BuildMethod: python3.12 # Required to have AWS SAM build this layer
```
### Ejemplo de plantilla 2: Crear una capa con un archivo Make personalizado
En la siguiente AWS SAM plantilla de ejemplo, se utiliza una plantilla personalizada `makefile` para crear la capa.
```
Resources:
MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
ContentUri: my_layer
CompatibleRuntimes:
- python3.12
Metadata:
BuildMethod: makefile
```
`makefile` contienes el destino de compilación y los comandos que se ejecutarán. Ten en cuenta que la propiedad `ContentUri` está establecida en `my_layer`, por lo que el archivo Make debes estar ubicado en la raíz del subdirectorio `my_layer` y el nombre del archivo debes ser `Makefile`. Tenga en cuenta también que los artefactos de construcción se copian en el `python/` subdirectorio para AWS Lambda que pueda encontrar el código de la capa.
```
build-MyLayer:
mkdir -p "$(ARTIFACTS_DIR)/python"
cp *.py "$(ARTIFACTS_DIR)/python"
python -m pip install -r requirements.txt -t "$(ARTIFACTS_DIR)/python"
```
**nota**
Cuando se llama a `makefile`, se activa el destino correspondiente, y los artefactos deben copiarse en la variable de entorno expuesta `$ARTIFACTS_DIR`. Para obtener más información, consulte [aws-lambda-builders en GitHub](https://github.com/aws/aws-lambda-builders/blob/develop/aws_lambda_builders/workflows/custom_make/DESIGN.md).
### Ejemplo de comandos de compilación de sam
Los siguientes comandos `sam build` crean capas que incluyen las secciones de atributos de recursos `Metadata`.
```
# Build the 'layer-logical-id' resource independently
$ sam build layer-logical-id
# Build the 'function-logical-id' resource and layers that this function depends on
$ sam build function-logical-id
# Build the entire application, including the layers that any function depends on
$ sam build
```