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.
# Cree su aplicación con AWS SAM
Tras añadir la infraestructura como código (IaC) a la AWS SAM plantilla, estará listo para empezar a crear la aplicación mediante el **sam build** comando. Este comando crea artefactos de compilación a partir de los archivos del directorio de proyectos de la aplicación (es decir, el archivo de AWS SAM plantilla, el código de la aplicación y cualquier archivo y dependencia aplicable específico del idioma). Estos artefactos de compilación preparan la aplicación sin servidor para las etapas posteriores del desarrollo de la aplicación, como las pruebas locales y la implementación en la nube. AWS Tanto las pruebas como la implementación utilizan artefactos de compilación como entradas.
Puede utilizar **sam build** para compilar toda la aplicación sin servidor. Además, puede crear compilaciones personalizadas, por ejemplo, con funciones, capas o tiempos de ejecución personalizados específicos. Para obtener más información sobre cómo y por qué se usa **sam build**, consulte los temas de esta sección. Si deseas una introducción sobre el uso del comando `sam build`, consulta [Introducción a la construcción con AWS SAM](using-sam-cli-build.md).
**Topics**
+ [Introducción a la construcción con AWS SAM](using-sam-cli-build.md)
+ [Compilación predeterminada con AWS SAM](serverless-sam-cli-using-build.md)
+ [Personaliza las compilaciones con AWS SAM](building-lambda-functions.md)
# Introducción a la construcción con AWS SAM
Utilice el AWS Serverless Application Model comando Command Line Interface (AWS SAMCLI) `sam build` para preparar la aplicación sin servidor para los siguientes pasos del flujo de trabajo de desarrollo, como las pruebas locales o la Nube de AWS implementación en. Este comando crea un directorio `.aws-sam` que estructura la aplicación en el formato y la ubicación que necesite `sam local` `sam deploy` .
+ Para obtener una introducción al AWS SAMCLI, consulte[¿Qué es el? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli).
+ Para ver una lista de opciones de comandos `sam build`, consulta [sam build](sam-cli-command-reference-sam-build.md).
+ Para ver un ejemplo de uso de `sam build` durante un flujo de trabajo de desarrollo típico, consulta [Paso 2: crear tu propia aplicación](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-build).
**nota**
El uso de `sam build` requiere que comience con los componentes básicos de una aplicación sin servidor en su máquina de desarrollo. Esto incluye una AWS SAM plantilla, un código de AWS Lambda función y cualquier archivo y dependencia específicos del idioma. Para obtener más información, consulte [Crea tu aplicación en AWS SAM](using-sam-cli-init.md).
**Topics**
+ [Creación de aplicaciones con la misma compilación](#using-sam-cli-build-apps)
+ [Prueba e implementación locales](#using-sam-cli-build-test-deploy)
+ [Prácticas recomendadas](#using-sam-cli-build-best)
+ [Opciones para la compilación de Sam](#using-sam-cli-build-options)
+ [Resolución de problemas](#using-sam-cli-build-troubleshooting)
+ [Ejemplos](#using-sam-cli-build-examples)
+ [Más información](#using-sam-cli-build-learn)
## Creación de aplicaciones con la misma compilación
Antes de usar `sam build`, considere la posibilidad de configurar lo siguiente:
1. **Funciones y capas Lambda**: el comando`sam build` puede crear funciones y capas Lambda. Para obtener más información sobre el uso de las capas de Lambda, consulta [Creación de capas Lambda en AWS SAM](building-layers.md).
1. **Tiempo de ejecución de Lambda**: el *tiempo de ejecución* proporciona un entorno específico del lenguaje que ejecuta su función en un entorno de ejecución cuando se invoca. Puede configurar tiempos de ejecución nativos y personalizados.
1. **Tiempo de ejecución nativo**: cree sus funciones de Lambda en un tiempo de ejecución de Lambda compatible y cree sus funciones para utilizar un tiempo de ejecución de Lambda nativo en Nube de AWS
1. **Tiempo de ejecución personalizado**: cree sus funciones de Lambda con cualquier lenguaje de programación y cree su tiempo de ejecución mediante un proceso personalizado definido en un generador makefile o de terceros, como esbuild Para obtener más información, consulta [Creación de funciones Lambda con tiempos de ejecución personalizados en AWS SAM](building-custom-runtimes.md).
1. **Tipo de paquete Lambda**: las funciones de Lambda se pueden empaquetar en los siguientes tipos de paquetes de implementación de Lambda:
1. **Un archivo de archivo .zip**, que incluye el código de la aplicación y sus dependencias.
1. **Imagen del contenedor**: contiene el sistema operativo base, el tiempo de ejecución, las extensiones de Lambda, el código de tu aplicación y sus dependencias.
Estos ajustes de la aplicación se pueden configurar al inicializar una aplicación mediante `sam init`
+ Para obtener más información acerca del uso de `sam init`, consulta [Crea tu aplicación en AWS SAM](using-sam-cli-init.md).
+ Para obtener más información sobre cómo configurar estos ajustes en la aplicación, consulta [Compilación predeterminada con AWS SAM](serverless-sam-cli-using-build.md).
**Para compilar una aplicación**
1. `cd` a la raíz de su proyecto. Es la misma ubicación que la plantilla. AWS SAM
```
$ cd sam-app
```
1. Ejecuta lo siguiente:
```
sam-app $ sam build
```
**nota**
Una opción que se usa con frecuencia es `--use-container`. Para obtener más información, consulta [Creación de una función de Lambda dentro de un contenedor proporcionado](#using-sam-cli-build-options-container).
A continuación, se muestra un ejemplo de resultados del AWS SAM CLI output.
```
sam-app $ sam build
Starting Build use cache
Manifest file is changed (new hash: 3298f1304...d4d421) or dependency folder (.aws-sam/deps/4d3dfad6-a267-47a6-a6cd-e07d6fae318c) is missing for (HelloWorldFunction), downloading dependencies and copying/building source
Building codeuri: /Users/.../sam-app/hello_world runtime: python3.12 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CleanUp
Running PythonPipBuilder:ResolveDependencies
Running PythonPipBuilder:CopySource
Running PythonPipBuilder:CopySource
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
1. La CLI de AWS SAM crea un directorio de compilación `.aws-sam`. A continuación, se muestra un ejemplo:
```
.aws-sam
├── build
│ ├── HelloWorldFunction
│ │ ├── __init__.py
│ │ ├── app.py
│ │ └── requirements.txt
│ └── template.yaml
└── build.toml
```
Según cómo esté configurada la aplicación, la CLI de AWS SAM hace lo siguiente:
1. Descarga, instala y organiza las dependencias en el directorio `.aws-sam/build`.
1. Prepara el código Lambda. Esto puede incluir la compilación del código, la creación de binarios ejecutables y la creación de imágenes de contenedores.
1. Copia los artefactos de construcción en el directorio `.aws-sam`. El formato variará en función del tipo de paquete de la aplicación.
1. En el caso de los tipos de paquetes.zip, los artefactos aún no están comprimidos, por lo que se pueden utilizar en testeo local. La CLI de AWS SAM comprime la aplicación cuando se usa `sam deploy`
1. Para los tipos de paquetes de imágenes de contenedores, se crea una imagen de contenedor localmente y se hace referencia a ella en el archivo `.aws-sam/build.toml`.
1. Copia la AWS SAM plantilla en el `.aws-sam` directorio y la modifica con nuevas rutas de archivo cuando es necesario.
Los componentes principales que componen los artefactos de compilación del directorio `.aws-sam` son los siguientes:
+ **El directorio de compilación**: contiene las funciones y capas de Lambda estructuradas de forma independiente. Esto da como resultado una estructura única para cada función o capa del directorio `.aws-sam/build`.
+ **La AWS SAM plantilla**: se modifica con valores actualizados en función de los cambios ocurridos durante el proceso de creación.
+ **El archivo build.toml: un archivo** de configuración que contiene los ajustes de compilación utilizados por. AWS SAMCLI
## Prueba e implementación locales
Al realizar testeo local con `sam local` o realizar una implementación con`sam deploy`, la CLI de AWS SAM hace lo siguiente:
1. Primero comprueba si existe un `.aws-sam` directorio y si hay una AWS SAM plantilla ubicada dentro de ese directorio. Si se cumplen estas condiciones, la CLI de AWS SAM considera el directorio raíz de la aplicación.
1. Si no se cumplen estas condiciones, AWS SAMCLI considera la ubicación original de la AWS SAM plantilla como el directorio raíz de la aplicación.
Durante el desarrollo, si se realizan cambios en los archivos originales de la aplicación, ejecuta `sam build` para actualizar el directorio `.aws-sam` antes de realizar testeo local.
## Prácticas recomendadas
+ No edite ningún código del directorio `.aws-sam/build`. En su lugar, actualice el código fuente original en la carpeta del proyecto y ejecuta `sam build` para actualizar el directorio `.aws-sam/build`.
+ Cuando modifique los archivos originales, ejecuta `sam build` para actualizar el directorio `.aws-sam/build`.
+ Es posible que desee que la CLI de AWS SAM haga referencia al directorio raíz original del proyecto en lugar de al directorio `.aws-sam`, por ejemplo, al desarrollar y probar con `sam local`. Elimine el `.aws-sam` directorio o la AWS SAM plantilla del `.aws-sam` directorio para que AWS SAMCLI reconozcan el directorio del proyecto original como el directorio raíz del proyecto. Cuando esté listo, ejecuta nuevamente `sam build` para crear el directorio `.aws-sam`.
+ Cuando se ejecuta `sam build`, el `.aws-sam/build` directorio se sobrescribe cada vez. El directorio `.aws-sam` no lo hace. Si desea almacenar archivos como registros, guárdalos en `.aws-sam` para evitar que se sobrescriban.
## Opciones para la compilación de Sam
### Creación de un solo recurso
Proporciona el identificador lógico del recurso para crear solo ese recurso. A continuación, se muestra un ejemplo:
```
$ sam build HelloWorldFunction
```
Para crear un recurso a partir de una aplicación o pila anidada, proporciona el identificador lógico de la aplicación o pila junto con el identificador lógico del recurso con el siguiente formato `/`:
```
$ sam build MyNestedStack/MyFunction
```
### Creación de una función de Lambda dentro de un contenedor proporcionado
La opción `--use-container` descarga una imagen de contenedor y la usa para crear las funciones de Lambda. A continuación, se hace referencia al contenedor local en el archivo `.aws-sam/build.toml`.
Esto requiere que Docker esté instalado. Para obtener instrucciones, consulta [Instalar Docker](install-docker.md).
A continuación, se muestra un ejemplo del comando:
```
$ sam build --use-container
```
Puedes especificar la imagen del contenedor que se usará con la opción `--build-image`. A continuación, se muestra un ejemplo:
```
$ sam build --use-container --build-image amazon/aws-sam-cli-build-image-nodejs20.x
```
Para especificar la imagen del contenedor que se usará para una sola función, proporciona el ID lógico de la función. A continuación, se muestra un ejemplo:
```
$ sam build --use-container --build-image Function1=amazon/aws-sam-cli-build-image-python3.12
```
### Transfiera la variables de entorno al contenedor de compilaciones.
Utiliza `--container-env-var` para transferir las variables de entorno al contenedor de compilaciones. A continuación, se muestra un ejemplo:
```
$ sam build --use-container --container-env-var Function1.GITHUB_TOKEN= --container-env-var GLOBAL_ENV_VAR=
```
Para transferir variables de entorno de un archivo, utiliza la opción `--container-env-var-file`. A continuación, se muestra un ejemplo:
```
$ sam build --use-container --container-env-var-file
```
Ejemplo del archivo `env.json`:
```
{
"MyFunction1": {
"GITHUB_TOKEN": "TOKEN1"
},
"MyFunction2": {
"GITHUB_TOKEN": "TOKEN2"
}
}
```
### Acelere la creación de aplicaciones que contienen múltiples funciones
Cuando se ejecuta `sam build` en una aplicación con varias funciones, la CLI de AWS SAM crea cada función de una en una. Para acelerar el proceso de compilación, utiliza la opción `--parallel`. De esta forma, se crean todas las funciones y capas al mismo tiempo.
A continuación, se muestra un ejemplo del comando:
```
$ sam build —-parallel
```
### Acelere 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, se AWS SAM CLI crea 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 obtener una lista de los tiempos de ejecución y métodos de compilación compatibles, consulta `--build-in-source`.
## Resolución de problemas
Para solucionar el problema AWS SAMCLI, consulte[Solución de problemas para AWS SAM CLI](sam-cli-troubleshooting.md).
## Ejemplos
### Creación de una aplicación que utiliza un tiempo de ejecución nativo y un tipo de paquete .zip
Para este ejemplo, consulta [Tutorial: Implemente una aplicación Hello World con AWS SAM](serverless-getting-started-hello-world.md).
### Crear una aplicación que utiliza un tiempo de ejecución y un tipo de paquete de imágenes nativas
Primero, ejecuta `sam init` para inicializar una nueva aplicación. Durante el flujo interactivo, seleccione el tipo de paquete `Image`. A continuación, se muestra un ejemplo:
```
$ sam init
...
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
4 - Scheduled task
5 - Standalone function
6 - Data processing
7 - Hello World Example With Powertools
8 - Infrastructure event management
9 - Serverless Connector Hello World Example
10 - Multi-step workflow with Connectors
11 - Lambda EFS example
12 - DynamoDB Example
13 - Machine Learning
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
...
10 - java8
11 - nodejs20.x
12 - nodejs18.x
13 - nodejs16.x
...
Runtime: 12
What package type would you like to use?
1 - Zip
2 - Image
Package type: 2
Based on your selections, the only dependency manager available is npm.
We will proceed copying the template using npm.
Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER
Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER
Project name [sam-app]: ENTER
Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment)
-----------------------
Generating application:
-----------------------
Name: sam-app
Base Image: amazon/nodejs18.x-base
Architectures: x86_64
Dependency Manager: npm
Output Directory: .
Configuration file: sam-app/samconfig.toml
Next steps can be found in the README file at sam-app/README.md
...
```
AWS SAMCLIInicializa una aplicación y crea el siguiente directorio de proyectos:
```
sam-app
├── README.md
├── events
│ └── event.json
├── hello-world
│ ├── Dockerfile
│ ├── app.mjs
│ ├── package.json
│ └── tests
│ └── unit
│ └── test-handler.mjs
├── samconfig.toml
└── template.yaml
```
A continuación, ejecuta `sam build` para crear e implementar nuestra aplicación:
```
sam-app $ sam build
Building codeuri: /Users/.../build-demo/sam-app runtime: None metadata: {'DockerTag': 'nodejs18.x-v1', 'DockerContext': '/Users/.../build-demo/sam-app/hello-world', 'Dockerfile': 'Dockerfile'} architecture: arm64 functions: HelloWorldFunction
Building image for HelloWorldFunction function
Setting DockerBuildArgs: {} for HelloWorldFunction function
Step 1/4 : FROM public.ecr.aws/lambda/nodejs:18
---> f5b68038c080
Step 2/4 : COPY app.mjs package*.json ./
---> Using cache
---> 834e565aae80
Step 3/4 : RUN npm install
---> Using cache
---> 31c2209dd7b5
Step 4/4 : CMD ["app.lambdaHandler"]
---> Using cache
---> 2ce2a438e89d
Successfully built 2ce2a438e89d
Successfully tagged helloworldfunction:nodejs18.x-v1
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
### Crear una aplicación que incluya un lenguaje de programación compilado
En este ejemplo, creamos una aplicación que contiene una función de Lambda utilizando el tiempo de ejecución Go.
En primer lugar, inicializamos una nueva aplicación utilizando `sam init` y configuramos nuestra aplicación para que utiliza Go:
```
$ sam init
...
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
...
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
...
4 - dotnetcore3.1
5 - go1.x
6 - go (provided.al2)
...
Runtime: 5
What package type would you like to use?
1 - Zip
2 - Image
Package type: 1
Based on your selections, the only dependency manager available is mod.
We will proceed copying the template using mod.
Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER
Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER
Project name [sam-app]: ENTER
Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment)
-----------------------
Generating application:
-----------------------
Name: sam-app
Runtime: go1.x
Architectures: x86_64
Dependency Manager: mod
Application Template: hello-world
Output Directory: .
Configuration file: sam-app/samconfig.toml
Next steps can be found in the README file at sam-app-go/README.md
...
```
AWS SAMCLIInicializa la aplicación. A continuación, se muestra la estructura de directorios que utilizamos para esta aplicación de ejemplo:
```
sam-app
├── Makefile
├── README.md
├── events
│ └── event.json
├── hello-world
│ ├── go.mod
│ ├── go.sum
│ ├── main.go
│ └── main_test.go
├── samconfig.toml
└── template.yaml
```
Hacemos referencia al archivo `README.md` para conocer los requisitos de esta aplicación.
```
...
## Requirements
* AWS CLI already configured with Administrator permission
* [Docker installed](https://www.docker.com/community-edition)
* [Golang](https://golang.org)
* SAM CLI - [Install the SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html)
...
```
A continuación, ejecutamos `sam local invoke` para probar la función. Este comando genera errores, ya que Go no está instalado en nuestra máquina local:
```
sam-app $ sam local invoke
Invoking hello-world (go1.x)
Local image was not found.
Removing rapid images for repo public.ecr.aws/sam/emulation-go1.x
Building image.................................................................................................................................................................................................................................................
Using local image: public.ecr.aws/lambda/go:1-rapid-x86_64.
Mounting /Users/.../Playground/build/sam-app/hello-world as /var/task:ro,delegated inside runtime container
START RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31 Version: $LATEST
fork/exec /var/task/hello-world: no such file or directory: PathError
null
END RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31
REPORT RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31 Init Duration: 0.88 ms Duration: 175.75 ms Billed Duration: 176 ms Memory Size: 128 MB Max Memory Used: 128 MB
{"errorMessage":"fork/exec /var/task/hello-world: no such file or directory","errorType":"PathError"}%
```
A continuación, ejecuta `sam build` para crear e implementar la aplicación. Nos encontramos con un error, ya que Go no está instalado en nuestra máquina local:
```
sam-app $ sam build
Starting Build use cache
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../Playground/build/sam-app/hello-world runtime: go1.x metadata: {} architecture: x86_64 functions: HelloWorldFunction
Build Failed
Error: GoModulesBuilder:Resolver - Path resolution for runtime: go1.x of binary: go was not successful
```
Si bien podríamos configurar nuestra máquina local para que construya correctamente nuestra función, en su lugar utilizamos la opción `--use-container` con `sam build`. AWS SAMCLIDescarga una imagen de contenedor, crea nuestra función con la nativa GoModulesBuilder y copia el binario resultante en nuestro `.aws-sam/build/HelloWorldFunction` directorio.
```
sam-app $ sam build --use-container
Starting Build use cache
Starting Build inside a container
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../build/sam-app/hello-world runtime: go1.x metadata: {} architecture: x86_64 functions: HelloWorldFunction
Fetching public.ecr.aws/sam/build-go1.x:latest-x86_64 Docker container image.....................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
Mounting /Users/.../build/sam-app/hello-world as /tmp/samcli/source:ro,delegated inside runtime container
Running GoModulesBuilder:Build
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
A continuación, se muestra un ejemplo del archivo `.aws-sam`.
```
.aws-sam
├── build
│ ├── HelloWorldFunction
│ │ └── hello-world
│ └── template.yaml
├── build.toml
├── cache
│ └── c860d011-4147-4010-addb-2eaa289f4d95
│ └── hello-world
└── deps
```
A continuación, ejecutamos `sam local invoke`. Nuestra función se invocó correctamente:
```
sam-app $ sam local invoke
Invoking hello-world (go1.x)
Local image is up-to-date
Using local image: public.ecr.aws/lambda/go:1-rapid-x86_64.
Mounting /Users/.../Playground/build/sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated inside runtime container
START RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479 Version: $LATEST
END RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479
REPORT RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479 Init Duration: 1.20 ms Duration: 1782.46 ms Billed Duration: 1783 ms Memory Size: 128 MB Max Memory Used: 128 MB
{"statusCode":200,"headers":null,"multiValueHeaders":null,"body":"Hello, 72.21.198.67\n"}%
```
## Más información
Para obtener más información sobre el uso del comando `sam build`, consulta los enlaces siguientes:
+ **[Aprendizaje AWS SAM: sam build](https://www.youtube.com/watch?v=fDhYKp4op_g)** — Serie «Aprendizaje AWS SAM» de Serverless Land. YouTube
+ **[Aprendizaje AWS SAM \$1 sam build \$1 E3](https://www.youtube.com/watch?v=vsAvRyLnB7Y)** — Serie «Aprendizaje AWS SAM» de Serverless Land en adelante. YouTube
+ **[AWS SAM build: cómo proporciona artefactos para su implementación (Sesiones con SAM S2E8) — Sesiones](https://www.youtube.com/watch?v=bNbBd6XoDHg)** con serie sobre. AWS SAM YouTube
+ **[AWS SAM compilaciones personalizadas: Cómo usar Makefiles para personalizar compilaciones en SAM (S2E9) — Sesiones](https://www.youtube.com/watch?v=wpccutnSbAk)** con series posteriores. AWS SAM YouTube
# 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
```
# Personaliza las compilaciones con AWS SAM
Puede personalizar la compilación para incluir funciones o capas de Lambda específicas. Una función es un recurso que puedes invocar para ejecutar el código en Lambda. Una capa de Lambda permite extraer código de una función de Lambda que luego se puede reutilizar en varias funciones de Lambda. Puede optar por personalizar su compilación con funciones de Lambda específicas si quiere centrarse en desarrollar e implementar funciones individuales sin servidor sin la complejidad de administrar dependencias o recursos compartidos. Además, puede optar por crear una capa de Lambda que le ayude a reducir el tamaño de los paquetes de implementación, a separar la lógica de las funciones principales de las dependencias y a compartir las dependencias entre varias funciones.
En los temas de esta sección se exploran algunas de las diferentes formas con las que se pueden crear funciones Lambda. AWS SAM Esto incluye la creación de funciones de Lambda con las versiones ejecutables de los clientes y la creación de capas de Lambda. Los tiempos de ejecución personalizados le permiten instalar y usar un lenguaje que no aparece en los tiempos de ejecución de Lambda en la Guía para desarrolladores. AWS Lambda Esto le permite crear un entorno de ejecución especializado para ejecutar funciones y aplicaciones sin servidor. 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, consulte [Conceptos de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html) en la *Guía para desarrolladores de AWS Lambda *.
**Topics**
+ [Compilación de funciones Lambda de Node.js con esbuild en AWS SAM](serverless-sam-cli-using-build-typescript.md)
+ [Creación de funciones Lambda de.NET con compilación AOT nativa en AWS SAM](build-dotnet7.md)
+ [Creación de funciones de Rust Lambda con in Cargo Lambda AWS SAM](building-rust.md)
+ [Creación de funciones Lambda de Python con in uv AWS SAM](building-python-uv.md)
+ [Creación de funciones Lambda con tiempos de ejecución personalizados en AWS SAM](building-custom-runtimes.md)
+ [Creación de capas Lambda en AWS SAM](building-layers.md)
# Compilación de funciones Lambda de Node.js con esbuild en AWS SAM
Para compilar y empaquetar AWS Lambda las funciones de Node.js, puede utilizarlas AWS SAMCLI con el paquete JavaScript esbuild. El paquete esbuild admite las funciones Lambda que usted escriba. TypeScript
Para crear una función de Lambda de Node.js con esbuild, añade un objeto de `Metadata` a tu recurso de `AWS:Serverless::Function` y especifica `esbuild` para el `BuildMethod`. Al ejecutar el **sam build** comando, AWS SAM usa esbuild para empaquetar el código de la función Lambda.
## Propiedades de los metadatos
El objeto `Metadata` admite las siguientes propiedades.
### BuildMethod
Especifica el paquete de URL para tu aplicación. El único valor admitido es `esbuild`.
### BuildProperties
Especifica las propiedades de creación del código de la función de Lambda.
El objeto de `BuildProperties` admite las siguientes propiedades. Todas las propiedades son opcionales. De forma predeterminada, AWS SAM utiliza el controlador de funciones Lambda como punto de entrada.
**EntryPoints**
Especifica puntos de entrada para tu aplicación.
**Externo**
Especifica la lista de paquetes a omitir de la compilación. Para más información, consulta [Externo](https://esbuild.github.io/api/#external) en el *sitio web de esbuild*.
**Formato**
Especifica el formato de salida de los JavaScript archivos generados en la aplicación. Para más información, consulta [Formato](https://esbuild.github.io/api/#format) en el *sitio web de esbuild*.
**Programa de carga**
Especifica la lista de configuraciones para cargar datos para un tipo de archivo determinado.
**MainFields**
Especifica qué campos de `package.json` se debesn intentar importar al resolver un paquete. El valor predeterminado es `main,module`.
**Minify**
Especifica si se debes minimizar el código de output agrupado. El valor predeterminado es `true`.
**OutExtension**
Personalice la extensión de los archivos que genera esbuild. Para más información, consulta [Out extension](https://esbuild.github.io/api/#out-extension) en el *sitio web de esbuild*.
**Sourcemap**
Especifica si el paquete produce un archivo de mapa de origen. El valor predeterminado es `false`.
Cuando se establece en `true`, `NODE_OPTIONS: --enable-source-maps` se añade a las variables de entorno de la función de Lambda y se genera un mapa de origen que se incluye en la función.
Como alternativa, cuando `NODE_OPTIONS: --enable-source-maps` se incluye en las variables de entorno de la función, `Sourcemap` se establece automáticamente en `true`.
En caso de conflicto, `Sourcemap: false` tiene prioridad sobre `NODE_OPTIONS: --enable-source-maps`.
De forma predeterminada, Lambda cifra todas las variables de entorno en reposo con AWS Key Management Service (AWS KMS). Al utilizar mapas de origen, para que la implementación se realice correctamente, tu rol de ejecución de la función debe tener permiso para realizar la acción de `kms:Encrypt`.
**SourcesContent**
Especifica si se debes incluir el código fuente en el archivo de mapa fuente. Configure esta propiedad cuando `Sourcemap` esté establecido en `'true'`.
+ Especifique `SourcesContent: 'true'` para incluir todo el código fuente.
+ Especifique `SourcesContent: 'false'` para excluir todo el código fuente. Esto se traduce en tamaños más pequeños de los archivos de los mapas fuente, lo que resulta útil en la producción al reducir los tiempos de puesta en marcha. Sin embargo, el código fuente no estará disponible en el depurador.
El valor predeterminado es `SourcesContent: true`.
Para más información, consulta [Contenido de las fuentes](https://esbuild.github.io/api/#sources-content) en el *sitio web de esbuild*.
**Destinatario**
Especifica la ECMAScript versión de destino. El valor predeterminado es `es2020`.
## TypeScript Ejemplo de función Lambda
En el siguiente fragmento de AWS SAM plantilla de ejemplo, se utiliza esbuild para crear una función Lambda de Node.js a partir del código de. TypeScript `hello-world/app.ts`
```
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
Environment:
Variables:
NODE_OPTIONS: --enable-source-maps
Metadata:
BuildMethod: esbuild
BuildProperties:
Format: esm
Minify: false
OutExtension:
- .js=.mjs
Target: "es2020"
Sourcemap: true
EntryPoints:
- app.ts
External:
- ""
```
# Creación de funciones Lambda de.NET con compilación AOT nativa en AWS SAM
Cree y empaquete sus AWS Lambda funciones de.NET 8 con AWS Serverless Application Model (AWS SAM), utilizando la compilación nativa Ahead-of-Time (AOT) para mejorar los tiempos de arranque en AWS Lambda frío.
**Topics**
+ [Descripción general de AOT nativo para .NET 8](#build-dotnet7-overview)
+ [Uso AWS SAM con funciones Lambda de.NET 8](#build-dotnet7-sam)
+ [Requisitos previos de instalación](#build-dotnet7-prerequisites)
+ [Defina las funciones Lambda de.NET 8 en su plantilla AWS SAM](#build-dotnet7-sam-define)
+ [Crea tu aplicación con la CLI de AWS SAM.](#build-dotnet7-sam-build)
+ [Más información](#build-dotnet7-learn-more)
## Descripción general de AOT nativo para .NET 8
Históricamente, las funciones de Lambda .NET tienen tiempos de inicio en frío que afectan a la experiencia del usuario, la latencia del sistema y los costos de uso de las aplicaciones sin servidor. Con la compilación de AOT nativo de .NET, puede mejorar los tiempos de arranque en frío de sus funciones de Lambda. *Para obtener más información sobre el AOT nativo para .NET 8, consulte [Uso del AOT nativo en el repositorio de Dotnet](https://github.com/dotnet/runtime/tree/main/src/coreclr/nativeaot#readme). GitHub *
## Uso AWS SAM con funciones Lambda de.NET 8
Siga estos pasos para configurar las funciones de Lambda de .NET 8 con AWS Serverless Application Model (AWS SAM):
+ Instala los requisitos previos en su máquina de desarrollo.
+ Defina las funciones Lambda de.NET 8 en su plantilla. AWS SAM
+ Cree su aplicación con. AWS SAMCLI
## Requisitos previos de instalación
A continuación, se indican los requisitos previos.
+ El AWS SAMCLI
+ La CLI de .NET Core
+ La herramienta global .NET Core de Amazon.Lambda.Tools.
+ Docker
**Instala la CLI AWS SAM**
1. Para comprobar si ya tienes la CLI de AWS SAM instalada, ejecuta lo siguiente:
```
sam --version
```
1. Para instalar el AWS SAMCLI, consulte[Instala la AWS SAM CLI](install-sam-cli.md).
1. Para actualizar una versión instalada del AWS SAMCLI, consulte[Actualización de AWS SAM CLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade).
**Instalar la CLI de .NET Core**
1. Para descargar e instalar la CLI de .NET Core, consulta [Descargar .NET](https://dotnet.microsoft.com/download) desde el sitio web de Microsoft.
1. Para obtener más información sobre la CLI de .NET Core, consulta la [CLI de .NET Core](https://docs.aws.amazon.com/lambda/latest/dg/csharp-package-cli.html) en la *Guía para desarrolladores de AWS Lambda *.
**Instala la herramienta global .NET Core de Amazon.Lambda.Tools.**
1. Ejecuta el siguiente comando:
```
dotnet tool install -g Amazon.Lambda.Tools
```
1. Si ya tienes la herramienta instalada, puedes asegurarse de que es la versión más reciente usando el siguiente comando:
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Para obtener más información acerca de la herramienta global .NET Core de Amazon.Lambda.Tools, consulte el repositorio CLI de extensiones [AWS para](https://github.com/aws/aws-extensions-for-dotnet-cli) .NET en. GitHub
**Instalar Docker**
+ Para compilar con AOT nativo, es necesario instalar Docker. Para obtener las instrucciones de instalación, consulta [Instalación de Docker para usarlo con la CLI de AWS SAM](install-docker.md).
## Defina las funciones Lambda de.NET 8 en su plantilla AWS SAM
Para definir un. NET8 Función Lambda en su AWS SAM plantilla, haga lo siguiente:
1. Ejecute el siguiente comando desde el directorio de inicio que quiera:
```
sam init
```
1. Seleccione `AWS Quick Start Templates` para elegir una plantilla de inicio.
1. Elige la plantilla `Hello World Example`.
1. Introduzca `n` para no utilizar la versión ejecutable y el tipo de paquete más populares.
1. Para la versión ejecutable, elija `dotnet8`.
1. Para el tipo de paquete, elija `Zip`.
1. Para su plantilla de inicio, elija `Hello World Example using native AOT`.
**Instalar Docker**
+ Para compilar con AOT nativo, es necesario instalar Docker. Para obtener las instrucciones de instalación, consulta [Instalación de Docker para usarlo con la CLI de AWS SAM](install-docker.md).
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src/HelloWorldAot/
Handler: bootstrap
Runtime: dotnet8
Architectures:
- x86_64
Events:
HelloWorldAot:
Type: Api
Properties:
Path: /hello
Method: get
```
**nota**
Cuando la `Event` propiedad de an `AWS::Serverless::Function` se establece en`Api`, pero no se especifica, AWS SAM genera el `AWS::ApiGateway::RestApi` CloudFormation recurso. `RestApiId`
## Crea tu aplicación con la CLI de AWS SAM.
Desde el directorio raíz del proyecto, ejecute el comando `sam build` para empezar a crear la aplicación. Si la propiedad `PublishAot` se ha definido en el archivo de proyecto de .NET 8, la AWS SAM de CLI se compilará con la compilación de AOT nativo. Para obtener más información sobre la propiedad `PublishAot`, consulta [Implementación nativa de AOT](https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/) en la documentación de *.NET de Microsoft*.
Para crear la función, AWS SAMCLI invoca la CLI de .NET Core, que utiliza la herramienta de .NET Core Global Amazon.Lambda.Tools.
**nota**
Al compilar, si existe un archivo `.sln` en el mismo directorio o en el directorio principal del proyecto, el directorio que contienes el archivo `.sln` se montará en el contenedor. Si no se encuentra ningún archivo `.sln`, solo se montará la carpeta del proyecto. Por lo tanto, si está creando una aplicación para varios proyectos, asegúrese de que el archivo `.sln` esté ubicado en la propiedad.
## Más información
Para obtener más información sobre la creación de funciones de Lambda de .NET 8, consulte [Introducing the .NET 8 runtime for AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-net-8-runtime-for-aws-lambda/).
Para obtener más información sobre el comando **sam build**, consulta [sam build](sam-cli-command-reference-sam-build.md).
# Creación de funciones de Rust Lambda con in Cargo Lambda AWS SAM
| |
| --- |
| Esta función se encuentra en una versión preliminar AWS SAM y está sujeta a cambios. |
Utilice la interfaz de línea de AWS Serverless Application Model comandos (AWS SAMCLI) con sus AWS Lambda funciones de Rust.
**Topics**
+ [Requisitos previos](#building-rust-prerequisites)
+ [Configuración AWS SAM para su uso con las funciones de Rust Lambda](#building-rust-configure)
+ [Ejemplos](#building-rust-examples)
## Requisitos previos
**Lenguaje Rust**
Para instalar Rust, consulta [Instalar Rust](https://www.rust-lang.org/tools/install) en el *sitio web del lenguaje Rust*.
**Cargo Lambda**
La CLI de AWS SAM requiere la instalación de [https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html](https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html), un subcomando para Cargo. Para obtener instrucciones sobre la instalación, consulta [Instalación](https://www.cargo-lambda.info/guide/installation.html) en la *Documentación de Cargo Lambda*.
**Docker**
Para crear y probar funciones de Lambda Rust es necesario disponer de Docker. Para obtener las instrucciones de instalación, consulta [Instalar Docker](install-docker.md).
**Acceda a la característica beta de la CLI de AWS SAM.**
Como esta característica está en versión preliminar, debes acceder usando uno de los siguientes métodos:
1. Usa las variables de entorno: `SAM_CLI_BETA_RUST_CARGO_LAMBDA=1`.
1. Añade lo siguiente a tu archivo `samconfig.toml`:
```
[default.build.parameters]
beta_features = true
[default.sync.parameters]
beta_features = true
```
1. Utiliza la opción `--beta-features` cuando utiliza un comando de la CLI de AWS SAM compatible. Por ejemplo:
```
$ sam build --beta-features
```
1. Elija la opción `y` cuando la CLI de AWS SAM le pida que acceda. A continuación, se muestra un ejemplo:
```
$ sam build
Starting Build use cache
Build method "rust-cargolambda" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
```
## Configuración AWS SAM para su uso con las funciones de Rust Lambda
### Paso 1: Configura tu AWS SAM plantilla
Configure su AWS SAM plantilla con lo siguiente:
+ **Binario**: opcional. Especifica cuándo tu plantilla contiene varias funciones Rust de Lambda.
+ **BuildMethod** – `rust-cargolambda`.
+ **CodeUri**— ruta a su `Cargo.toml` archivo.
+ **Controlador**: `bootstrap`.
+ **Tiempo de ejecución**: `provided.al2`.
Para obtener más información sobre los tiempos de ejecución personalizados, consulta los tiempos de [AWS Lambda ejecución personalizados](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html) en la Guía *AWS Lambda para desarrolladores*.
A continuación, se muestra un ejemplo de una plantilla configurada AWS SAM :
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties: function_a
Properties:
CodeUri: ./rust_app
Handler: bootstrap
Runtime: provided.al2
...
```
### Paso 2: usa la CLI de AWS SAM con tu función Rust de Lambda
Usa cualquier AWS SAMCLI comando con tu AWS SAM plantilla. Para obtener más información, consulte [AWS SAM CLI](using-sam-cli.md).
## Ejemplos
### Ejemplo de Hello World
**En este ejemplo, creamos la aplicación de muestra Hello World usando Rust como nuestro tiempo de ejecución.**
En primer lugar, inicializamos una nueva aplicación sin servidor utilizando `sam init`. Durante el flujo interactivo, seleccionamos la **aplicación Hello World** y elegimos el tiempo de ejecución de **Rust**.
```
$ sam init
...
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
...
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
1 - dotnet8
2 - dotnet6
3 - go (provided.al2)
...
18 - python3.11
19 - python3.10
20 - ruby3.3
21 - ruby3.2
22 - rust (provided.al2)
23 - rust (provided.al2023)
Runtime: 22
Based on your selections, the only Package type available is Zip.
We will proceed to selecting the Package type as Zip.
Based on your selections, the only dependency manager available is cargo.
We will proceed copying the template using cargo.
Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER
Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER
Project name [sam-app]: hello-rust
-----------------------
Generating application:
-----------------------
Name: hello-rust
Runtime: rust (provided.al2)
Architectures: x86_64
Dependency Manager: cargo
Application Template: hello-world
Output Directory: .
Configuration file: hello-rust/samconfig.toml
Next steps can be found in the README file at hello-rust/README.md
Commands you can use next
=========================
[*] Create pipeline: cd hello-rust && sam pipeline init --bootstrap
[*] Validate SAM template: cd hello-rust && sam validate
[*] Test Function in the Cloud: cd hello-rust && sam sync --stack-name {stack-name} --watch
```
La siguiente es la estructura de nuestra aplicación Hello World:
```
hello-rust
├── README.md
├── events
│ └── event.json
├── rust_app
│ ├── Cargo.toml
│ └── src
│ └── main.rs
├── samconfig.toml
└── template.yaml
```
En nuestra AWS SAM plantilla, nuestra Rust función se define de la siguiente manera:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
Properties:
CodeUri: ./rust_app
Handler: bootstrap
Runtime: provided.al2
Architectures:
- x86_64
Events:
HelloWorld:
Type: Api
Path: /hello
Method: get
```
A continuación, ejecuta `sam build` para crear e implementar la aplicación. La CLI de AWS SAM crea un directorio de `.aws-sam` y organiza allí nuestros artefactos de construcción. Nuestra función se crea utilizando Cargo Lambda y se almacena como un archivo binario ejecutable en `.aws-sam/build/HelloWorldFunction/bootstrap`.
**nota**
Si planea ejecutar el comando **sam local invoke** en macOS, tiene que crear funciones diferentes antes de la invocación. Para ello, utilice el siguiente comando:
**SAM\$1BUILD\$1MODE=debug sam build**
Este comando solo es necesario si se van a realizar pruebas locales. No se recomienda al compilar para la implementación.
```
hello-rust$ sam build
Starting Build use cache
Build method "rust-cargolambda" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
Experimental features are enabled for this session.
Visit the docs page to learn more about the AWS Beta terms https://aws.amazon.com/service-terms/.
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../hello-rust/rust_app runtime: provided.al2 metadata: {'BuildMethod': 'rust-cargolambda'} architecture: x86_64 functions: HelloWorldFunction
Running RustCargoLambdaBuilder:CargoLambdaBuild
Running RustCargoLambdaBuilder:RustCopyAndRename
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
A continuación, implementamos nuestra aplicación usando `sam deploy --guided`.
```
hello-rust$ sam deploy --guided
Configuring SAM deploy
======================
Looking for config file [samconfig.toml] : Found
Reading default arguments : Success
Setting default arguments for 'sam deploy'
=========================================
Stack Name [hello-rust]: ENTER
AWS Region [us-west-2]: ENTER
#Shows you resources changes to be deployed and require a 'Y' to initiate deploy
Confirm changes before deploy [Y/n]: ENTER
#SAM needs permission to be able to create roles to connect to the resources in your template
Allow SAM CLI IAM role creation [Y/n]: ENTER
#Preserves the state of previously provisioned resources when an operation fails
Disable rollback [y/N]: ENTER
HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y
Save arguments to configuration file [Y/n]: ENTER
SAM configuration file [samconfig.toml]: ENTER
SAM configuration environment [default]: ENTER
Looking for resources needed for deployment:
...
Uploading to hello-rust/56ba6585d80577dd82a7eaaee5945c0b 817973 / 817973 (100.00%)
Deploying with following values
===============================
Stack name : hello-rust
Region : us-west-2
Confirm changeset : True
Disable rollback : False
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_IAM"]
Parameter overrides : {}
Signing Profiles : {}
Initiating deployment
=====================
Uploading to hello-rust/a4fc54cb6ab75dd0129e4cdb564b5e89.template 1239 / 1239 (100.00%)
Waiting for changeset to be created..
CloudFormation stack changeset
---------------------------------------------------------------------------------------------------------
Operation LogicalResourceId ResourceType Replacement
---------------------------------------------------------------------------------------------------------
+ Add HelloWorldFunctionHelloW AWS::Lambda::Permission N/A
orldPermissionProd
...
---------------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1681427201/f0ef1563-5ab6-4b07-9361-864ca3de6ad6
Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: y
2023-04-13 13:07:17 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 5.0 seconds)
---------------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
---------------------------------------------------------------------------------------------------------
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation
...
---------------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
---------------------------------------------------------------------------------------------------------
Outputs
---------------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/hello-rust-HelloWorldFunctionRole-10II2P13AUDUY
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/
Key HelloWorldFunction
Description Hello World Lambda Function ARN
Value arn:aws:lambda:us-west-2:012345678910:function:hello-rust-HelloWorldFunction-
yk4HzGzYeZBj
---------------------------------------------------------------------------------------------------------
Successfully created/updated stack - hello-rust in us-west-2
```
Para realizar las pruebas, podemos invocar nuestra función de Lambda mediante el punto de conexión de la API.
```
$ curl https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/
Hello World!%
```
Para probar nuestra función localmente, primero nos aseguramos de que la propiedad `Architectures` de nuestra función coincida con nuestro equipo local.
```
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
Metadata:
BuildMethod: rust-cargolambda # More info about Cargo Lambda: https://github.com/cargo-lambda/cargo-lambda
Properties:
CodeUri: ./rust_app # Points to dir of Cargo.toml
Handler: bootstrap # Do not change, as this is the default executable name produced by Cargo Lambda
Runtime: provided.al2
Architectures:
- arm64
...
```
Como ya modificamos nuestra arquitectura de `x86_64` a `arm64` en este ejemplo, ejecutamos `sam build` para actualizar nuestros artefactos de construcción. A continuación, ejecutamos `sam local invoke` para invocar nuestra función de forma local.
```
hello-rust$ sam local invoke
Invoking bootstrap (provided.al2)
Local image was not found.
Removing rapid images for repo public.ecr.aws/sam/emulation-provided.al2
Building image.....................................................................................................................................
Using local image: public.ecr.aws/lambda/provided:al2-rapid-arm64.
Mounting /Users/.../hello-rust/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container
START RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 Version: $LATEST
{"statusCode":200,"body":"Hello World!"}END RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6
REPORT RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 Init Duration: 0.68 ms Duration: 130.63 ms Billed Duration: 131 ms Memory Size: 128 MB Max Memory Used: 128 MB
```
### Proyecto de función de Lambda única
**Este es un ejemplo de una aplicación sin servidor que contiene una función Rust de Lambda.**
Estructura del directorio del proyecto:
```
.
├── Cargo.lock
├── Cargo.toml
├── src
│ └── main.rs
└── template.yaml
```
AWS SAM plantilla:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
...
```
### Proyecto de función de Lambda múltiple
**Este es un ejemplo de una aplicación sin servidor que contiene varias funciones Rust de Lambda.**
Estructura del directorio del proyecto:
```
.
├── Cargo.lock
├── Cargo.toml
├── src
│ ├── function_a.rs
│ └── function_b.rs
└── template.yaml
```
AWS SAM plantilla:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
FunctionA:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties:
Binary: function_a
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
FunctionB:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties:
Binary: function_b
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
```
Archivo `Cargo.toml`:
```
[package]
name = "test-handler"
version = "0.1.0"
edition = "2021"
[dependencies]
lambda_runtime = "0.6.0"
serde = "1.0.136"
tokio = { version = "1", features = ["macros"] }
tracing = { version = "0.1", features = ["log"] }
tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] }
[[bin]]
name = "function_a"
path = "src/function_a.rs"
[[bin]]
name = "function_b"
path = "src/function_b.rs"
```
# Creación de funciones Lambda de Python con in uv AWS SAM
| |
| --- |
| Esta función se encuentra en una versión preliminar AWS SAM y está sujeta a cambios. |
Utilice la interfaz de línea de AWS Serverless Application Model comandos (AWS SAMCLI) con uv un rápido instalador y solucionador de paquetes de Python para crear sus AWS Lambda funciones de Python.
**Topics**
+ [Requisitos previos](#building-python-uv-prerequisites)
+ [Configuración AWS SAM para su uso con funciones Lambda de Python y uv](#building-python-uv-configure)
+ [Ejemplos](#building-python-uv-examples)
## Requisitos previos
**Python**
Para instalar Python, consulta [Descargar Python](https://www.python.org/downloads/) en el *sitio web de Python*.
**uv**
AWS SAMCLIRequiere la instalación de [https://docs.astral.sh/uv/](https://docs.astral.sh/uv/)un instalador y solucionador de paquetes de Python extremadamente rápido. Para obtener instrucciones sobre la instalación, consulta [Instalación](https://docs.astral.sh/uv/getting-started/installation/) en la *Documentación de uv*.
**Acceda a la característica beta de la CLI de AWS SAM.**
Como esta característica está en versión preliminar, debes acceder usando uno de los siguientes métodos:
1. Usa las variables de entorno: `SAM_CLI_BETA_PYTHON_UV=1`.
1. Añade lo siguiente a tu archivo `samconfig.toml`:
```
[default.build.parameters]
beta_features = true
[default.sync.parameters]
beta_features = true
```
1. Utiliza la opción `--beta-features` cuando utiliza un comando de la CLI de AWS SAM compatible. Por ejemplo:
```
$ sam build --beta-features
```
1. Elija la opción `y` cuando la CLI de AWS SAM le pida que acceda. A continuación, se muestra un ejemplo:
```
$ sam build
Starting Build use cache
Build method "python-uv" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
```
## Configuración AWS SAM para su uso con funciones Lambda de Python y uv
### Paso 1: Configura tu AWS SAM plantilla
Configura tu AWS SAM plantilla con lo siguiente:
+ **BuildMethod** – `python-uv`.
+ **CodeUri**— ruta al directorio de códigos de funciones que contiene `pyproject.toml` o`requirements.txt`.
+ **Controlador**: su controlador de funciones (por ejemplo,`app.lambda_handler`).
+ **Runtime**: versión en tiempo de ejecución de Python (p. ej.,`python3.12`).
Este es un ejemplo de una AWS SAM plantilla configurada:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./my_function
Handler: app.lambda_handler
Runtime: python3.12
Metadata:
BuildMethod: python-uv
...
```
## Ejemplos
### Ejemplo de Hello World
**En este ejemplo, creamos un ejemplo de aplicación Hello World utilizando Python uv como gestor de paquetes.**
uvpuede usar `pyproject.toml` o `requirements.txt` leer las dependencias. Si se proporcionan ambos, `sam build` leerá desde `requirements.txt` para ver las dependencias.
La siguiente es la estructura de nuestra aplicación Hello World:
```
hello-python-uv
├── README.md
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── pyproject.toml
├── samconfig.toml
└── template.yaml
```
Archivo `pyproject.toml`:
```
[project]
name = "my-function"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = [
"requests>=2.31.0",
"boto3>=1.28.0",
]
```
En nuestra AWS SAM plantilla, nuestra función de Python se define de la siguiente manera:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.12
Architectures:
- x86_64
Metadata:
BuildMethod: python-uv
```
A continuación, ejecuta `sam build` para crear e implementar la aplicación. La CLI de AWS SAM crea un directorio de `.aws-sam` y organiza allí nuestros artefactos de construcción. Las dependencias de nuestras funciones se instalan uv y almacenan en`.aws-sam/build/HelloWorldFunction/`.
```
hello-python-uv$ sam build
Starting Build use cache
Build method "python-uv" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
Experimental features are enabled for this session.
Visit the docs page to learn more about the AWS Beta terms https://aws.amazon.com/service-terms/.
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../hello-python-uv/hello_world runtime: python3.12 metadata: {'BuildMethod': 'python-uv'} architecture: x86_64 functions: HelloWorldFunction
Running PythonUvBuilder:UvBuild
Running PythonUvBuilder:CopySource
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
**nota**
El método de `python-uv` compilación se configura por función en la `Metadata` sección. Cada función de la plantilla puede utilizar un método de creación diferente, lo que te permite mezclar funciones uv basadas con funciones `pip` basadas en la misma AWS SAM plantilla. Si no se especifica ningún método de compilación, `pip` se utiliza de forma predeterminada.
# Creación de funciones Lambda con tiempos de ejecución personalizados en AWS SAM
Puedes usar el comando `sam build` para crear los tiempos de ejecución personalizados necesarios para la función de Lambda. Para declarar que la función de Lambda utilizarás un tiempo de ejecución personalizado, especifique `Runtime: provided` para la función.
Para crear un tiempo de ejecución personalizado, declare el atributo de recurso `Metadata` con una entrada `BuildMethod: makefile`. Proporcione el archivo Make personalizado, en el que se declara el destino de compilación del formulario `build-function-logical-id` que contienes los comandos de compilación para su tiempo de ejecución. El archivo Make se encarga de compilar el tiempo de ejecución personalizado, si es necesario, y de copiar los artefactos de compilación en la ubicación adecuada para los pasos posteriores del flujo de trabajo. La ubicación del archivo Make viene especificada por la propiedad `CodeUri` del recurso de la función y debes llamarse `Makefile`.
## Ejemplos
### Ejemplo 1: tiempo de ejecución personalizado para una función escrita en Rust
**nota**
Recomendamos crear funciones de Lambda con Cargo Lambda. Para obtener más información, consulte [Creación de funciones de Rust Lambda con in Cargo Lambda AWS SAM](building-rust.md).
La siguiente AWS SAM plantilla declara una función que usa un tiempo de ejecución personalizado para una función Lambda escrita en Rust e indica `sam build` que se ejecuten los comandos para el `build-HelloRustFunction` destino de compilación.
```
Resources:
HelloRustFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: HelloRust
Handler: bootstrap.is.real.handler
Runtime: provided
MemorySize: 512
CodeUri: .
Metadata:
BuildMethod: makefile
```
El archivo Make siguiente contiene el destino de compilación y los comandos que se ejecutarán. Tenga en cuenta que la propiedad `CodeUri` está establecida en `.`, por lo que el archivo Make debes estar ubicado en el directorio raíz del proyecto (es decir, el mismo directorio que el archivo de plantilla de la aplicación de AWS SAM ). El nombre del archivo debes ser `Makefile`.
```
build-HelloRustFunction:
cargo build --release --target x86_64-unknown-linux-musl
cp ./target/x86_64-unknown-linux-musl/release/bootstrap $(ARTIFACTS_DIR)
```
Para obtener más información sobre cómo configurar el entorno de desarrollo para ejecutar el comando `cargo build` en el anterior `makefile`, consulta la publicación de blog [Tiempo de ejecución de Rust para AWS Lambda](https://aws.amazon.com/blogs/opensource/rust-runtime-for-aws-lambda/).
### Ejemplo 2: generador de archivos Make para Python3.12 (una alternativa al generador incluido)
Es posible que quieras utilizar una biblioteca o un módulo que no esté incluido en un paquete de creación. En este ejemplo, se muestra una AWS SAM plantilla para un entorno de ejecución de Python 3.12 con un generador de archivos makefile.
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.12
Metadata:
BuildMethod: makefile
```
El archivo Make siguiente contiene el destino de compilación y los comandos que se ejecutarán. Ten en cuenta que la propiedad `CodeUri` está establecida en `hello_world`, por lo que el archivo Make debe estar ubicado en la raíz del subdirectorio `hello_world` y el nombre del archivo debe ser `Makefile`.
```
build-HelloWorldFunction:
cp *.py $(ARTIFACTS_DIR)
cp requirements.txt $(ARTIFACTS_DIR)
python -m pip install -r requirements.txt -t $(ARTIFACTS_DIR)
rm -rf $(ARTIFACTS_DIR)/bin
```
# 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
```