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.
# Compilación predeterminada con AWS SAM
Para crear una aplicación sin servidor, utiliza el comando `sam build`. Este comando también recopila los artefactos de compilación de las dependencias de la aplicación y los coloca en el formato y la ubicación adecuados para los siguientes pasos, como las pruebas, el empaquetado y la implementación locales.
Las dependencias de la aplicación se especifican en un archivo de manifiesto, como `requirements.txt` (Python) o `package.json` (Node.js), o mediante la propiedad `Layers` de un recurso de función. La propiedad `Layers` contiene una lista de los recursos de [capa de AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) de los que depende la función de Lambda.
El formato de los artefactos de compilación de la aplicación depende de la propiedad `PackageType` de cada función. Las opciones de esta propiedad son:
+ **`Zip`**: un archivo .zip, que incluye el código de la aplicación y sus dependencias. Si comprimes el código como un archivo .zip, debes especificar un tiempo de ejecución de Lambda para tu función.
+ **`Image`**: una imagen del contenedor, que incluye el sistema operativo base, el tiempo de ejecución, las extensiones, el código de la aplicación y sus dependencias.
Para obtener más información sobre los tipos de paquetes de Lambda, consulta [Paquetes de implementación de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) en la *Guía para desarrolladores de AWS Lambda *.
**Topics**
+ [Creación de un archivo .zip](#build-zip-archive)
+ [Creación de una imagen del contenedor](#build-container-image)
+ [Archivo de variables del entorno del contenedor.](#serverless-sam-cli-using-container-environment-file)
+ [Acelera los tiempos de compilación al compilar el proyecto en la carpeta de origen](#serverless-sam-cli-using-build-in-source)
+ [Ejemplos](#building-applications-examples)
+ [Crear funciones fuera de AWS SAM](#building-applications-skip)
## Creación de un archivo .zip
Para crear una aplicación sin servidor como un archivo .zip, declare `PackageType: Zip` para tu función sin servidor.
AWS SAM crea la aplicación para la [arquitectura](sam-resource-function.md#sam-function-architectures) que especifique. Si no especifica una arquitectura, la AWS SAM utiliza de forma `x86_64` predeterminada.
Si la función de Lambda depende de paquetes que tienesn programas compilados de forma nativa, utiliza el indicador `--use-container`. Este indicador compila tus funciones de forma local en un contenedor que se comporta como un entorno Lambda, de modo que estén en el formato correcto cuando las despliegues en la nube. AWS
Cuando utiliza `--use-container` esta opción, AWS SAM extrae de forma predeterminada la imagen del contenedor de [Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/public/what-is-ecr.html) Public. Si desea extraer una imagen de contenedor de otro repositorio o de una versión específica de AWS SAM CLI, puede usar la `--build-image` opción y proporcionar el URI de una imagen de contenedor alternativa. A continuación, se muestran dos comandos de ejemplo para crear aplicaciones mediante imágenes de contenedor de una versión específica de AWS SAM CLI:
```
# Build a Node.js 20 application using a container image for a specific version of AWS SAM CLI (1.136.0)
sam build --use-container --build-image public.ecr.aws/sam/build-nodejs22.x:1.136.0
# Build a function resource using the Python 3.13 container image from a specific version of AWS SAM CLI (1.136.0)(
sam build --use-container --build-image Function1=public.ecr.aws/sam/build-python3.13:1.136.0
```
Para ver ejemplos adicionales de cómo crear una aplicación de archivo .zip, consulta la sección de ejemplos que aparece más adelante en este tema.
## Creación de una imagen del contenedor
Para crear una aplicación sin servidor como una imagen del contenedor, declara `PackageType: Image` para tu función sin servidor. También debes declarar el atributo de recurso `Metadata` con las siguientes entradas:
`Dockerfile`
El nombre de Dockerfile que se asocia con la función de Lambda.
`DockerContext`
La ubicación del Dockerfile.
`DockerTag`
(Opcional) Una etiqueta para aplicar a la imagen creada.
`DockerBuildArgs`
Crear argumentos para la compilación.
La CLI de AWS SAM no elimina ni ofusca ninguna información que incluya en los argumentos `DockerBuildArgs`. Recomendamos encarecidamente que no utilice esta sección para almacenar información confidencial, como contraseñas o secretos.
A continuación, se muestra un ejemplo de una sección de atributos de recursos de `Metadata`:
```
Metadata:
Dockerfile: Dockerfile
DockerContext: ./hello_world
DockerTag: v1
```
Para descargar una aplicación de muestra configurada con el tipo de paquete `Image`, consulte [Tutorial: Implemente una aplicación Hello World con AWS SAM](serverless-getting-started-hello-world.md). Cuando aparezca el mensaje que le pregunte qué tipo de paquete quieres instalar, elige `Image`.
**nota**
Si especificas una imagen base de múltiples arquitecturas en tu Dockerfile, AWS SAM crea tu imagen de contenedor para la arquitectura de tu máquina host. Para crear una arquitectura diferente, especifique una imagen base que utiliza la arquitectura de destino específica.
## Archivo de variables del entorno del contenedor.
Para proporcionar un archivo JSON que contengas variables de entorno para el contenedor de compilación, usa el argumento `--container-env-var-file` junto con el comando `sam build`. Puedes proporcionar una única variable de entorno que se aplique a todos los recursos sin servidor o variables de entorno diferentes para cada recurso.
### Formato
El formato para pasar las variables de entorno a un contenedor de compilación depende del número de variables de entorno que proporciones para tus recursos.
Para proporcionar una única variable de entorno para todos los recursos, especifique un objeto `Parameters` como el siguiente:
```
{
"Parameters": {
"GITHUB_TOKEN": "TOKEN_GLOBAL"
}
}
```
Para proporcionar variables de entorno diferentes para cada recurso, especifique objetos para cada recurso de la siguiente manera:
```
{
"MyFunction1": {
"GITHUB_TOKEN": "TOKEN1"
},
"MyFunction2": {
"GITHUB_TOKEN": "TOKEN2"
}
}
```
Guarda las variables de entorno como un archivo, por ejemplo, denominado `env.json`. El siguiente comando usa este archivo para pasar las variables de entorno al contenedor de compilación:
```
sam build --use-container --container-env-var-file env.json
```
### Prioridad
+ Las variables de entorno que proporcionas para recursos específicos tienen prioridad sobre la variable de entorno única para todos los recursos.
+ Las variables de entorno que se proporcionan en la línea de comandos tienesn prioridad sobre las variables de entorno de un archivo.
## Acelera los tiempos de compilación al compilar el proyecto en la carpeta de origen
Para consultar los tiempos de ejecución y los métodos de compilación compatibles, puedes usar la opción de `--build-in-source` para compilar el proyecto directamente en la carpeta de origen. De forma predeterminada, AWS SAM CLI se compila en un directorio temporal, lo que implica copiar el código fuente y los archivos del proyecto. Con `--build-in-source` las AWS SAM CLI compilaciones directamente en la carpeta de origen, lo que acelera el proceso de compilación al eliminar la necesidad de copiar los archivos a un directorio temporal.
Para consultar una lista de los tiempos de ejecución y métodos de compilación admitidos, consulta `--build-in-source`.
## Ejemplos
### Ejemplo 1: Archivo .zip
Los siguientes comandos `sam build` crean un archivo .zip:
```
# Build all functions and layers, and their dependencies
sam build
# Run the build process inside a Docker container that functions like a Lambda environment
sam build --use-container
# Build a Node.js 20 application using a container image for a specific version of AWS SAM CLI (1.136.0)
sam build --use-container --build-image public.ecr.aws/sam/build-nodejs22.x:1.136.0
# Build a function resource using the Python 3.13 container image from a specific version of AWS SAM CLI (1.136.0)(
sam build --use-container --build-image Function1=public.ecr.aws/sam/build-python3.13:1.136.0
# Build and run your functions locally
sam build && sam local invoke
# For more options
sam build --help
```
### Ejemplo 2: Imagen del contenedor
La siguiente AWS SAM plantilla se compila como una imagen contenedora:
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
PackageType: Image
ImageConfig:
Command: ["app.lambda_handler"]
Metadata:
Dockerfile: Dockerfile
DockerContext: ./hello_world
DockerTag: v1
```
A continuación, se muestra un ejemplo de un Dockerfile.
```
FROM public.ecr.aws/lambda/python:3.12
COPY app.py requirements.txt ./
RUN python3.12 -m pip install -r requirements.txt
# Overwrite the command by providing a different command directly in the template.
CMD ["app.lambda_handler"]
```
### Ejemplo 3: npm ci
En el caso de las aplicaciones de Node.js, puedes utilizar `npm ci` en lugar de `npm install` para instalar dependencias. Para usar `npm ci`, especifique `UseNpmCi: True` bajo `BuildProperties` en el atributo de recurso `Metadata` de la función de Lambda. Para poder utilizar `npm ci`, la aplicación debe tener un archivo `package-lock.json` o `npm-shrinkwrap.json` presente en `CodeUri` para la función de Lambda.
El siguiente ejemplo utiliza `npm ci` para instalar dependencias cuando ejecuta `sam build`:
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello-world/
Handler: app.handler
Runtime: nodejs20.x
Architectures:
- x86_64
Events:
HelloWorld:
Type: Api
Properties:
Path: /hello
Method: get
Metadata:
BuildProperties:
UseNpmCi: True
```
### Paquetes principales de Python
En el caso de las aplicaciones de Python, puede conservar la estructura del paquete durante el proceso de compilación para permitir las importaciones absolutas. Para conservar la estructura del paquete, especifique `ParentPackageMode` en `BuildProperties` en el atributo de recurso `Metadata` de la función de Lambda.
El siguiente ejemplo conserva la estructura del paquete `app` cuando se ejecuta `sam build`:
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello-world/
Handler: app.main.handler
Runtime: python3.12
Architectures:
- x86_64
Metadata:
BuildProperties:
ParentPackageMode: explicit
ParentPackages: app
```
Con esta configuración, el código puede usar importaciones absolutas como `from app.utils import logger`, en lugar de importaciones relativas como `from .utils import logger`.
## Crear funciones fuera de AWS SAM
De forma predeterminada, cuando se ejecuta**sam build**, AWS SAM se crean todos los recursos de la función. Otras opciones incluyen:
+ **Cree todos los recursos de funciones fuera de AWS SAM**: si crea todos los recursos de funciones manualmente o mediante otra herramienta, no **sam build** es obligatorio. Puedes omitir **sam build** y pasar al siguiente paso del proceso, como realizar pruebas locales o implementar tu aplicación.
+ **Cree algunos recursos de funciones fuera de AWS SAM**: si desea AWS SAM crear algunos de sus recursos de función y, al mismo tiempo, crear otros recursos de funciones fuera de AWS SAM ella, puede especificarlo en la AWS SAM plantilla.
### Cree algunos recursos de funciones fuera de AWS SAM
Para AWS SAM omitir una función al utilizarla**sam build**, configura lo siguiente en tu AWS SAM plantilla:
1. Añada la propiedad de metadatos `SkipBuild: True` a la función.
1. Especifique la ruta a los recursos de la función creada.
A continuación, se muestra un ejemplo, con `TestFunction` configurado para omitirse. Sus recursos creados se encuentran en `built-resources/TestFunction.zip`.
```
TestFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: built-resources/TestFunction.zip
Handler: TimeHandler::handleRequest
Runtime: java11
Metadata:
SkipBuild: True
```
Ahora, cuando ejecute**sam build**, AWS SAM hará lo siguiente:
1. AWS SAM omitirá las funciones configuradas con`SkipBuild: True`.
1. AWS SAM compilará todos los demás recursos de funciones y los guardará en caché en el directorio de `.aws-sam` compilación.
1. En el caso de las funciones omitidas, tu plantilla en el directorio de compilación `.aws-sam` se actualizará automáticamente para hacer referencia a la ruta especificada a los recursos de la función creada.
Este es un ejemplo de la plantilla almacenada en caché para `TestFunction` en el directorio de compilación `.aws-sam`:
```
TestFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ../../built-resources/TestFunction.zip
Handler: TimeHandler::handleRequest
Runtime: java11
Metadata:
SkipBuild: True
```