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.
# Desarrolle su aplicación sin servidor con AWS SAM
Esta sección contiene temas sobre la validación de la AWS SAM plantilla y la creación de la aplicación con dependencias. También contiene temas sobre su uso AWS SAM en determinados casos de uso, como el trabajo con capas Lambda, el uso de aplicaciones anidadas, el control del acceso a API APIs Gateway, la organización de los recursos con AWS Step Functions y la firma de código de las aplicaciones. Los tres hitos principales que debe completar para desarrollar su aplicación se enumeran a continuación.
**Topics**
+ [Crea tu aplicación en AWS SAM](using-sam-cli-init.md)
+ [Defina su infraestructura con AWS SAM](serverless-authoring.md)
+ [Cree su aplicación con AWS SAM](serverless-building.md)
# Crea tu aplicación en AWS SAM
Después de completar [Introducción](serverless-getting-started.md) y de leer [Cómo usar AWS Serverless Application Model (AWS SAM)](chapter-using-sam.md), estará listo para crear un proyecto de AWS SAM en su entorno de desarrollador. Su AWS SAM proyecto servirá como punto de partida para escribir su aplicación sin servidor. Para obtener una lista de las opciones de AWS SAMCLI `sam init` comando, consulte[sam init](sam-cli-command-reference-sam-init.md).
El AWS Serverless Application Model comando Command Line Interface (AWS SAMCLI) `sam init` proporciona opciones para inicializar una nueva aplicación sin servidor que consta de:
+ Una AWS SAM plantilla para definir el código de infraestructura.
+ Una estructura de carpetas que organiza la aplicación.
+ Configuración para sus AWS Lambda funciones.
Para crear un AWS SAM proyecto, consulte los temas de estas secciones.
**nota**
`sam init`incluye plantillas de proyectos para funciones duraderas en tiempos de ejecución compatibles (PythonTypeScript, Java). Estas plantillas proporcionan código de inicio y configuración para crear aplicaciones sin servidor con estado.
**Topics**
+ [Inicialización de aplicación sin servidor](#using-sam-cli-init-new)
+ [Opciones para el inicio de sesión](#using-sam-cli-init-options)
+ [Resolución de problemas](#using-sam-cli-init-troubleshooting)
+ [Ejemplos](#using-sam-cli-init-examples)
+ [Más información](#using-sam-cli-init-learn)
+ [Siguientes pasos](#w2aac18c11c39)
## Inicialización de aplicación sin servidor
**Cómo inicializar una nueva aplicación sin servidor mediante la CLI de AWS SAM**
1. `cd` a un directorio de inicio.
1. Ejecute lo siguiente en la línea de comandos:
```
$ sam init
```
1. La CLI de AWS SAM lo guiará a través de un flujo interactivo para crear una nueva aplicación sin servidor.
**nota**
Como se explica en [Tutorial: Implemente una aplicación Hello World con AWS SAM](serverless-getting-started-hello-world.md), este comando inicializa la aplicación sin servidor y crea el directorio del proyecto. Este directorio contendrá varios archivos y carpetas. El archivo más importante es `template.yaml`. Esta es tu plantilla. AWS SAM Su versión de python debe coincidir con la versión de python que aparece en el archivo `template.yaml` que creó el comando **sam init**.
### Elegir una plantilla inicial
Una *plantilla* consta de lo siguiente:
1. Una AWS SAM plantilla para su código de infraestructura.
1. Un directorio inicial del proyecto que organiza los archivos del proyecto. Por ejemplo, esto puede incluir:
1. Una estructura para el código de la función de Lambda y sus dependencias.
1. Una carpeta `events` que contiene los eventos de prueba para las testeo local.
1. Una carpeta `tests` para respaldar las pruebas unitarias.
1. Un archivo `samconfig.toml` para configurar los ajustes del proyecto.
1. Un archivo `ReadMe` y otros archivos básicos de inicio del proyecto.
A continuación, se muestra un ejemplo de un directorio inicial para un proyecto:
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
├── integration
│ ├── __init__.py
│ └── test_api_gateway.py
├── requirements.txt
└── unit
├── __init__.py
└── test_handler.py
```
Puede seleccionar de una lista de *plantillas de inicio rápido de AWS * disponibles o proporcionar su propia *ubicación de plantilla personalizada*.
**Para elegir una plantilla de inicio AWS rápido**
1. Cuando se le solicite, seleccione **Plantillas de inicio rápido de AWS **.
1. Seleccione una plantilla de inicio AWS rápido para empezar. A continuación, se muestra un ejemplo:
```
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: 4
```
**Para elegir su propia ubicación de plantilla personalizada**
1. Cuando se le solicite, seleccione la **ubicación de la plantilla personalizada**.
```
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 2
```
1. La CLI de AWS SAM le pedirá que proporciona una ubicación para la plantilla.
```
Template location (git, mercurial, http(s), zip, path):
```
Proporciona cualquiera de las siguientes ubicaciones al archivo.zip de la plantilla:
+ **Repositorio GitHub**: la ruta al archivo.zip de su repositorio GitHub. El archivo debe estar en la raíz del repositorio.
+ **Repositorio Mercurial**: la ruta al archivo.zip de su repositorio Mercurial. El archivo debe estar en la raíz del repositorio.
+ **Ruta.zip**: una ruta HTTPS o local a su archivo.zip.
1. La CLI de AWS SAM inicializará la aplicación sin servidor con su plantilla personalizada.
### Elija un tiempo de ejecución
Al elegir una *plantilla de inicio rápido de AWS *, la CLI de AWS SAM le pide que seleccione un tiempo de ejecución para las funciones de Lambda. La lista de opciones que muestra la CLI de AWS SAM son los tiempos de ejecución compatibles de forma nativa con Lambda.
+ El [tiempo de ejecución](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-runtime) proporciona un entorno específico del lenguaje que se ejecuta en el entorno de ejecución.
+ [Cuando se implementa en Nube de AWS, el servicio Lambda invoca la función en un entorno de ejecución.](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtime-environment.html)
Puedes utilizar cualquier otro lenguaje de programación con un tiempo de ejecución personalizado. Para ello, debe crear manualmente la estructura inicial de la aplicación. A continuación, puede utilizar `sam init` para inicializar rápidamente la aplicación configurando una ubicación de plantilla personalizada.
A partir de tu selección, la CLI de AWS SAM crea el directorio de inicio para el código y las dependencias de la función de Lambda.
Si Lambda admite varios administradores de dependencias para su tiempo de ejecución, se le solicitará que elija el administrador de dependencias que prefiera.
### Elija un tipo de paquete
Cuando elige una *plantilla de inicio rápido de AWS * y un *tiempo de ejecución*, la CLI de AWS SAM le pide que seleccione un *tipo de paquete*. El tipo de paquete determina cómo se implementan las funciones de Lambda para usarlas con el servicio de Lambda. Los dos tipos de paquetes compatibles son:
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.
1. **Un archivo de archivo .zip**, que incluye el código de la aplicación y sus dependencias.
Para obtener más información sobre paquetes de implementación, 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 *.
A continuación, se muestra un ejemplo de estructura de directorios de una aplicación con una función de Lambda empaquetada como imagen de contenedor. AWS SAMCLIDescarga la imagen y crea un directorio `Dockerfile` en el directorio de la función para especificar la imagen.
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── Dockerfile
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
└── unit
├── __init__.py
└── test_handler.py
```
A continuación, se muestra un ejemplo de estructura de directorios de una aplicación con una función empaquetada como un archivo de archivos.zip.
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
├── integration
│ ├── __init__.py
│ └── test_api_gateway.py
├── requirements.txt
└── unit
├── __init__.py
└── test_handler.py
```
### Configura el AWS X-Ray rastreo
Puede optar por activar el AWS X-Ray rastreo. Para obtener más información, consulta [¿Qué es? AWS X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html) en la *Guía para AWS X-Ray desarrolladores*.
Si la activas, AWS SAMCLI configura tu AWS SAM plantilla. A continuación, se muestra un ejemplo:
```
Globals:
Function:
...
Tracing: Active
Api:
TracingEnabled: True
```
### Configure la supervisión con Amazon CloudWatch Application Insights
Puede optar por activar la supervisión mediante Amazon CloudWatch Application Insights. Para obtener más información, consulte [Amazon CloudWatch Application Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html) en la *Guía del CloudWatch usuario de Amazon*.
Si la activas, AWS SAMCLI configurará tu AWS SAM plantilla. A continuación, se muestra un ejemplo:
```
Resources:
ApplicationResourceGroup:
Type: AWS::ResourceGroups::Group
Properties:
Name:
Fn::Join:
- ''
- - ApplicationInsights-SAM-
- Ref: AWS::StackName
ResourceQuery:
Type: CLOUDFORMATION_STACK_1_0
ApplicationInsightsMonitoring:
Type: AWS::ApplicationInsights::Application
Properties:
ResourceGroupName:
Fn::Join:
- ''
- - ApplicationInsights-SAM-
- Ref: AWS::StackName
AutoConfigurationEnabled: 'true'
DependsOn: ApplicationResourceGroup
```
### Asigne un nombre a la aplicación.
Indique un nombre para su solicitud. La CLI de AWS SAM crea una carpeta de nivel superior para la aplicación con este nombre.
## Opciones para el inicio de sesión
Estas son algunas de las opciones principales que puede utilizar con el comando `sam init`. Para obtener una lista de todas las opciones, consulta [sam init](sam-cli-command-reference-sam-init.md).
### Inicializa una aplicación mediante una ubicación de plantilla personalizada
Utiliza la opción `--location` y proporciona una ubicación de plantilla personalizada compatible. A continuación, se muestra un ejemplo:
```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```
### Inicializa una aplicación sin el flujo interactivo
Utiliza la opción `--no-interactive` y proporciona las opciones de configuración en la línea de comandos para omitir el flujo interactivo. A continuación, se muestra un ejemplo:
```
$ sam init --no-interactive --runtime go1.x --name go-demo --dependency-manager mod --app-template hello-world
```
## Resolución de problemas
Para solucionar el problema AWS SAMCLI, consulte. [Solución de problemas para AWS SAM CLI](sam-cli-troubleshooting.md)
## Ejemplos
### Inicialice una nueva aplicación sin servidor mediante la plantilla Hello World Starter AWS
Para ver este ejemplo, consulta [Paso 1: inicializar la aplicación de muestra Hello World](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-init) en el *tutorial: Implementación de una aplicación de Hello World*.
### Inicializa una nueva aplicación sin servidor con una ubicación de plantilla personalizada
Los siguientes son ejemplos de cómo proporcionar una ubicación GitHub a la plantilla personalizada:
```
$ sam init --location gh:aws-samples/cookiecutter-aws-sam-python
$ sam init --location git+sh://git@github.com/aws-samples/cookiecutter-aws-sam-python.git
$ sam init --location hg+ssh://hg@bitbucket.org/repo/template-name
```
A continuación, se muestra un ejemplo de una ruta de archivo local:
```
$ sam init --location /path/to/template.zip
```
A continuación, se muestra un ejemplo de una ruta a la que se puede acceder mediante HTTPS:
```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```
## Más información
Para obtener más información sobre el uso del comando `sam init`, consulta los enlaces siguientes:
+ **[Aprendizaje AWS SAM: sam init, sobre la](https://www.youtube.com/watch?v=9m3R-leD5Xo)** serie Serverless Land «Aprendizaje AWS SAM». YouTube
+ **[Estructuración de aplicaciones sin servidor para su uso con la CLI de AWS SAM(Sesiones con SAM S2E7)](https://www.youtube.com/watch?v=k9IRdgze9fQ)**: Sesiones con la serie AWS SAM en YouTube.
## Siguientes pasos
Ahora que ha creado su AWS SAM proyecto, está listo para empezar a crear su aplicación. Consulte [Defina su infraestructura con AWS SAM](serverless-authoring.md) para obtener instrucciones detalladas sobre las tareas que debe completar para hacerlo.
# Defina su infraestructura con AWS SAM
Ahora que ha creado su proyecto, está listo para definir su infraestructura de aplicaciones con él AWS SAM. Para ello, configure la AWS SAM plantilla para definir los recursos y las propiedades de la aplicación, que es el `template.yaml` archivo AWS SAM del proyecto.
Los temas de esta sección proporcionan contenido sobre cómo definir la infraestructura en la AWS SAM plantilla (el `template.yaml` archivo). También contiene temas sobre la definición de recursos para casos de uso específicos, como el trabajo con capas Lambda, el uso de aplicaciones anidadas, el control del acceso a API Gateway, la organización de los recursos con AWS Step Functions APIs, la firma de código de las aplicaciones y la validación de la plantilla. AWS SAM
**Topics**
+ [Defina los recursos de la aplicación en su AWS SAM plantilla](authoring-define-resources.md)
+ [Configura y administra el acceso a los recursos en tu AWS SAM plantilla](sam-permissions.md)
+ [Controla el acceso a la API con tu AWS SAM plantilla](serverless-controlling-access-to-apis.md)
+ [Aumente la eficiencia con las capas Lambda con AWS SAM](serverless-sam-cli-layers.md)
+ [Reutilice el código y los recursos mediante aplicaciones anidadas en AWS SAM](serverless-sam-template-nested-applications.md)
+ [Gestione eventos basados en el tiempo con el EventBridge programador en AWS SAM](using-eventbridge-scheduler.md)
+ [Organizar los AWS SAM recursos con AWS Step Functions](serverless-step-functions-in-sam.md)
+ [Configura la firma de código para tu AWS SAM aplicación](authoring-codesigning.md)
+ [Validar archivos AWS SAM de plantilla](serverless-sam-cli-using-validate.md)
# Defina los recursos de la aplicación en su AWS SAM plantilla
Los AWS recursos que utiliza la aplicación sin servidor se definen en la `Resources` sección de la AWS SAM plantilla. Al definir un recurso, identifica qué es el recurso, cómo interactúa con otros recursos y cómo se puede acceder a él (es decir, los permisos del recurso).
La `Resources` sección de la AWS SAM plantilla puede contener una combinación de CloudFormation recursos y AWS SAM recursos. Además, puedes usar AWS SAM la sintaxis abreviada para los siguientes recursos:
| AWS SAM sintaxis abreviada | Qué hace con un recurso relacionado AWS |
| --- | --- |
| [AWS::Serverless::Api](sam-resource-api.md) | Crea una colección de recursos y métodos de Amazon API Gateway que se pueden invocar a través de puntos de conexión HTTPS. |
| [AWS::Serverless::Application](sam-resource-application.md) | Integrar una aplicación sin servidor desde [AWS Serverless Application Repository](https://serverlessrepo.aws.amazon.com/applications) o desde un bucket de Amazon S3 como una aplicación anidada. |
| [AWS::Serverless::Connector](sam-resource-connector.md) | Configura permisos entre dos recursos. Para obtener una introducción a los conectores, consulta [Administrar los permisos de recursos con AWS SAM conectores](managing-permissions-connectors.md). |
| [AWS::Serverless::Function](sam-resource-function.md) | Crea una AWS Lambda función, un rol de ejecución AWS Identity and Access Management (IAM) y mapeos de fuentes de eventos que activan la función. |
| [AWS::Serverless::GraphQLApi](sam-resource-graphqlapi.md) | crea y configura una AWS AppSync GraphQL API para su aplicación sin servidor. |
| [AWS::Serverless::HttpApi](sam-resource-httpapi.md) | Crea una API HTTP de Amazon API Gateway, que le permite crear RESTful APIs con menor latencia y costes más bajos que REST APIs. |
| [AWS::Serverless::LayerVersion](sam-resource-layerversion.md) | Crea una Lambda LayerVersion que contiene el código de biblioteca o de tiempo de ejecución que necesita una función Lambda. |
| [AWS::Serverless::SimpleTable](sam-resource-simpletable.md) | Crea una tabla de DynamoDB con una claves principal de atributo único. |
| [AWS::Serverless::StateMachine](sam-resource-statemachine.md) | Crea una máquina de AWS Step Functions estados que se puede utilizar para organizar AWS Lambda funciones y otros AWS recursos a fin de crear flujos de trabajo complejos y sólidos. |
Los recursos anteriores también se enumeran en [AWS SAM recursos y propiedades](sam-specification-resources-and-properties.md).
Para obtener información de referencia sobre todos los tipos de AWS recursos y propiedades CloudFormation y el AWS SAM soporte, consulte la [referencia sobre tipos de AWS recursos y propiedades](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html) en la *Guía del AWS CloudFormation usuario*.
# Configura y administra el acceso a los recursos en tu AWS SAM plantilla
Para que AWS los recursos interactúen entre sí, se deben configurar el acceso y los permisos adecuados entre los recursos. Para ello, es necesario configurar los usuarios, las funciones y las políticas AWS Identity and Access Management (de IAM) para que la interacción se lleve a cabo de forma segura.
Todos los temas de esta sección están relacionados con la configuración del acceso a los recursos definidos en la plantilla. Esta sección comienza con las prácticas recomendadas generales. En los dos temas siguientes se analizan dos opciones de las que dispone para configurar el acceso y los permisos entre los recursos a los que se hace referencia en su aplicación sin servidor: los AWS SAM conectores y las plantillas de AWS SAM políticas. El último tema proporciona detalles sobre la administración del acceso de los usuarios mediante la misma mecánica que se CloudFormation utiliza para la administración de los usuarios.
Para obtener más información, consulta [Control de acceso con AWS Identity and Access Management](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) en la *Guía del usuario de AWS CloudFormation *.
El AWS Serverless Application Model (AWS SAM) ofrece dos opciones que simplifican la administración del acceso y los permisos de las aplicaciones sin servidor.
1. AWS SAM conectores
1. Plantillas de política de AWS SAM
## AWS SAM conectores
Los conectores son una forma de aprovisionar permisos entre dos recursos. Para ello, describe cómo deben interactuar entre sí en la AWS SAM plantilla. Se pueden definir mediante el atributo de recurso `Connectors` o el tipo de recurso `AWS::Serverless::Connector`. Los conectores permiten el aprovisionamiento `Read` y el `Write` acceso a datos y eventos entre una combinación de AWS recursos. Para obtener más información sobre AWS SAM los conectores, consulte[Administrar los permisos de recursos con AWS SAM conectores](managing-permissions-connectors.md).
## Plantillas de política de AWS SAM
AWS SAM Las plantillas de políticas son conjuntos de permisos predefinidos que puede añadir a sus AWS SAM plantillas para gestionar el acceso y los permisos entre sus AWS Lambda funciones, las máquinas de AWS Step Functions estado y los recursos con los que interactúan. Para obtener más información sobre las plantillas AWS SAM de políticas, consulte[Plantillas de política de AWS SAM](serverless-policy-templates.md).
## AWS CloudFormation mecanismos
CloudFormation los mecanismos incluyen la configuración de los usuarios, las funciones y las políticas de IAM para gestionar los permisos entre los AWS recursos. Para obtener más información, consulte [Gestión de AWS SAM permisos con CloudFormation mecanismos](sam-permissions-cloudformation.md).
## Prácticas recomendadas
En todas sus aplicaciones sin servidor, puede utilizar varios métodos para configurar los permisos entre los recursos. Por lo tanto, puede seleccionar la mejor opción para cada escenario y utilizar varias opciones juntas en todas sus aplicaciones. Estas son algunas cosas que se deben tener en cuenta cuando se elige la mejor opción para usted:
+ AWS SAM Tanto los conectores como las plantillas de políticas reducen la experiencia en IAM necesaria para facilitar las interacciones seguras entre los recursos. AWS Utiliza conectores y plantillas de políticas cuando sean compatibles.
+ AWS SAM Los conectores proporcionan una sintaxis abreviada sencilla e intuitiva para definir los permisos en AWS SAM las plantillas y requieren el mínimo nivel de experiencia en IAM. Si se admiten tanto AWS SAM los conectores como las plantillas de políticas, utilice AWS SAM conectores.
+ AWS SAM los conectores pueden aprovisionar datos `Read` y eventos y `Write` acceder a ellos entre los recursos de AWS SAM origen y destino compatibles. Para obtener una lista de recursos admitidos, consulta [AWS SAM referencia de conector](reference-sam-connector.md). Cuando sea compatible, utilice AWS SAM conectores.
+ Si bien las plantillas de AWS SAM políticas se limitan a los permisos entre las funciones de Lambda, las máquinas de estado de Step Functions y los AWS recursos con los que interactúan, las plantillas de políticas admiten todas las operaciones de CRUD. Cuando sea compatible y cuando haya una plantilla AWS SAM de política disponible para su escenario, utilice plantillas de AWS SAM políticas. Para obtener una lista de las plantillas de políticas disponibles, consulta [Plantillas de política de AWS SAM](serverless-policy-templates.md).
+ Para todos los demás escenarios, o cuando se requiera granularidad, utilice CloudFormation mecanismos.
# Administrar los permisos de recursos con AWS SAM conectores
Los conectores son un tipo de recurso abstracto AWS Serverless Application Model (AWS SAM), identificado como`AWS::Serverless::Connector`, que proporciona permisos simples y con un amplio alcance entre los recursos de las aplicaciones sin servidor.
## Ventajas de los conectores AWS SAM
Al elaborar automáticamente las políticas de acceso adecuadas entre los recursos, los conectores le permiten crear sus aplicaciones sin servidor y centrarse en la arquitectura de las aplicaciones sin necesidad de conocimientos especializados en capacidades de AWS autorización, lenguaje de políticas y configuraciones de seguridad específicas de los servicios. Por lo tanto, los conectores son una gran ventaja para los desarrolladores que se están iniciando en el desarrollo sin servidores o para los desarrolladores experimentados que desean aumentar su velocidad de desarrollo.
## Uso de conectores AWS SAM
Utiliza el atributo `Connectors` de recurso integrándolo en un **recurso fuente.** A continuación, defina el recurso de **destino** y describa cómo deben fluir los datos o los eventos entre esos recursos. AWS SAM a continuación, redacta las políticas de acceso necesarias para facilitar las interacciones requeridas.
A continuación se describe cómo se escribe este atributo de recurso:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
:
Type:
...
Connectors:
:
Properties:
Destination:
Permissions:
...
```
## Cómo funcionan los conectores
**nota**
En esta sección se explica cómo los conectores proporcionan los recursos necesarios entre bastidores. Esto sucede automáticamente al utilizar conectores.
En primer lugar, el atributo `Connectors` de recurso incrustado se transforma en un tipo de recurso `AWS::Serverless::Connector`. Su ID lógico se crea automáticamente como**.
Por ejemplo, aquí hay un conector integrado:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Lambda::Function
Connectors:
MyConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Read
- Write
MyTable:
Type: AWS::DynamoDB::Table
```
Esto generará el siguiente recurso `AWS::Serverless::Connector`:
```
Transform: AWS::Serverless-2016-10-31
Resources:
...
MyFunctionMyConn:
Type: AWS::Serverless::Connector
Properties:
Source:
Id: MyFunction
Destination:
Id: MyTable
Permissions:
- Read
- Write
```
**nota**
También puede definir los conectores en la AWS SAM plantilla mediante esta sintaxis. Esto se recomienda cuando el recurso de origen está definido en una plantilla independiente de la del conector.
A continuación, se redactan automáticamente las políticas de acceso necesarias para esta conexión. Para obtener más información acerca de los recursos generados por conectores, consulta [CloudFormation recursos generados cuando se especifica AWS::Serverless::Connector](sam-specification-generated-resources-connector.md).
## Ejemplo de conectores
El siguiente ejemplo muestra cómo puede utilizar conectores para escribir datos de una AWS Lambda función en una tabla de Amazon DynamoDB.
![\[Una función de Lambda que escribe datos en una tabla de DynamoDB mediante conectores de AWS SAM .\]](http://docs.aws.amazon.com/es_es/serverless-application-model/latest/developerguide/images/managing-connectors-example.png)
```
Transform: AWS::Serverless-2016-10-31
Resources:
MyTable:
Type: AWS::Serverless::SimpleTable
MyFunction:
Type: AWS::Serverless::Function
Connectors:
MyConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Write
Properties:
Runtime: nodejs16.x
Handler: index.handler
InlineCode: |
const AWS = require("aws-sdk");
const docClient = new AWS.DynamoDB.DocumentClient();
exports.handler = async (event, context) => {
await docClient.put({
TableName: process.env.TABLE_NAME,
Item: {
id: context.awsRequestId,
event: JSON.stringify(event)
}
}).promise();
}
Environment:
Variables:
TABLE_NAME: !Ref MyTable
```
El atributo de recurso `Connectors` está integrado en el recurso fuente de la función de Lambda. La tabla de DynamoDB se define como el recurso de destino que utiliza la propiedad `Id`. Los conectores proporcionarán permisos `Write` entre estos dos recursos.
Al implementar la AWS SAM plantilla en CloudFormation, AWS SAM redactará automáticamente las políticas de acceso necesarias para que esta conexión funcione.
## Recursos de origen y destino compatibles para los conectores
Compatibilidad con conectores `Read` y tipos de permisos de datos y eventos `Write` entre una combinación selecta de conexiones de recursos de origen y destino. Por ejemplo, los conectores admiten una conexión `Write` entre un recurso `AWS::ApiGateway::RestApi` de origen y un recurso `AWS::Lambda::Function` de destino.
Los recursos de origen y destino se puedesn definir mediante una combinación de propiedades compatibles. Los requisitos de propiedad dependerán de la conexión que se realice y de dónde estén definidos los recursos.
**nota**
Los conectores puedesn proporcionar permisos entre los tipos de recursos compatibles sin servidor y con servidor.
Para obtener una lista de conexiones de recursos compatibles y sus requisitos de propiedad, consulta [Tipos de recursos de origen y destino admitidos para los conectores](reference-sam-connector.md#supported-connector-resource-types).
# Defina los permisos de lectura y escritura en AWS SAM
En AWS SAM, `Read` y `Write` los permisos se pueden aprovisionar dentro de un único conector:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Lambda::Function
Connectors:
MyTableConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Read
- Write
MyTable:
Type: AWS::DynamoDB::Table
```
Para obtener más información sobre el uso de conectores, consulte [AWS SAM referencia de conector](reference-sam-connector.md).
# Defina los recursos mediante otras propiedades compatibles en AWS SAM
Para los recursos de origen y destino, cuando se definen en la misma plantilla, utiliza la propiedad `Id`. Si lo desea, puedes añadirse un `Qualifier` para reducir el alcance del recurso definido. Cuando el recurso no esté dentro de la misma plantilla, utiliza una combinación de propiedades admitidas.
+ Para obtener una lista de las combinaciones de propiedades compatibles para los recursos de origen y destino, consulta [Tipos de recursos de origen y destino admitidos para los conectores](reference-sam-connector.md#supported-connector-resource-types).
+ Para obtener una descripción de las propiedades que puedes usar con los conectores, consulta [AWS::Serverless::Connector](sam-resource-connector.md).
Cuando define un recurso de origen con una propiedad distinta de `Id`, utiliza la propiedad `SourceReference`.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
:
Type:
...
Connectors:
:
Properties:
SourceReference:
Qualifier:
Destination:
Permissions:
```
A continuación, se muestra un ejemplo del uso de un `Qualifier` para reducir el alcance de un recurso de Amazon API Gateway:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyApi:
Type: AWS::Serverless::Api
Connectors:
ApiToLambdaConn:
Properties:
SourceReference:
Qualifier: Prod/GET/foobar
Destination:
Id: MyFunction
Permissions:
- Write
...
```
A continuación, se muestra un ejemplo en el que se utiliza una combinación compatible de `Arn` y `Type` para definir un recurso de destino a partir de otra plantilla:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
TableConn:
Properties:
Destination:
Type: AWS::DynamoDB::Table
Arn: !GetAtt MyTable.Arn
...
```
Para obtener más información sobre el uso de conectores, consulte [AWS SAM referencia de conector](reference-sam-connector.md).
# Cree varios conectores a partir de una sola fuente en AWS SAM
Dentro de un recurso de origen, puedes definir varios conectores, cada uno con un recurso de destino diferente.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
BucketConn:
Properties:
Destination:
Id: amzn-s3-demo-bucket
Permissions:
- Read
- Write
SQSConn:
Properties:
Destination:
Id: MyQueue
Permissions:
- Read
- Write
TableConn:
Properties:
Destination:
Id: MyTable
Permissions:
- Read
- Write
TableConnWithTableArn:
Properties:
Destination:
Type: AWS::DynamoDB::Table
Arn: !GetAtt MyTable.Arn
Permissions:
- Read
- Write
...
```
Para obtener más información sobre el uso de conectores, consulte [AWS SAM referencia de conector](reference-sam-connector.md).
# Cree conectores multidestino en AWS SAM
Dentro de un recurso de origen, puedes definir un conector único con varios recursos de destino. A continuación, se muestra un ejemplo de recurso fuente de una función de Lambda para conectarse a un bucket de Amazon Simple Storage Service (Amazon S3) y a una tabla de DynamoDB:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
WriteAccessConn:
Properties:
Destination:
- Id: OutputBucket
- Id: CredentialTable
Permissions:
- Write
...
OutputBucket:
Type: AWS::S3::Bucket
CredentialTable:
Type: AWS::DynamoDB::Table
```
Para obtener más información sobre el uso de conectores, consulte [AWS SAM referencia de conector](reference-sam-connector.md).
# Defina los atributos de los recursos con los conectores incluidos AWS SAM
Los atributos de los recursos se pueden definir para que los recursos especifiquen comportamientos y relaciones adicionales. Para obtener más información sobre los atributos de los recursos, consulta la [referencia a los atributos de los recursos](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-product-attribute-reference.html) en la *Guía del usuario AWS CloudFormation *.
Puedes añadir atributos de recursos al conector integrado definiéndolos al mismo nivel que las propiedades del conector. Cuando la AWS SAM plantilla se transforme en el momento de la implementación, los atributos pasarán a los recursos generados.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
MyConn:
DeletionPolicy: Retain
DependsOn: AnotherFunction
Properties:
...
```
Para obtener más información sobre el uso de conectores, consulte [AWS SAM referencia de conector](reference-sam-connector.md).
## Más información
Para obtener más información sobre el uso de AWS SAM conectores, consulte los siguientes temas:
+ [AWS::Serverless::Connector](sam-resource-connector.md)
+ [Defina los permisos de lectura y escritura en AWS SAM](connector-usage-define.md)
+ [Defina los recursos mediante otras propiedades compatibles en AWS SAM](connector-usage-other-properties.md)
+ [Cree varios conectores a partir de una sola fuente en AWS SAM](connector-usage-single-source.md)
+ [Cree conectores multidestino en AWS SAM](connector-usage-multi-destination.md)
+ [Defina los permisos de lectura y escritura en AWS SAM](connector-usage-define.md)
+ [Defina los atributos de los recursos con los conectores incluidos AWS SAM](connector-usage-resource-attributes.md)
## Proporcionar información
Para enviar comentarios sobre los conectores, [envía un nuevo número](https://github.com/aws/serverless-application-model/issues/new?assignees=&labels=area%2Fconnectors,stage%2Fneeds-triage&template=other.md&title=%28Feature%20Request%29) al *serverless-application-model AWS GitHubrepositorio*.
# Plantillas de política de AWS SAM
El AWS Serverless Application Model (AWS SAM) le permite elegir de una lista de plantillas de políticas para limitar los permisos de las funciones y máquinas de AWS Step Functions estado de Lambda a los recursos que utiliza la aplicación.
AWS SAM las aplicaciones AWS Serverless Application Repository que utilizan plantillas de políticas no requieren ningún reconocimiento especial del cliente para implementar la aplicación desde. AWS Serverless Application Repository
Si desea solicitar que se agregue una nueva plantilla de política, haga lo siguiente:
1. Envía una solicitud de incorporación de datos utilizando el archivo fuente policy\$1templates.json de la rama del proyecto. `develop` AWS SAM GitHub [Puedes encontrar el archivo fuente en policy\$1templates.json en el sitio web.](https://github.com/aws/serverless-application-model/blob/develop/samtranslator/policy_templates_data/policy_templates.json) GitHub
1. Envía una incidencia en el AWS SAM GitHub proyecto que incluya los motivos de tu solicitud de cambios y un enlace a la solicitud. Utiliza este enlace para enviar una nueva edición: [Issues AWS Serverless Application Model](https://github.com/aws/serverless-application-model/issues/new).
## Sintaxis
Para cada plantilla de política que especifiques en tu archivo de AWS SAM plantilla, siempre debes especificar un objeto que contenga los valores de los marcadores de posición de la plantilla de política. Si una plantilla de política no requiere ningún valor de marcador de posición, debe especificar un objeto vacío.
### YAML
```
MyFunction:
Type: AWS::Serverless::Function
Properties:
Policies:
- PolicyTemplateName1: # Policy template with placeholder value
Key1: Value1
- PolicyTemplateName2: {} # Policy template with no placeholder value
```
**nota**
Si ha configurado una política de IAM o ha administrado políticas mediante Lambda, la plantilla de política se puede configurar sin utilizar un objeto vacío.
## Ejemplos
### Ejemplo 1: plantilla de política con valores de marcador de posición
El siguiente ejemplo muestra que la plantilla de política [SQSPollerPolicy](serverless-policy-template-list.md#sqs-poller-policy) espera `QueueName` como recurso. La AWS SAM plantilla recupera el nombre de la cola "`MyQueue`" de Amazon SQS, que puede crear en la misma aplicación o solicitarla como parámetro de la aplicación.
```
1. MyFunction:
2. Type: 'AWS::Serverless::Function'
3. Properties:
4. CodeUri: ${codeuri}
5. Handler: hello.handler
6. Runtime: python2.7
7. Policies:
8. - SQSPollerPolicy:
9. QueueName:
10. !GetAtt MyQueue.QueueName
```
### Ejemplo 2: plantilla de política sin valores de marcador de posición
El ejemplo siguiente contiene la plantilla de política [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy), que no tiene valores de marcador de posición.
**nota**
Aunque no haya valores de marcador de posición, debe especificar un objeto vacío; de lo contrario, se producirá un error.
```
1. MyFunction:
2. Type: 'AWS::Serverless::Function'
3. Properties:
4. CodeUri: ${codeuri}
5. Handler: hello.handler
6. Runtime: python2.7
7. Policies:
8. - CloudWatchPutMetricPolicy: {}
```
### Ejemplo 3: plantilla de políticas con valores de marcadores de posición y una política de IAM normal
El siguiente ejemplo contiene la política y [DynamoDBCrudPolicy](serverless-policy-template-list.md#dynamo-db-crud-policy) la plantilla de políticas de Amazon SQSFull Access. La política de Amazon SQSFull Access es una política de IAM y no una AWS SAM política, por lo que no es necesario especificar un objeto vacío, ya que la política se transferiría directamente a. CloudFormation
```
1. MyFunction:
2. Type: 'AWS::Serverless::Function'
3. Properties:
4. CodeUri: ${codeuri}
5. Handler: hello.handler
6. Runtime: python2.7
7. Policies:
8. - AmazonSQSFullAccess // IAM policy could be set without passing an empty object
9. - DynamoDBCrudPolicy: // SAM specific policy, has a defined structure
10. TableName:
11. !Ref SampleTable
```
## Tabla de plantillas de políticas
La siguiente es una tabla de las plantillas de políticas disponibles.
****
| Plantilla de política | Description (Descripción) |
| --- | --- |
| [AcmGetCertificatePolicy](serverless-policy-template-list.md#acm-get-certificate-policy) | Otorga permiso para leer un certificado desde AWS Certificate Manager. |
| [AMIDescribePolicy](serverless-policy-template-list.md#ami-describe-policy) | Da permiso para describir Amazon Machine Images (AMIs). |
| [AthenaQueryPolicy](serverless-policy-template-list.md#athena-query-policy) | Concede permisos para ejecutar consultas de Athena. |
| [AWSSecretsManagerGetSecretValuePolicy](serverless-policy-template-list.md#secrets-manager-get-secret-value-policy) | Concede permiso para obtener el valor secreto del secreto AWS Secrets Manager especificado. |
| [AWSSecretsManagerRotationPolicy](serverless-policy-template-list.md#secrets-manager-rotation-policy) | Concede permiso para transferir un secreto AWS Secrets Manager. |
| [CloudFormationDescribeStacksPolicy](serverless-policy-template-list.md#cloud-formation-describe-stacks-policy) | Da permiso para describir las CloudFormation pilas. |
| [CloudWatchDashboardPolicy](serverless-policy-template-list.md#cloudwatch-dashboard-policy) | Otorga permisos para poner las métricas en los CloudWatch paneles de control para que funcionen. |
| [CloudWatchDescribeAlarmHistoryPolicy](serverless-policy-template-list.md#cloudwatch-describe-alarm-history-policy) | Da permiso para describir el historial CloudWatch de alarmas. |
| [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy) | Da permiso para enviar métricas a CloudWatch. |
| [CodeCommitCrudPolicy](serverless-policy-template-list.md#codecommit-crud-policy) | Otorga permisos a create/read/update/delete los objetos de un CodeCommit repositorio específico. |
| [CodeCommitReadPolicy](serverless-policy-template-list.md#codecommit-read-policy) | Otorga permisos para leer los objetos de un CodeCommit repositorio específico. |
| [CodePipelineLambdaExecutionPolicy](serverless-policy-template-list.md#code-pipeline-lambda-execution-policy) | Da permiso para que una función Lambda invocada por CodePipeline informe del estado del trabajo. |
| [CodePipelineReadOnlyPolicy](serverless-policy-template-list.md#code-pipeline-readonly-policy) | Otorga permiso de lectura para obtener detalles sobre una CodePipeline canalización. |
| [ComprehendBasicAccessPolicy](serverless-policy-template-list.md#comprehend-basic-access-policy) | Concede permiso para detectar entidades, frases clave, idiomas y sentimientos. |
| [CostExplorerReadOnlyPolicy](serverless-policy-template-list.md#cost-explorer-readonly-policy) | Otorga permiso de solo lectura al Cost Explorer de solo lectura para el historial de facturación APIs . |
| [DynamoDBBackupFullAccessPolicy](serverless-policy-template-list.md#ddb-back-full-policy) | Concede permiso de lectura y escritura a las copias de seguridad bajo demanda de DynamoDB para una tabla. |
| [DynamoDBCrudPolicy](serverless-policy-template-list.md#dynamo-db-crud-policy) | Concede permisos de creación, lectura, actualización y eliminación a una tabla de Amazon DynamoDB. |
| [DynamoDBReadPolicy](serverless-policy-template-list.md#dynamo-db-read-policy) | Concede permiso de solo lectura a una tabla DynamoDB. |
| [DynamoDBReconfigurePolicy](serverless-policy-template-list.md#dynamo-db-reconfigure-policy) | Concede permiso para volver a configurar una tabla DynamoDB. |
| [DynamoDBRestoreFromBackupPolicy](serverless-policy-template-list.md#ddb-restore-from-backup-policy) | Concede permiso para restaurar una tabla de DynamoDB a partir de una copia de seguridad. |
| [DynamoDBStreamReadPolicy](serverless-policy-template-list.md#dynamo-db-stream-read-policy) | Concede permiso para describir y leer flujos y registros de DynamoDB. |
| [DynamoDBWritePolicy](serverless-policy-template-list.md#dynamo-db-write-policy) | Concede permiso de solo escritura a una tabla DynamoDB. |
| [EC2CopyImagePolicy](serverless-policy-template-list.md#ec2-copy-image-policy) | Concede permiso para copiar imágenes de Amazon EC2. |
| [EC2DescribePolicy](serverless-policy-template-list.md#ec2-describe-policy) | Concede permiso para describir instancias de Amazon Elastic Compute Cloud (Amazon EC2). |
| [EcsRunTaskPolicy](serverless-policy-template-list.md#ecs-run-task-policy) | Concede permiso para iniciar una nueva tarea para una definición de tarea. |
| [EFSWriteAccessPolicy](serverless-policy-template-list.md#efs-write-access-policy) | Concede permiso para montar un sistema de archivos de Amazon EFS con acceso de escritura. |
| [EKSDescribePolicy](serverless-policy-template-list.md#eks-describe-policy) | Concede permiso para describir o enumerar los clústeres de Amazon EKS. |
| [ElasticMapReduceAddJobFlowStepsPolicy](serverless-policy-template-list.md#elastic-map-reduce-add-job-flows-policy) | Concede permiso para añadir nuevos pasos a un clúster en ejecución. |
| [ElasticMapReduceCancelStepsPolicy](serverless-policy-template-list.md#elastic-map-reduce-cancel-steps-policy) | Concede permiso para cancelar un paso o pasos pendientes en un clúster en ejecución. |
| [ElasticMapReduceModifyInstanceFleetPolicy](serverless-policy-template-list.md#elastic-map-reduce-modify-instance-fleet-policy) | Concede permiso para enumerar detalles y modificar las capacidades para las flotas de instancia de un clúster. |
| [ElasticMapReduceModifyInstanceGroupsPolicy](serverless-policy-template-list.md#elastic-map-reduce-modify-instance-groups-policy) | Concede permiso para enumerar los detalles y modificar la configuración de los grupos de instancias de un clúster. |
| [ElasticMapReduceSetTerminationProtectionPolicy](serverless-policy-template-list.md#elastic-map-reduce-set-termination-protection-policy) | Concede permiso para establecer la protección de terminación para un clúster. |
| [ElasticMapReduceTerminateJobFlowsPolicy](serverless-policy-template-list.md#elastic-map-reduce-terminate-job-flows-policy) | Concede permiso para cerrar un clúster. |
| [ElasticsearchHttpPostPolicy](serverless-policy-template-list.md#elastic-search-http-post-policy) | Otorga permiso POST a Amazon OpenSearch Service. |
| [EventBridgePutEventsPolicy](serverless-policy-template-list.md#eventbridge-put-events-policy) | Otorga permisos para enviar eventos a EventBridge. |
| [FilterLogEventsPolicy](serverless-policy-template-list.md#filter-log-events-policy) | Otorga permiso para filtrar CloudWatch los eventos de registros de un grupo de registros especificado. |
| [FirehoseCrudPolicy](serverless-policy-template-list.md#firehose-crud-policy) | Concede permiso para crear, escribir, actualizar y eliminar una secuencia de entrega de Firehose. |
| [FirehoseWritePolicy](serverless-policy-template-list.md#firehose-write-policy) | Concede permiso para escribir en una secuencia de entrega de Firehose. |
| [KinesisCrudPolicy](serverless-policy-template-list.md#kinesis-crud-policy) | Concede permiso para crear, publicar y eliminar un flujo de Amazon Kinesis. |
| [KinesisStreamReadPolicy](serverless-policy-template-list.md#kinesis-stream-read-policy) | Concede permiso para listar y leer un flujo de Amazon Kinesis. |
| [KMSDecryptPolicy](serverless-policy-template-list.md#kms-decrypt-policy) | Da permiso para descifrar con una clave AWS Key Management Service (AWS KMS). |
| [KMSEncryptPolicy](serverless-policy-template-list.md#kms-encrypt-policy) | Da permiso para cifrar con una clave AWS Key Management Service (AWS KMS). |
| [LambdaInvokePolicy](serverless-policy-template-list.md#lambda-invoke-policy) | Da permiso para invocar una AWS Lambda función, un alias o una versión. |
| [MobileAnalyticsWriteOnlyAccessPolicy](serverless-policy-template-list.md#mobile-analytics-write-only-access-policy) | Concede permiso de solo escritura para poner datos de eventos para todos los recursos de la aplicación. |
| [OrganizationsListAccountsPolicy](serverless-policy-template-list.md#organizations-list-accounts-policy) | Otorga permiso de solo lectura para enumerar los nombres de las cuentas secundarias y. IDs |
| [PinpointEndpointAccessPolicy](serverless-policy-template-list.md#pinpoint-endpoint-access-policy) | Concede permiso para obtener y actualizar puntos de conexión para una aplicación de Amazon Pinpoint. |
| [PollyFullAccessPolicy](serverless-policy-template-list.md#polly-full-access-policy) | Concede permiso de acceso completo a los recursos del léxico de Amazon Polly. |
| [RekognitionDetectOnlyPolicy](serverless-policy-template-list.md#rekognition-detect-only-policy) | Concede permiso para detectar rostros, etiquetas y texto. |
| [RekognitionFacesManagementPolicy](serverless-policy-template-list.md#rekognition-face-management-policy) | Concede permiso para añadir, eliminar y buscar rostros en una colección de Amazon Rekognition. |
| [RekognitionFacesPolicy](serverless-policy-template-list.md#rekognition-faces-policy) | Concede permiso para comparar y detectar rostros y etiquetas. |
| [RekognitionLabelsPolicy](serverless-policy-template-list.md#rekognition-labels-policy) | Concede permiso para detectar etiquetas de objetos y de moderación. |
| [RekognitionNoDataAccessPolicy](serverless-policy-template-list.md#rekognition-no-data-access-policy) | Concede permiso para comparar y detectar rostros y etiquetas. |
| [RekognitionReadPolicy](serverless-policy-template-list.md#rekognition-read-policy) | Concede permiso para enumerar y buscar rostros. |
| [RekognitionWriteOnlyAccessPolicy](serverless-policy-template-list.md#rekognition-write-only-access-policy) | Concede permiso para crear colecciones e indexar rostros. |
| [Route53ChangeResourceRecordSetsPolicy](serverless-policy-template-list.md#route53-change-resource-record-sets-policy) | Concede permiso para cambiar los conjuntos de registros de recursos en Route 53. |
| [S3CrudPolicy](serverless-policy-template-list.md#s3-crud-policy) | Concede permisos de creación, lectura, actualización y eliminación para actuar en los objetos de un bucket de Amazon S3. |
| [S3FullAccessPolicy](serverless-policy-template-list.md#s3-full-access-policy) | Concede permiso de acceso completo para actuar sobre los objetos de un bucket de Amazon S3. |
| [S3ReadPolicy](serverless-policy-template-list.md#s3-read-policy) | Concede permiso de solo lectura para leer objetos en un bucket de Amazon Simple Storage Service (Amazon S3). |
| [S3WritePolicy](serverless-policy-template-list.md#s3-write-policy) | Concede permiso de escritura para escribir objetos en un bucket de Amazon S3. |
| [SageMakerCreateEndpointConfigPolicy](serverless-policy-template-list.md#sagemaker-create-endpoint-config-policy) | Otorga permiso para crear una configuración de punto final en SageMaker AI. |
| [SageMakerCreateEndpointPolicy](serverless-policy-template-list.md#sagemaker-create-endpoint-policy) | Da permiso para crear un punto final en la SageMaker IA. |
| [ServerlessRepoReadWriteAccessPolicy](serverless-policy-template-list.md#serverlessrepo-read-write-access-policy) | Otorga permiso para crear y enumerar aplicaciones en el AWS Serverless Application Repository servicio. |
| [SESBulkTemplatedCrudPolicy](serverless-policy-template-list.md#ses-bulk-templated-crud-policy) | Concede permiso para enviar correos electrónicos, correos electrónicos con plantillas, correos electrónicos masivos con plantillas y verificar la identidad. |
| [SESBulkTemplatedCrudPolicy\$1v2](serverless-policy-template-list.md#ses-bulk-templated-crud-policy-v2) | Concede permiso para enviar correos electrónicos, correos electrónicos con plantillas y correos electrónicos masivos con plantillas de Amazon SES y para verificar la identidad. |
| [SESCrudPolicy](serverless-policy-template-list.md#ses-crud-policy) | Concede permiso para enviar correo electrónico y verificar la identidad. |
| [SESEmailTemplateCrudPolicy](serverless-policy-template-list.md#ses-email-template-crud-policy) | Concede permiso para crear, obtener, enumerar, actualizar y eliminar plantillas de correo electrónico de Amazon SES. |
| [SESSendBouncePolicy](serverless-policy-template-list.md#ses-send-bounce-policy) | Concede SendBounce permiso a una identidad de Amazon Simple Email Service (Amazon SES). |
| [SNSCrudPolicy](serverless-policy-template-list.md#sns-crud-policy) | Concede permisos para crear, publicar y suscribirse a temas de Amazon SNS. |
| [SNSPublishMessagePolicy](serverless-policy-template-list.md#sqs-publish-message-policy) | Concede permiso para publicar un mensaje en un tema de Amazon Simple Notification Service (Amazon SNS). |
| [SQSPollerPolicy](serverless-policy-template-list.md#sqs-poller-policy) | Concede permiso para sondear una cola de Amazon Simple Queue Service (Amazon SQS). |
| [SQSSendMessagePolicy](serverless-policy-template-list.md#sqs-send-message-policy) | Concede permisos para enviar mensajes a una cola de Amazon SQS. |
| [SSMParameterReadPolicy](serverless-policy-template-list.md#ssm-parameter-read-policy) | Concede permiso para acceder a un parámetro de un almacén de parámetros de Amazon EC2 Systems Manager (SSM) para cargar secretos en esta cuenta. Se utiliza cuando el nombre del parámetro no tiene un prefijo de barra inclinada. |
| [SSMParameterWithSlashPrefixReadPolicy](serverless-policy-template-list.md#ssm-parameter-slash-read-policy) | Concede permiso para acceder a un parámetro de un almacén de parámetros de Amazon EC2 Systems Manager (SSM) para cargar secretos en esta cuenta. Se utiliza cuando el nombre del parámetro tiene un prefijo de barra diagonal. |
| [StepFunctionsExecutionPolicy](serverless-policy-template-list.md#stepfunctions-execution-policy) | Concede permiso para iniciar la ejecución de una máquina de estado de Step Functions. |
| [TextractDetectAnalyzePolicy](serverless-policy-template-list.md#textract-detect-analyze-policy) | Concede acceso para detectar y analizar documentos con Amazon Textract. |
| [TextractGetResultPolicy](serverless-policy-template-list.md#textract-get-result-policy) | Concede acceso a documentos detectados y analizados desde Amazon Textract. |
| [TextractPolicy](serverless-policy-template-list.md#textract-policy) | Proporciona acceso completo a Amazon Textract. |
| [VPCAccessPolicy](serverless-policy-template-list.md#vpc-access-policy) | Permite crear, eliminar, describir y eliminar interfaces de red elásticas. |
## Resolución de problemas
### Error de la CLI de SAM: «Debe especificar valores de parámetros válidos para la plantilla de política '< policy-template-name >'»
Al ejecutar `sam build`, verá el siguiente error:
```
"Must specify valid parameter values for policy template ''"
```
Esto significa que no pasó un objeto vacío al declarar una plantilla de política que no tiene ningún valor de marcador de posición.
Para solucionar este problema, declare la política como se muestra en el siguiente ejemplo para[CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy).
```
1. MyFunction:
2. Policies:
3. - CloudWatchPutMetricPolicy: {}
```
# AWS SAM lista de plantillas de políticas
A continuación se muestran las plantillas de políticas disponibles, junto con los permisos que se aplican a cada una de ellas. AWS Serverless Application Model (AWS SAM) rellena automáticamente los elementos marcadores de posición (como la AWS región y el identificador de cuenta) con la información adecuada.
**Topics**
+ [AcmGetCertificatePolicy](#acm-get-certificate-policy)
+ [AMIDescribePolicy](#ami-describe-policy)
+ [AthenaQueryPolicy](#athena-query-policy)
+ [AWSSecretsManagerGetSecretValuePolicy](#secrets-manager-get-secret-value-policy)
+ [AWSSecretsManagerRotationPolicy](#secrets-manager-rotation-policy)
+ [CloudFormationDescribeStacksPolicy](#cloud-formation-describe-stacks-policy)
+ [CloudWatchDashboardPolicy](#cloudwatch-dashboard-policy)
+ [CloudWatchDescribeAlarmHistoryPolicy](#cloudwatch-describe-alarm-history-policy)
+ [CloudWatchPutMetricPolicy](#cloudwatch-put-metric-policy)
+ [CodePipelineLambdaExecutionPolicy](#code-pipeline-lambda-execution-policy)
+ [CodePipelineReadOnlyPolicy](#code-pipeline-readonly-policy)
+ [CodeCommitCrudPolicy](#codecommit-crud-policy)
+ [CodeCommitReadPolicy](#codecommit-read-policy)
+ [ComprehendBasicAccessPolicy](#comprehend-basic-access-policy)
+ [CostExplorerReadOnlyPolicy](#cost-explorer-readonly-policy)
+ [DynamoDBBackupFullAccessPolicy](#ddb-back-full-policy)
+ [DynamoDBCrudPolicy](#dynamo-db-crud-policy)
+ [DynamoDBReadPolicy](#dynamo-db-read-policy)
+ [DynamoDBReconfigurePolicy](#dynamo-db-reconfigure-policy)
+ [DynamoDBRestoreFromBackupPolicy](#ddb-restore-from-backup-policy)
+ [DynamoDBStreamReadPolicy](#dynamo-db-stream-read-policy)
+ [DynamoDBWritePolicy](#dynamo-db-write-policy)
+ [EC2CopyImagePolicy](#ec2-copy-image-policy)
+ [EC2DescribePolicy](#ec2-describe-policy)
+ [EcsRunTaskPolicy](#ecs-run-task-policy)
+ [EFSWriteAccessPolicy](#efs-write-access-policy)
+ [EKSDescribePolicy](#eks-describe-policy)
+ [ElasticMapReduceAddJobFlowStepsPolicy](#elastic-map-reduce-add-job-flows-policy)
+ [ElasticMapReduceCancelStepsPolicy](#elastic-map-reduce-cancel-steps-policy)
+ [ElasticMapReduceModifyInstanceFleetPolicy](#elastic-map-reduce-modify-instance-fleet-policy)
+ [ElasticMapReduceModifyInstanceGroupsPolicy](#elastic-map-reduce-modify-instance-groups-policy)
+ [ElasticMapReduceSetTerminationProtectionPolicy](#elastic-map-reduce-set-termination-protection-policy)
+ [ElasticMapReduceTerminateJobFlowsPolicy](#elastic-map-reduce-terminate-job-flows-policy)
+ [ElasticsearchHttpPostPolicy](#elastic-search-http-post-policy)
+ [EventBridgePutEventsPolicy](#eventbridge-put-events-policy)
+ [FilterLogEventsPolicy](#filter-log-events-policy)
+ [FirehoseCrudPolicy](#firehose-crud-policy)
+ [FirehoseWritePolicy](#firehose-write-policy)
+ [KinesisCrudPolicy](#kinesis-crud-policy)
+ [KinesisStreamReadPolicy](#kinesis-stream-read-policy)
+ [KMSDecryptPolicy](#kms-decrypt-policy)
+ [KMSEncryptPolicy](#kms-encrypt-policy)
+ [LambdaInvokePolicy](#lambda-invoke-policy)
+ [MobileAnalyticsWriteOnlyAccessPolicy](#mobile-analytics-write-only-access-policy)
+ [OrganizationsListAccountsPolicy](#organizations-list-accounts-policy)
+ [PinpointEndpointAccessPolicy](#pinpoint-endpoint-access-policy)
+ [PollyFullAccessPolicy](#polly-full-access-policy)
+ [RekognitionDetectOnlyPolicy](#rekognition-detect-only-policy)
+ [RekognitionFacesManagementPolicy](#rekognition-face-management-policy)
+ [RekognitionFacesPolicy](#rekognition-faces-policy)
+ [RekognitionLabelsPolicy](#rekognition-labels-policy)
+ [RekognitionNoDataAccessPolicy](#rekognition-no-data-access-policy)
+ [RekognitionReadPolicy](#rekognition-read-policy)
+ [RekognitionWriteOnlyAccessPolicy](#rekognition-write-only-access-policy)
+ [Route53ChangeResourceRecordSetsPolicy](#route53-change-resource-record-sets-policy)
+ [S3CrudPolicy](#s3-crud-policy)
+ [S3FullAccessPolicy](#s3-full-access-policy)
+ [S3ReadPolicy](#s3-read-policy)
+ [S3WritePolicy](#s3-write-policy)
+ [SageMakerCreateEndpointConfigPolicy](#sagemaker-create-endpoint-config-policy)
+ [SageMakerCreateEndpointPolicy](#sagemaker-create-endpoint-policy)
+ [ServerlessRepoReadWriteAccessPolicy](#serverlessrepo-read-write-access-policy)
+ [SESBulkTemplatedCrudPolicy](#ses-bulk-templated-crud-policy)
+ [SESBulkTemplatedCrudPolicy\$1v2](#ses-bulk-templated-crud-policy-v2)
+ [SESCrudPolicy](#ses-crud-policy)
+ [SESEmailTemplateCrudPolicy](#ses-email-template-crud-policy)
+ [SESSendBouncePolicy](#ses-send-bounce-policy)
+ [SNSCrudPolicy](#sns-crud-policy)
+ [SNSPublishMessagePolicy](#sqs-publish-message-policy)
+ [SQSPollerPolicy](#sqs-poller-policy)
+ [SQSSendMessagePolicy](#sqs-send-message-policy)
+ [SSMParameterReadPolicy](#ssm-parameter-read-policy)
+ [SSMParameterWithSlashPrefixReadPolicy](#ssm-parameter-slash-read-policy)
+ [StepFunctionsExecutionPolicy](#stepfunctions-execution-policy)
+ [TextractDetectAnalyzePolicy](#textract-detect-analyze-policy)
+ [TextractGetResultPolicy](#textract-get-result-policy)
+ [TextractPolicy](#textract-policy)
+ [VPCAccessPolicy](#vpc-access-policy)
## AcmGetCertificatePolicy
Otorga permiso para leer un certificado desde. AWS Certificate Manager
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"acm:GetCertificate"
],
"Resource": {
"Fn::Sub": [
"${certificateArn}",
{
"certificateArn": {
"Ref": "CertificateArn"
}
}
]
}
}
]
```
## AMIDescribePolicy
Da permiso para describir Amazon Machine Images (AMIs).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeImages"
],
"Resource": "*"
}
]
```
## AthenaQueryPolicy
Concede permisos para ejecutar consultas de Athena.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"athena:ListWorkGroups",
"athena:GetExecutionEngine",
"athena:GetExecutionEngines",
"athena:GetNamespace",
"athena:GetCatalogs",
"athena:GetNamespaces",
"athena:GetTables",
"athena:GetTable"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"athena:StartQueryExecution",
"athena:GetQueryResults",
"athena:DeleteNamedQuery",
"athena:GetNamedQuery",
"athena:ListQueryExecutions",
"athena:StopQueryExecution",
"athena:GetQueryResultsStream",
"athena:ListNamedQueries",
"athena:CreateNamedQuery",
"athena:GetQueryExecution",
"athena:BatchGetNamedQuery",
"athena:BatchGetQueryExecution",
"athena:GetWorkGroup"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:athena:${AWS::Region}:${AWS::AccountId}:workgroup/${workgroupName}",
{
"workgroupName": {
"Ref": "WorkGroupName"
}
}
]
}
}
]
```
## AWSSecretsManagerGetSecretValuePolicy
Da permiso para obtener el valor secreto del AWS Secrets Manager secreto especificado.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": {
"Fn::Sub": [
"${secretArn}",
{
"secretArn": {
"Ref": "SecretArn"
}
}
]
}
}
]
```
## AWSSecretsManagerRotationPolicy
Concede permiso para transferir un secreto AWS Secrets Manager.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:DescribeSecret",
"secretsmanager:GetSecretValue",
"secretsmanager:PutSecretValue",
"secretsmanager:UpdateSecretVersionStage"
],
"Resource": {
"Fn::Sub": "arn:${AWS::Partition}:secretsmanager:${AWS::Region}:${AWS::AccountId}:secret:*"
},
"Condition": {
"StringEquals": {
"secretsmanager:resource/AllowRotationLambdaArn": {
"Fn::Sub": [
"arn:${AWS::Partition}:lambda:${AWS::Region}:${AWS::AccountId}:function:${functionName}",
{
"functionName": {
"Ref": "FunctionName"
}
}
]
}
}
}
},
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetRandomPassword"
],
"Resource": "*"
}
]
```
## CloudFormationDescribeStacksPolicy
Da permiso para describir las CloudFormation pilas.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudformation:DescribeStacks"
],
"Resource": {
"Fn::Sub": "arn:${AWS::Partition}:cloudformation:${AWS::Region}:${AWS::AccountId}:stack/*"
}
}
]
```
## CloudWatchDashboardPolicy
Otorga permisos para poner las métricas en los CloudWatch paneles de control para que funcionen.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:GetDashboard",
"cloudwatch:ListDashboards",
"cloudwatch:PutDashboard",
"cloudwatch:ListMetrics"
],
"Resource": "*"
}
]
```
## CloudWatchDescribeAlarmHistoryPolicy
Da permiso para describir el historial de CloudWatch alarmas de Amazon.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:DescribeAlarmHistory"
],
"Resource": "*"
}
]
```
## CloudWatchPutMetricPolicy
Da permiso para enviar métricas a CloudWatch.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricData"
],
"Resource": "*"
}
]
```
## CodePipelineLambdaExecutionPolicy
Da permiso para que una función Lambda invocada por AWS CodePipeline informe del estado del trabajo.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:PutJobSuccessResult",
"codepipeline:PutJobFailureResult"
],
"Resource": "*"
}
]
```
## CodePipelineReadOnlyPolicy
Otorga permiso de lectura para obtener detalles sobre una CodePipeline canalización.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:ListPipelineExecutions"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:codepipeline:${AWS::Region}:${AWS::AccountId}:${pipelinename}",
{
"pipelinename": {
"Ref": "PipelineName"
}
}
]
}
}
]
```
## CodeCommitCrudPolicy
Otorga permisos para crear, leer, actualizar y eliminar objetos dentro de un CodeCommit repositorio específico.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:GitPull",
"codecommit:GitPush",
"codecommit:CreateBranch",
"codecommit:DeleteBranch",
"codecommit:GetBranch",
"codecommit:ListBranches",
"codecommit:MergeBranchesByFastForward",
"codecommit:MergeBranchesBySquash",
"codecommit:MergeBranchesByThreeWay",
"codecommit:UpdateDefaultBranch",
"codecommit:BatchDescribeMergeConflicts",
"codecommit:CreateUnreferencedMergeCommit",
"codecommit:DescribeMergeConflicts",
"codecommit:GetMergeCommit",
"codecommit:GetMergeOptions",
"codecommit:BatchGetPullRequests",
"codecommit:CreatePullRequest",
"codecommit:DescribePullRequestEvents",
"codecommit:GetCommentsForPullRequest",
"codecommit:GetCommitsFromMergeBase",
"codecommit:GetMergeConflicts",
"codecommit:GetPullRequest",
"codecommit:ListPullRequests",
"codecommit:MergePullRequestByFastForward",
"codecommit:MergePullRequestBySquash",
"codecommit:MergePullRequestByThreeWay",
"codecommit:PostCommentForPullRequest",
"codecommit:UpdatePullRequestDescription",
"codecommit:UpdatePullRequestStatus",
"codecommit:UpdatePullRequestTitle",
"codecommit:DeleteFile",
"codecommit:GetBlob",
"codecommit:GetFile",
"codecommit:GetFolder",
"codecommit:PutFile",
"codecommit:DeleteCommentContent",
"codecommit:GetComment",
"codecommit:GetCommentsForComparedCommit",
"codecommit:PostCommentForComparedCommit",
"codecommit:PostCommentReply",
"codecommit:UpdateComment",
"codecommit:BatchGetCommits",
"codecommit:CreateCommit",
"codecommit:GetCommit",
"codecommit:GetCommitHistory",
"codecommit:GetDifferences",
"codecommit:GetObjectIdentifier",
"codecommit:GetReferences",
"codecommit:GetTree",
"codecommit:GetRepository",
"codecommit:UpdateRepositoryDescription",
"codecommit:ListTagsForResource",
"codecommit:TagResource",
"codecommit:UntagResource",
"codecommit:GetRepositoryTriggers",
"codecommit:PutRepositoryTriggers",
"codecommit:TestRepositoryTriggers",
"codecommit:GetBranch",
"codecommit:GetCommit",
"codecommit:UploadArchive",
"codecommit:GetUploadArchiveStatus",
"codecommit:CancelUploadArchive"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:codecommit:${AWS::Region}:${AWS::AccountId}:${repositoryName}",
{
"repositoryName": {
"Ref": "RepositoryName"
}
}
]
}
}
]
```
## CodeCommitReadPolicy
Otorga permisos para leer los objetos de un CodeCommit repositorio específico.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:GitPull",
"codecommit:GetBranch",
"codecommit:ListBranches",
"codecommit:BatchDescribeMergeConflicts",
"codecommit:DescribeMergeConflicts",
"codecommit:GetMergeCommit",
"codecommit:GetMergeOptions",
"codecommit:BatchGetPullRequests",
"codecommit:DescribePullRequestEvents",
"codecommit:GetCommentsForPullRequest",
"codecommit:GetCommitsFromMergeBase",
"codecommit:GetMergeConflicts",
"codecommit:GetPullRequest",
"codecommit:ListPullRequests",
"codecommit:GetBlob",
"codecommit:GetFile",
"codecommit:GetFolder",
"codecommit:GetComment",
"codecommit:GetCommentsForComparedCommit",
"codecommit:BatchGetCommits",
"codecommit:GetCommit",
"codecommit:GetCommitHistory",
"codecommit:GetDifferences",
"codecommit:GetObjectIdentifier",
"codecommit:GetReferences",
"codecommit:GetTree",
"codecommit:GetRepository",
"codecommit:ListTagsForResource",
"codecommit:GetRepositoryTriggers",
"codecommit:TestRepositoryTriggers",
"codecommit:GetBranch",
"codecommit:GetCommit",
"codecommit:GetUploadArchiveStatus"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:codecommit:${AWS::Region}:${AWS::AccountId}:${repositoryName}",
{
"repositoryName": {
"Ref": "RepositoryName"
}
}
]
}
}
]
```
## ComprehendBasicAccessPolicy
Concede permiso para detectar entidades, frases clave, idiomas y sentimientos.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"comprehend:BatchDetectKeyPhrases",
"comprehend:DetectDominantLanguage",
"comprehend:DetectEntities",
"comprehend:BatchDetectEntities",
"comprehend:DetectKeyPhrases",
"comprehend:DetectSentiment",
"comprehend:BatchDetectDominantLanguage",
"comprehend:BatchDetectSentiment"
],
"Resource": "*"
}
]
```
## CostExplorerReadOnlyPolicy
Otorga permiso de solo lectura al historial de facturación de solo lectura (Cost AWS Cost Explorer Explorer). APIs
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ce:GetCostAndUsage",
"ce:GetDimensionValues",
"ce:GetReservationCoverage",
"ce:GetReservationPurchaseRecommendation",
"ce:GetReservationUtilization",
"ce:GetTags"
],
"Resource": "*"
}
]
```
## DynamoDBBackupFullAccessPolicy
Concede permiso de lectura y escritura a las copias de seguridad bajo demanda de DynamoDB para una tabla.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:CreateBackup",
"dynamodb:DescribeContinuousBackups"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:DeleteBackup",
"dynamodb:DescribeBackup",
"dynamodb:ListBackups"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/backup/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBCrudPolicy
Concede permisos de creación, lectura, actualización y eliminación a una tabla de Amazon DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:DeleteItem",
"dynamodb:PutItem",
"dynamodb:Scan",
"dynamodb:Query",
"dynamodb:UpdateItem",
"dynamodb:BatchWriteItem",
"dynamodb:BatchGetItem",
"dynamodb:DescribeTable",
"dynamodb:ConditionCheckItem"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
]
}
]
```
## DynamoDBReadPolicy
Concede permiso de solo lectura a una tabla DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:GetItem",
"dynamodb:Scan",
"dynamodb:Query",
"dynamodb:BatchGetItem",
"dynamodb:DescribeTable"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
]
}
]
```
## DynamoDBReconfigurePolicy
Concede permiso para volver a configurar una tabla DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:UpdateTable"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBRestoreFromBackupPolicy
Concede permiso para restaurar una tabla de DynamoDB a partir de una copia de seguridad.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:RestoreTableFromBackup"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/backup/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:BatchWriteItem"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBStreamReadPolicy
Concede permiso para describir y leer flujos y registros de DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:DescribeStream",
"dynamodb:GetRecords",
"dynamodb:GetShardIterator"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/stream/${streamName}",
{
"tableName": {
"Ref": "TableName"
},
"streamName": {
"Ref": "StreamName"
}
}
]
}
},
{
"Effect": "Allow",
"Action": [
"dynamodb:ListStreams"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/stream/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
}
]
```
## DynamoDBWritePolicy
Concede permiso de solo escritura a una tabla DynamoDB.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"dynamodb:PutItem",
"dynamodb:UpdateItem",
"dynamodb:BatchWriteItem"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}",
{
"tableName": {
"Ref": "TableName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:dynamodb:${AWS::Region}:${AWS::AccountId}:table/${tableName}/index/*",
{
"tableName": {
"Ref": "TableName"
}
}
]
}
]
}
]
```
## EC2CopyImagePolicy
Da permiso para copiar EC2 imágenes de Amazon.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CopyImage"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ec2:${AWS::Region}:${AWS::AccountId}:image/${imageId}",
{
"imageId": {
"Ref": "ImageId"
}
}
]
}
}
]
```
## EC2DescribePolicy
Otorga permiso para describir las instancias de Amazon Elastic Compute Cloud (Amazon EC2).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeRegions",
"ec2:DescribeInstances"
],
"Resource": "*"
}
]
```
## EcsRunTaskPolicy
Concede permiso para iniciar una nueva tarea para una definición de tarea.
```
"Statement": [
{
"Action": [
"ecs:RunTask"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ecs:${AWS::Region}:${AWS::AccountId}:task-definition/${taskDefinition}",
{
"taskDefinition": {
"Ref": "TaskDefinition"
}
}
]
},
"Effect": "Allow"
}
]
```
## EFSWriteAccessPolicy
Concede permiso para montar un sistema de archivos de Amazon EFS con acceso de escritura.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticfilesystem:ClientMount",
"elasticfilesystem:ClientWrite"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticfilesystem:${AWS::Region}:${AWS::AccountId}:file-system/${FileSystem}",
{
"FileSystem": {
"Ref": "FileSystem"
}
}
]
},
"Condition": {
"StringEquals": {
"elasticfilesystem:AccessPointArn": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticfilesystem:${AWS::Region}:${AWS::AccountId}:access-point/${AccessPoint}",
{
"AccessPoint": {
"Ref": "AccessPoint"
}
}
]
}
}
}
}
]
```
## EKSDescribePolicy
Concede permiso para describir o enumerar clústeres de Amazon Elastic Kubernetes Service (Amazon EKS).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"eks:DescribeCluster",
"eks:ListClusters"
],
"Resource": "*"
}
]
```
## ElasticMapReduceAddJobFlowStepsPolicy
Concede permiso para añadir nuevos pasos a un clúster en ejecución.
```
"Statement": [
{
"Action": "elasticmapreduce:AddJobFlowSteps",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceCancelStepsPolicy
Concede permiso para cancelar un paso o pasos pendientes en un clúster en ejecución.
```
"Statement": [
{
"Action": "elasticmapreduce:CancelSteps",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceModifyInstanceFleetPolicy
Concede permiso para enumerar detalles y modificar las capacidades para las flotas de instancia de un clúster.
```
"Statement": [
{
"Action": [
"elasticmapreduce:ModifyInstanceFleet",
"elasticmapreduce:ListInstanceFleets"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceModifyInstanceGroupsPolicy
Concede permiso para enumerar los detalles y modificar la configuración de los grupos de instancias de un clúster.
```
"Statement": [
{
"Action": [
"elasticmapreduce:ModifyInstanceGroups",
"elasticmapreduce:ListInstanceGroups"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceSetTerminationProtectionPolicy
Concede permiso para establecer la protección de terminación para un clúster.
```
"Statement": [
{
"Action": "elasticmapreduce:SetTerminationProtection",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceTerminateJobFlowsPolicy
Concede permiso para cerrar un clúster.
```
"Statement": [
{
"Action": "elasticmapreduce:TerminateJobFlows",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticsearchHttpPostPolicy
Otorga permisos POST y PUT a Amazon OpenSearch Service.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"es:ESHttpPost",
"es:ESHttpPut"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:es:${AWS::Region}:${AWS::AccountId}:domain/${domainName}/*",
{
"domainName": {
"Ref": "DomainName"
}
}
]
}
}
]
```
## EventBridgePutEventsPolicy
Otorga permisos para enviar eventos a Amazon EventBridge.
```
"Statement": [
{
"Effect": "Allow",
"Action": "events:PutEvents",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:events:${AWS::Region}:${AWS::AccountId}:event-bus/${eventBusName}",
{
"eventBusName": {
"Ref": "EventBusName"
}
}
]
}
}
]
```
## FilterLogEventsPolicy
Otorga permiso para filtrar CloudWatch los eventos de los registros de un grupo de registros específico.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:FilterLogEvents"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:logs:${AWS::Region}:${AWS::AccountId}:log-group:${logGroupName}:log-stream:*",
{
"logGroupName": {
"Ref": "LogGroupName"
}
}
]
}
}
]
```
## FirehoseCrudPolicy
Concede permiso para crear, escribir, actualizar y eliminar una secuencia de entrega de Firehose.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"firehose:CreateDeliveryStream",
"firehose:DeleteDeliveryStream",
"firehose:DescribeDeliveryStream",
"firehose:PutRecord",
"firehose:PutRecordBatch",
"firehose:UpdateDestination"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:firehose:${AWS::Region}:${AWS::AccountId}:deliverystream/${deliveryStreamName}",
{
"deliveryStreamName": {
"Ref": "DeliveryStreamName"
}
}
]
}
}
]
```
## FirehoseWritePolicy
Concede permiso para escribir en una secuencia de entrega de Firehose.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"firehose:PutRecord",
"firehose:PutRecordBatch"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:firehose:${AWS::Region}:${AWS::AccountId}:deliverystream/${deliveryStreamName}",
{
"deliveryStreamName": {
"Ref": "DeliveryStreamName"
}
}
]
}
}
]
```
## KinesisCrudPolicy
Concede permiso para crear, publicar y eliminar un flujo de Amazon Kinesis.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:AddTagsToStream",
"kinesis:CreateStream",
"kinesis:DecreaseStreamRetentionPeriod",
"kinesis:DeleteStream",
"kinesis:DescribeStream",
"kinesis:DescribeStreamSummary",
"kinesis:GetShardIterator",
"kinesis:IncreaseStreamRetentionPeriod",
"kinesis:ListTagsForStream",
"kinesis:MergeShards",
"kinesis:PutRecord",
"kinesis:PutRecords",
"kinesis:SplitShard",
"kinesis:RemoveTagsFromStream"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/${streamName}",
{
"streamName": {
"Ref": "StreamName"
}
}
]
}
}
]
```
## KinesisStreamReadPolicy
Concede permiso para listar y leer un flujo de Amazon Kinesis.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:ListStreams",
"kinesis:DescribeLimits"
],
"Resource": {
"Fn::Sub": "arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/*"
}
},
{
"Effect": "Allow",
"Action": [
"kinesis:DescribeStream",
"kinesis:DescribeStreamSummary",
"kinesis:GetRecords",
"kinesis:GetShardIterator"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kinesis:${AWS::Region}:${AWS::AccountId}:stream/${streamName}",
{
"streamName": {
"Ref": "StreamName"
}
}
]
}
}
]
```
## KMSDecryptPolicy
Da permiso para descifrar con una clave AWS Key Management Service (AWS KMS). Tenga en cuenta que `keyId` debe ser un identificador de AWS KMS clave y no un alias de clave.
```
"Statement": [
{
"Action": "kms:Decrypt",
"Effect": "Allow",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kms:${AWS::Region}:${AWS::AccountId}:key/${keyId}",
{
"keyId": {
"Ref": "KeyId"
}
}
]
}
}
]
```
## KMSEncryptPolicy
Da permiso para cifrar con una AWS KMS clave. Tenga en cuenta que KeyID debe ser un identificador de AWS KMS clave y no un alias de clave.
```
"Statement": [
{
"Action": "kms:Encrypt",
"Effect": "Allow",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kms:${AWS::Region}:${AWS::AccountId}:key/${keyId}",
{
"keyId": {
"Ref": "KeyId"
}
}
]
}
}
]
```
## LambdaInvokePolicy
Da permiso para invocar una AWS Lambda función, un alias o una versión.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:lambda:${AWS::Region}:${AWS::AccountId}:function:${functionName}*",
{
"functionName": {
"Ref": "FunctionName"
}
}
]
}
}
]
```
## MobileAnalyticsWriteOnlyAccessPolicy
Concede permiso de solo escritura para poner datos de eventos para todos los recursos de la aplicación.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"mobileanalytics:PutEvents"
],
"Resource": "*"
}
]
```
## OrganizationsListAccountsPolicy
Otorga permiso de solo lectura para enumerar los nombres de las cuentas secundarias y. IDs
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"organizations:ListAccounts"
],
"Resource": "*"
}
]
```
## PinpointEndpointAccessPolicy
Concede permiso para obtener y actualizar puntos de conexión para una aplicación de Amazon Pinpoint.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"mobiletargeting:GetEndpoint",
"mobiletargeting:UpdateEndpoint",
"mobiletargeting:UpdateEndpointsBatch"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:mobiletargeting:${AWS::Region}:${AWS::AccountId}:apps/${pinpointApplicationId}/endpoints/*",
{
"pinpointApplicationId": {
"Ref": "PinpointApplicationId"
}
}
]
}
}
]
```
## PollyFullAccessPolicy
Concede permiso de acceso completo a los recursos del léxico de Amazon Polly.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"polly:GetLexicon",
"polly:DeleteLexicon"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:polly:${AWS::Region}:${AWS::AccountId}:lexicon/${lexiconName}",
{
"lexiconName": {
"Ref": "LexiconName"
}
}
]
}
]
},
{
"Effect": "Allow",
"Action": [
"polly:DescribeVoices",
"polly:ListLexicons",
"polly:PutLexicon",
"polly:SynthesizeSpeech"
],
"Resource": [
{
"Fn::Sub": "arn:${AWS::Partition}:polly:${AWS::Region}:${AWS::AccountId}:lexicon/*"
}
]
}
]
```
## RekognitionDetectOnlyPolicy
Concede permiso para detectar rostros, etiquetas y texto.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:DetectFaces",
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels",
"rekognition:DetectText"
],
"Resource": "*"
}
]
```
## RekognitionFacesManagementPolicy
Concede permiso para añadir, eliminar y buscar rostros en una colección de Amazon Rekognition.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:IndexFaces",
"rekognition:DeleteFaces",
"rekognition:SearchFaces",
"rekognition:SearchFacesByImage",
"rekognition:ListFaces"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## RekognitionFacesPolicy
Concede permiso para comparar y detectar rostros y etiquetas.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:CompareFaces",
"rekognition:DetectFaces"
],
"Resource": "*"
}
]
```
## RekognitionLabelsPolicy
Concede permiso para detectar etiquetas de objetos y de moderación.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels"
],
"Resource": "*"
}
]
```
## RekognitionNoDataAccessPolicy
Concede permiso para comparar y detectar rostros y etiquetas.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:CompareFaces",
"rekognition:DetectFaces",
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## RekognitionReadPolicy
Concede permiso para enumerar y buscar rostros.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:ListCollections",
"rekognition:ListFaces",
"rekognition:SearchFaces",
"rekognition:SearchFacesByImage"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## RekognitionWriteOnlyAccessPolicy
Concede permiso para crear colecciones e indexar rostros.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:CreateCollection",
"rekognition:IndexFaces"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:rekognition:${AWS::Region}:${AWS::AccountId}:collection/${collectionId}",
{
"collectionId": {
"Ref": "CollectionId"
}
}
]
}
}
]
```
## Route53ChangeResourceRecordSetsPolicy
Concede permiso para cambiar los conjuntos de registros de recursos en Route 53.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"route53:ChangeResourceRecordSets"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:route53:::hostedzone/${HostedZoneId}",
{
"HostedZoneId": {
"Ref": "HostedZoneId"
}
}
]
}
}
]
```
## S3CrudPolicy
Concede permisos de creación, lectura, actualización y eliminación para actuar en los objetos de un bucket de Amazon S3.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:GetBucketLocation",
"s3:GetObjectVersion",
"s3:PutObject",
"s3:PutObjectAcl",
"s3:GetLifecycleConfiguration",
"s3:PutLifecycleConfiguration",
"s3:DeleteObject"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## S3FullAccessPolicy
Concede permiso de acceso completo para actuar sobre los objetos de un bucket de Amazon S3.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectAcl",
"s3:GetObjectVersion",
"s3:PutObject",
"s3:PutObjectAcl",
"s3:DeleteObject",
"s3:DeleteObjectTagging",
"s3:DeleteObjectVersionTagging",
"s3:GetObjectTagging",
"s3:GetObjectVersionTagging",
"s3:PutObjectTagging",
"s3:PutObjectVersionTagging"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketLocation",
"s3:GetLifecycleConfiguration",
"s3:PutLifecycleConfiguration"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## S3ReadPolicy
Concede permiso de solo lectura para leer objetos en un bucket de Amazon Simple Storage Service (Amazon S3).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:GetBucketLocation",
"s3:GetObjectVersion",
"s3:GetLifecycleConfiguration"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## S3WritePolicy
Concede permiso de escritura para escribir objetos en un bucket de Amazon S3.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:PutObjectAcl",
"s3:PutLifecycleConfiguration"
],
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:s3:::${bucketName}/*",
{
"bucketName": {
"Ref": "BucketName"
}
}
]
}
]
}
]
```
## SageMakerCreateEndpointConfigPolicy
Otorga permiso para crear una configuración de punto final en SageMaker AI.
```
"Statement": [
{
"Action": [
"sagemaker:CreateEndpointConfig"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sagemaker:${AWS::Region}:${AWS::AccountId}:endpoint-config/${endpointConfigName}",
{
"endpointConfigName": {
"Ref": "EndpointConfigName"
}
}
]
},
"Effect": "Allow"
}
]
```
## SageMakerCreateEndpointPolicy
Da permiso para crear un punto final en la SageMaker IA.
```
"Statement": [
{
"Action": [
"sagemaker:CreateEndpoint"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sagemaker:${AWS::Region}:${AWS::AccountId}:endpoint/${endpointName}",
{
"endpointName": {
"Ref": "EndpointName"
}
}
]
},
"Effect": "Allow"
}
]
```
## ServerlessRepoReadWriteAccessPolicy
Otorga permiso para crear y enumerar aplicaciones en el servicio AWS Serverless Application Repository (AWS SAM).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"serverlessrepo:CreateApplication",
"serverlessrepo:CreateApplicationVersion",
"serverlessrepo:GetApplication",
"serverlessrepo:ListApplications",
"serverlessrepo:ListApplicationVersions"
],
"Resource": [
{
"Fn::Sub": "arn:${AWS::Partition}:serverlessrepo:${AWS::Region}:${AWS::AccountId}:applications/*"
}
]
}
]
```
## SESBulkTemplatedCrudPolicy
Concede permiso para enviar correos electrónicos, correos electrónicos con plantillas y correos electrónicos masivos con plantillas de Amazon SES y para verificar la identidad.
**nota**
La acción `ses:SendTemplatedEmail` requiere un ARN de plantilla. En su lugar, usa `SESBulkTemplatedCrudPolicy_v2`.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:GetIdentityVerificationAttributes",
"ses:SendEmail",
"ses:SendRawEmail",
"ses:SendTemplatedEmail",
"ses:SendBulkTemplatedEmail",
"ses:VerifyEmailIdentity"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
}
}
]
```
## SESBulkTemplatedCrudPolicy\$1v2
Concede permiso para enviar correos electrónicos, correos electrónicos con plantillas y correos electrónicos masivos con plantillas de Amazon SES y para verificar la identidad.
```
"Statement": [
{
"Action": [
"ses:SendEmail",
"ses:SendRawEmail",
"ses:SendTemplatedEmail",
"ses:SendBulkTemplatedEmail"
],
"Effect": "Allow",
"Resource": [
{
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
},
{
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:template/${templateName}",
{
"templateName": {
"Ref": "TemplateName"
}
}
]
}
]
},
{
"Action": [
"ses:GetIdentityVerificationAttributes",
"ses:VerifyEmailIdentity"
],
"Effect": "Allow",
"Resource": "*"
}
]
```
## SESCrudPolicy
Concede permiso para enviar correo electrónico y verificar la identidad.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:GetIdentityVerificationAttributes",
"ses:SendEmail",
"ses:SendRawEmail",
"ses:VerifyEmailIdentity"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
}
}
]
```
## SESEmailTemplateCrudPolicy
Concede permiso para crear, obtener, enumerar, actualizar y eliminar plantillas de correo electrónico de Amazon SES.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:CreateTemplate",
"ses:GetTemplate",
"ses:ListTemplates",
"ses:UpdateTemplate",
"ses:DeleteTemplate",
"ses:TestRenderTemplate"
],
"Resource": "*"
}
]
```
## SESSendBouncePolicy
Concede SendBounce permiso a una identidad de Amazon Simple Email Service (Amazon SES).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:SendBounce"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ses:${AWS::Region}:${AWS::AccountId}:identity/${identityName}",
{
"identityName": {
"Ref": "IdentityName"
}
}
]
}
}
]
```
## SNSCrudPolicy
Concede permisos para crear, publicar y suscribirse a temas de Amazon SNS.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sns:ListSubscriptionsByTopic",
"sns:CreateTopic",
"sns:SetTopicAttributes",
"sns:Subscribe",
"sns:Publish"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sns:${AWS::Region}:${AWS::AccountId}:${topicName}*",
{
"topicName": {
"Ref": "TopicName"
}
}
]
}
}
]
```
## SNSPublishMessagePolicy
Concede permiso para publicar un mensaje en un tema de Amazon Simple Notification Service (Amazon SNS).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sns:Publish"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sns:${AWS::Region}:${AWS::AccountId}:${topicName}",
{
"topicName": {
"Ref": "TopicName"
}
}
]
}
}
]
```
## SQSPollerPolicy
Concede permiso para sondear una cola de Amazon Simple Queue Service (Amazon SQS).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sqs:ChangeMessageVisibility",
"sqs:ChangeMessageVisibilityBatch",
"sqs:DeleteMessage",
"sqs:DeleteMessageBatch",
"sqs:GetQueueAttributes",
"sqs:ReceiveMessage"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sqs:${AWS::Region}:${AWS::AccountId}:${queueName}",
{
"queueName": {
"Ref": "QueueName"
}
}
]
}
}
]
```
## SQSSendMessagePolicy
Concede permisos para enviar mensajes a una cola de Amazon SQS.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sqs:SendMessage*"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sqs:${AWS::Region}:${AWS::AccountId}:${queueName}",
{
"queueName": {
"Ref": "QueueName"
}
}
]
}
}
]
```
## SSMParameterReadPolicy
Otorga permiso para acceder a un parámetro de un almacén de parámetros de Amazon EC2 Systems Manager (SSM) para cargar datos secretos en esta cuenta. Se utiliza cuando el nombre del parámetro no tiene un prefijo de barra inclinada.
**nota**
Si no utiliza la clave predeterminada, también necesitará la política `KMSDecryptPolicy`.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:DescribeParameters"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ssm:GetParameters",
"ssm:GetParameter",
"ssm:GetParametersByPath"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ssm:${AWS::Region}:${AWS::AccountId}:parameter/${parameterName}",
{
"parameterName": {
"Ref": "ParameterName"
}
}
]
}
}
]
```
## SSMParameterWithSlashPrefixReadPolicy
Otorga permiso para acceder a un parámetro de un almacén de parámetros de Amazon EC2 Systems Manager (SSM) para cargar datos secretos en esta cuenta. Se utiliza cuando el nombre del parámetro tiene un prefijo de barra diagonal.
**nota**
Si no utiliza la clave predeterminada, también necesitará la política `KMSDecryptPolicy`.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:DescribeParameters"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ssm:GetParameters",
"ssm:GetParameter",
"ssm:GetParametersByPath"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ssm:${AWS::Region}:${AWS::AccountId}:parameter${parameterName}",
{
"parameterName": {
"Ref": "ParameterName"
}
}
]
}
}
]
```
## StepFunctionsExecutionPolicy
Concede permiso para iniciar la ejecución de una máquina de estado de Step Functions.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"states:StartExecution"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:states:${AWS::Region}:${AWS::AccountId}:stateMachine:${stateMachineName}",
{
"stateMachineName": {
"Ref": "StateMachineName"
}
}
]
}
}
]
```
## TextractDetectAnalyzePolicy
Concede acceso para detectar y analizar documentos con Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:DetectDocumentText",
"textract:StartDocumentTextDetection",
"textract:StartDocumentAnalysis",
"textract:AnalyzeDocument"
],
"Resource": "*"
}
]
```
## TextractGetResultPolicy
Concede acceso a documentos detectados y analizados desde Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:GetDocumentTextDetection",
"textract:GetDocumentAnalysis"
],
"Resource": "*"
}
]
```
## TextractPolicy
Proporciona acceso completo a Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:*"
],
"Resource": "*"
}
]
```
## VPCAccessPolicy
Permite crear, eliminar, describir y eliminar interfaces de red elásticas.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DeleteNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DetachNetworkInterface"
],
"Resource": "*"
}
]
```
# Gestión de AWS SAM permisos con CloudFormation mecanismos
Para controlar el acceso a AWS los recursos, the AWS Serverless Application Model (AWS SAM) puede usar los mismos mecanismos que. CloudFormation Para obtener más información, consulta [Control de acceso con AWS Identity and Access Management](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) en la *Guía del usuario de AWS CloudFormation *.
Existen tres opciones principales para conceder a un usuario permiso para administrar aplicaciones sin servidor. Cada opción proporciona a los usuarios diferentes niveles de control de acceso.
+ Concesión de permisos de administrador.
+ Adjunte las políticas AWS gestionadas necesarias.
+ Otorgue permisos específicos AWS Identity and Access Management (IAM).
Según la opción que elija, los usuarios solo pueden administrar las aplicaciones sin servidor que contengan AWS recursos a los que tengan permiso de acceso.
En las siguientes secciones se describe cada proceso de manera detallada.
## Concesión de permisos de administrador
Si concedes permisos de administrador a un usuario, este podrá administrar aplicaciones sin servidor que contengan cualquier combinación de AWS recursos. Esta es la opción más sencilla, pero también otorga a los usuarios el conjunto más amplio de permisos, lo que les permite realizar acciones con el mayor impacto.
Para obtener más información acerca de cómo conceder permisos de administrador a un usuario, consulta [Creación del primer grupo de usuarios y administradores de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) en la *Guía del usuario de IAM*.
## Adjunte las políticas AWS administradas necesarias
Puede conceder a los usuarios un subconjunto de permisos mediante [políticas AWS administradas](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies), en lugar de conceder permisos de administrador completos. Si usa esta opción, asegúrese de que el conjunto de políticas AWS administradas cubra todas las acciones y los recursos necesarios para las aplicaciones sin servidor que administran los usuarios.
Por ejemplo, las siguientes políticas AWS administradas son suficientes para [implementar la aplicación Hello World de ejemplo](serverless-getting-started-hello-world.md):
+ AWSCloudFormationFullAccess
+ IAMFullAcceder
+ AWSLambda\$1FullAccess
+ APIGatewayAdministrador de Amazon
+ Amazon S3 FullAccess
+ Amazon EC2 ContainerRegistryFullAccess
Para obtener más información acerca de cómo adjuntar políticas a un usuario de IAM, consulta [Cambio de los permisos de un usuario de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html) en la *Guía del usuario de IAM*.
## Conceda permisos específicos de IAM.
Para obtener un nivel de control de acceso más detallado, puede conceder permisos de IAM específicos a los usuarios mediante [instrucciones de política](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_statement.html). Si usas esta opción, asegúrese de que las instrucciones de políticas cubran todas las acciones y los recursos necesarios para las aplicaciones sin servidor que administran los usuarios.
La mejor práctica con esta opción es denegar a los usuarios el permiso para crear roles, incluidos los roles de ejecución de Lambda, para que no puedan concederse permisos escalados. Por lo tanto, como administrador, primero debe crear [rol de ejecución de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) que se especificará en las aplicaciones sin servidor que administrarán los usuarios. Para obtener información sobre la creación de roles de ejecución de Lambda, consulta [Creación de un rol de ejecución en la consola de IAM](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html#permissions-executionrole-console).
Para la [aplicación Hello World de ejemplo](serverless-getting-started-hello-world.md), **AWSLambdaBasicExecutionRole**basta con ejecutar la aplicación. Tras crear un rol de ejecución de Lambda, modifique el archivo de AWS SAM plantilla de la aplicación Hello World de ejemplo para añadir la siguiente propiedad al `AWS::Serverless::Function` recurso:
```
Role: lambda-execution-role-arn
```
Una vez implementada la aplicación Hello World modificada, la siguiente instrucción de política otorga permisos suficientes para que los usuarios implementen, actualicen y eliminen la aplicación:
**nota**
El ejemplo de declaración de política de esta sección le otorga el permiso suficiente para implementar, actualizar y eliminar la [aplicación Hello World de ejemplo](serverless-getting-started-hello-world.md). Si agrega tipos de recursos adicionales a su aplicación, debe actualizar la instrucción de política para incluir lo siguiente:
Permiso para que su aplicación invoque las acciones del servicio.
La entidad principal de servicio, si es necesaria para las acciones del servicio.
Por ejemplo, si agrega un flujo de trabajo de Step Functions, es posible que deba agregar permisos para las acciones que se enumeran [aquí](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsstepfunctions.html#awsstepfunctions-actions-as-permissions) y la entidad principal de servicio `states.amazonaws.com`.
Para obtener más información acerca de las políticas de IAM, consulta [Administración de las políticas de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html) en la *Guía del usuario de IAM*.
# Controla el acceso a la API con tu AWS SAM plantilla
Controlar el acceso a su API Gateway APIs ayuda a garantizar que su aplicación sin servidor sea segura y solo se pueda acceder a ella mediante la autorización que habilite. Puedes habilitar la autorización en tu AWS SAM plantilla para controlar quién puede acceder a tu API Gateway APIs.
AWS SAM admite varios mecanismos para controlar el acceso a su API Gateway APIs. El conjunto de mecanismos admitidos varía entre los tipos de recursos `AWS::Serverless::HttpApi` y `AWS::Serverless::Api`.
En la tabla siguiente se resumen los mecanismos que admite cada tipo de recurso.
| Mecanismos para controlar el acceso | AWS::Serverless::HttpApi | AWS::Serverless::Api |
| --- | --- | --- |
| Autorizadores de Lambda | ✓ | ✓ |
| Permisos de IAM | | ✓ |
| Grupos de usuarios de Amazon Cognito | ✓ \$1 | ✓ |
| Claves de API | | ✓ |
| Políticas de recursos | | ✓ |
| OAuth autorizadores 2.0/JWT | ✓ | |
\$1 Puede utilizar Amazon Cognito como emisor de un token web JSON (JWT) con el tipo de recurso `AWS::Serverless::HttpApi`.
+ **Autorizadores de Lambda**: un autorizador de Lambda (que anteriormente se denominaba *autorizador personalizado*) es una función de Lambda que se proporciona para controlar el acceso a los métodos de la API. Cuando se llama a su API, esta función de Lambda se invoca con un contexto de solicitud o un token de autorización que proporciona la aplicación cliente. La función de Lambda responde si la persona que llama está autorizada a realizar la operación solicitada.
Tanto el tipo de recurso `AWS::Serverless::HttpApi` como el tipo de recurso `AWS::Serverless::Api` admiten autorizadores de Lambda.
Para obtener más información sobre los autorizadores Lambda con`AWS::Serverless::HttpApi`, consulte [Trabajar con AWS Lambda autorizadores para HTTP en la Guía para desarrolladores](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-lambda-authorizer.html) de APIs *API* Gateway. Para obtener más información sobre los autorizadores de Lambda con `AWS::Serverless::Api`, consulta [Uso de autorizadores Lambda](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) en la *Guía para desarrolladores de API Gateway*.
Para ver ejemplos de autorizadores de Lambda para cualquier tipo de recurso, consulta [Ejemplos de autorizadores Lambda para AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md).
+ **Permisos de IAM**: puede controlar quién puede invocar su API mediante los [permisos de AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_controlling.html). Los usuarios que llamen a su API deben estar autenticados con credenciales de IAM. Las llamadas a su API solo se realizan correctamente si hay una política de IAM asociada al usuario de IAM que represente a la persona que llama a la API, un grupo de IAM que contenga al usuario o un rol de IAM que asuma el usuario.
Solo el tipo de recurso `AWS::Serverless::Api` admite los permisos de IAM.
Para obtener más información, consulta [Control del acceso a las API con permisos de IAM](https://docs.aws.amazon.com/apigateway/latest/developerguide/permissions.html) en la *Guía para desarrolladores de API Gateway*. Para ver un ejemplo, consulta [Ejemplo de permiso de IAM para AWS SAM](serverless-controlling-access-to-apis-permissions.md).
+ **Grupos de usuarios de Amazon Cognito**: los grupos de usuarios de Amazon Cognito son directorios de usuarios de Amazon Cognito. Un cliente de su API primero debe iniciar sesión con un usuario en el grupo de usuarios y obtener una identidad o un token de acceso para el usuario. A continuación, el cliente llama a la API con uno de los tokens devueltos. La llamada a la API solo se realiza correctamente si el token requerido es válido.
El tipo de recurso `AWS::Serverless::Api` admite grupos de usuarios de Amazon Cognito. El tipo de recurso `AWS::Serverless::HttpApi` admite el uso de Amazon Cognito como emisor de JWT.
Para obtener más información, consulta [Control del acceso a una API de REST con grupos de usuarios de Amazon Cognito como autorizador](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) en la *Guía para desarrolladores de API Gateway*. Para ver un ejemplo, consulta [Ejemplo de grupo de usuarios de Amazon Cognito para AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md).
+ **Claves de API**: son valores de cadenas alfanuméricas que distribuye a los clientes desarrolladores de aplicaciones para concederles acceso a su API.
Solo el tipo de recurso `AWS::Serverless::Api` admite claves de API.
Para obtener más información sobre claves de API, consulta el tema [Creación y utilización de planes de uso de claves API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) en la *Guía para desarrolladores de API Gateway*. Para ver un ejemplo de claves de API, consulta [Ejemplo de clave de API para AWS SAM](serverless-controlling-access-to-apis-keys.md).
+ **Políticas basadas en recursos**: son documentos de política JSON que se adjuntan a una API de API Gateway. Utilice políticas de recursos para controlar si una entidad principal especificada (normalmente un usuario o rol de IAM) puede invocar la API.
Solo el tipo de `AWS::Serverless::Api` recurso admite las políticas de recursos como mecanismo para controlar el acceso a API Gateway APIs.
Para obtener más información sobre las políticas de recursos, consulta [Controlar el acceso a una API con las políticas de recursos de API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) en la *Guía para desarrolladores de API Gateway*. Para ver ejemplos de políticas de recursos, consulta [Ejemplo de política de recursos para AWS SAM](serverless-controlling-access-to-apis-resource-policies.md).
+ **OAuth Autorizadores 2.0/JWT**[: se pueden utilizar JWTs como parte de los marcos OpenID [Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) y OAuth 2.0 para controlar el acceso a sus.](https://oauth.net/2/) APIs API Gateway valida JWTs lo que los clientes envían con las solicitudes de API y permite o deniega las solicitudes en función de la validación del token y, opcionalmente, de los ámbitos del token.
Solo el tipo de `AWS::Serverless::HttpApi` recurso admite los autorizadores OAuth 2.0/JWT.
Para obtener más información, consulte [Control del acceso a HTTP APIs con autorizadores JWT](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) en la Guía para *desarrolladores de API Gateway*. Para ver un ejemplo, consulta [OAuth Ejemplo de autorizador 2.0/JWT para AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md).
## Elegir un mecanismo para controlar el acceso
El mecanismo que elija utilizar para controlar el acceso a su API Gateway APIs depende de varios factores. Por ejemplo, si tiene un proyecto totalmente nuevo sin configurar la autorización ni el control de acceso, los grupos de usuarios de Amazon Cognito podrían ser su mejor opción. Esto se debe a que, al configurar grupos de usuarios, también configura automáticamente la autenticación y el control de acceso.
Sin embargo, si tu aplicación ya tiene configurada la autenticación, la mejor opción podría ser utilizar autorizadores de Lambda. Esto se debe a que puede llamar a su servicio de autenticación actual y devolver un documento de política en función de la respuesta. Además, si tu aplicación requiere una autenticación personalizada o una lógica de control de acceso que los grupos de usuarios no admiten, los autorizadores de Lambda podrían ser su mejor opción.
Cuando hayas elegido qué mecanismo usar, consulta la sección correspondiente en la sección correspondiente [Ejemplos](#serverless-controlling-access-to-apis-examples) para saber cómo configurar tu aplicación para que use ese mecanismo. AWS SAM
## Personalizar respuestas de error
Se puede utilizar AWS SAM para personalizar el contenido de algunas respuestas de error de API Gateway. Solo el tipo de recurso `AWS::Serverless::Api` admite respuestas personalizadas de API Gateway.
Para obtener más información, consulta el tema [Respuestas de Gateway en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) en la *Guía para desarrolladores de API Gateway*. Para ver un ejemplo de respuestas personalizadas, consulta [Ejemplo de respuesta personalizada para AWS SAM](serverless-controlling-access-to-apis-customize-response.md).
## Ejemplos
+ [Ejemplos de autorizadores Lambda para AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md)
+ [Ejemplo de permiso de IAM para AWS SAM](serverless-controlling-access-to-apis-permissions.md)
+ [Ejemplo de grupo de usuarios de Amazon Cognito para AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md)
+ [Ejemplo de clave de API para AWS SAM](serverless-controlling-access-to-apis-keys.md)
+ [Ejemplo de política de recursos para AWS SAM](serverless-controlling-access-to-apis-resource-policies.md)
+ [OAuth Ejemplo de autorizador 2.0/JWT para AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md)
+ [Ejemplo de respuesta personalizada para AWS SAM](serverless-controlling-access-to-apis-customize-response.md)
# Ejemplos de autorizadores Lambda para AWS SAM
El tipo de recurso `AWS::Serverless::Api` admite dos tipos de autorizadores de Lambda: `TOKEN` y `REQUEST`. Solo el tipo de recurso `AWS::Serverless::HttpApi` admite los autorizadores `REQUEST`. A continuación, se incluyen ejemplos de cada tipo.
## Ejemplos de autorizadores `TOKEN` de Lambda (AWS::Serverless::Api)
Puede controlar el acceso al suyo APIs definiendo un `TOKEN` autorizador Lambda en su plantilla. AWS SAM Para ello, utilice el tipo de datos [ApiAuth](sam-property-api-apiauth.md).
La siguiente es una sección de AWS SAM plantilla de ejemplo para un autorizador Lambda`TOKEN`:
**nota**
En el siguiente ejemplo, el `FunctionRole` de SAM se genera implícitamente.
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaTokenAuthorizer
Authorizers:
MyLambdaTokenAuthorizer:
FunctionArn: !GetAtt MyAuthFunction.Arn
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
Para obtener más información sobre los autorizadores de Lambda, consulta [Uso de autorizadores Lambda de API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) en la *Guía para desarrolladores de API Gateway*.
## Ejemplos de autorizadores de Lambda `REQUEST` (AWS::Serverless::Api)
Puede controlar el acceso al suyo APIs definiendo un `REQUEST` autorizador Lambda en su plantilla. AWS SAM Para ello, utilice el tipo de datos [ApiAuth](sam-property-api-apiauth.md).
La siguiente es una sección de AWS SAM plantilla de ejemplo para un autorizador Lambda`REQUEST`:
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaRequestAuthorizer
Authorizers:
MyLambdaRequestAuthorizer:
FunctionPayloadType: REQUEST
FunctionArn: !GetAtt MyAuthFunction.Arn
Identity:
QueryStrings:
- auth
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
Para obtener más información sobre los autorizadores de Lambda, consulta [Uso de autorizadores Lambda de API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) en la *Guía para desarrolladores de API Gateway*.
## Ejemplos de autorizadores de Lambda (AWS::Serverless::HttpApi)
Puede controlar el acceso a su HTTP APIs definiendo un autorizador Lambda en su plantilla. AWS SAM Para ello, utilice el tipo de datos [HttpApiAuth](sam-property-httpapi-httpapiauth.md).
La siguiente es una sección de AWS SAM plantilla de ejemplo para un autorizador Lambda:
```
Resources:
MyApi:
Type: AWS::Serverless::HttpApi
Properties:
StageName: Prod
Auth:
DefaultAuthorizer: MyLambdaRequestAuthorizer
Authorizers:
MyLambdaRequestAuthorizer:
FunctionArn: !GetAtt MyAuthFunction.Arn
FunctionInvokeRole: !GetAtt MyAuthFunctionRole.Arn
Identity:
Headers:
- Authorization
AuthorizerPayloadFormatVersion: 2.0
EnableSimpleResponses: true
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: index.handler
Runtime: nodejs12.x
Events:
GetRoot:
Type: HttpApi
Properties:
ApiId: !Ref MyApi
Path: /
Method: get
PayloadFormatVersion: "2.0"
MyAuthFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: authorizer.handler
Runtime: nodejs12.x
```
# Ejemplo de permiso de IAM para AWS SAM
Puede controlar el acceso al suyo APIs definiendo los permisos de IAM en su AWS SAM plantilla. Para ello, utilice el tipo de datos [ApiAuth](sam-property-api-apiauth.md).
A continuación, se muestra un ejemplo de AWS SAM plantilla que se utiliza para los permisos de IAM:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Description: 'API with IAM authorization'
Auth:
DefaultAuthorizer: AWS_IAM #sets AWS_IAM auth for all methods in this API
MyFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.10
Events:
GetRoot:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
InlineCode: |
def handler(event, context):
return {'body': 'Hello World!', 'statusCode': 200}
```
Para obtener más información sobre los permisos de IAM, consulta [Controlar el acceso para invocar una API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html) en la *Guía para desarrolladores de API Gateway*.
# Ejemplo de grupo de usuarios de Amazon Cognito para AWS SAM
Puede controlar el acceso al suyo APIs definiendo los grupos de usuarios de Amazon Cognito en su AWS SAM plantilla. Para ello, utilice el tipo de datos [ApiAuth](sam-property-api-apiauth.md).
A continuación, se muestra un ejemplo AWS SAM de sección de plantillas para un grupo de usuarios:
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Cors: "'*'"
Auth:
DefaultAuthorizer: MyCognitoAuthorizer
Authorizers:
MyCognitoAuthorizer:
UserPoolArn: !GetAtt MyCognitoUserPool.Arn
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Handler: lambda.handler
Runtime: nodejs12.x
Events:
Root:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: GET
MyCognitoUserPool:
Type: AWS::Cognito::UserPool
Properties:
UserPoolName: !Ref CognitoUserPoolName
Policies:
PasswordPolicy:
MinimumLength: 8
UsernameAttributes:
- email
Schema:
- AttributeDataType: String
Name: email
Required: false
MyCognitoUserPoolClient:
Type: AWS::Cognito::UserPoolClient
Properties:
UserPoolId: !Ref MyCognitoUserPool
ClientName: !Ref CognitoUserPoolClientName
GenerateSecret: false
```
Para obtener más información, consulta [Control del acceso a una API de REST con grupos de usuarios de Amazon Cognito como autorizador](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) en la *Guía para desarrolladores de API Gateway*.
# Ejemplo de clave de API para AWS SAM
Puedes controlar el acceso a tu AWS SAM plantilla APIs solicitando claves de API. Para ello, utilice el tipo de datos [ApiAuth](sam-property-api-apiauth.md).
A continuación, se muestra un ejemplo de una sección AWS SAM de plantillas para las claves de API:
```
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
Auth:
ApiKeyRequired: true # sets for all methods
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: index.handler
Runtime: nodejs12.x
Events:
ApiKey:
Type: Api
Properties:
RestApiId: !Ref MyApi
Path: /
Method: get
Auth:
ApiKeyRequired: true
```
Para obtener más información sobre claves de API, consulta el tema [Creación y utilización de planes de uso de claves API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) en la *Guía para desarrolladores de API Gateway*.
# Ejemplo de política de recursos para AWS SAM
Puede controlar el acceso a la suya APIs adjuntando una política de recursos a su AWS SAM plantilla. Para ello, utilice el tipo de datos [ApiAuth](sam-property-api-apiauth.md).
El siguiente es un ejemplo de AWS SAM plantilla para una API privada. Una API privada debe tener una política de recursos para poder implementarse.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyPrivateApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
EndpointConfiguration: PRIVATE # Creates a private API. Resource policies are required for all private APIs.
Auth:
ResourcePolicy:
CustomStatements:
- Effect: 'Allow'
Action: 'execute-api:Invoke'
Resource: ['execute-api:/*/*/*']
Principal: '*'
- Effect: 'Deny'
Action: 'execute-api:Invoke'
Resource: ['execute-api:/*/*/*']
Principal: '*'
MyFunction:
Type: 'AWS::Serverless::Function'
Properties:
InlineCode: |
def handler(event, context):
return {'body': 'Hello World!', 'statusCode': 200}
Handler: index.handler
Runtime: python3.10
Events:
AddItem:
Type: Api
Properties:
RestApiId:
Ref: MyPrivateApi
Path: /
Method: get
```
Para obtener más información sobre las políticas de recursos, consulta [Controlar el acceso a una API con las políticas de recursos de API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) en la *Guía para desarrolladores de API Gateway*. Para obtener más información sobre la privacidad APIs, consulte [Creación de una API privada en Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-apis.html) en la *Guía para desarrolladores de API Gateway*.
# OAuth Ejemplo de autorizador 2.0/JWT para AWS SAM
[Puede controlar el acceso a su APIs uso JWTs como parte de los marcos [OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) y 2.0. OAuth ](https://oauth.net/2/) Para ello, utilice el tipo de datos [HttpApiAuth](sam-property-httpapi-httpapiauth.md).
A continuación se muestra un ejemplo de sección de AWS SAM plantillas para un OAuth autorizador 2.0/JWT:
```
Resources:
MyApi:
Type: AWS::Serverless::HttpApi
Properties:
Auth:
Authorizers:
MyOauth2Authorizer:
AuthorizationScopes:
- scope
IdentitySource: $request.header.Authorization
JwtConfiguration:
audience:
- audience1
- audience2
issuer: "https://www.example.com/v1/connect/oidc"
DefaultAuthorizer: MyOauth2Authorizer
StageName: Prod
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src
Events:
GetRoot:
Properties:
ApiId: MyApi
Method: get
Path: /
PayloadFormatVersion: "2.0"
Type: HttpApi
Handler: index.handler
Runtime: nodejs12.x
```
*Para obtener más información sobre los autorizadores OAuth 2.0/JWT, consulte [Control del acceso a HTTP APIs con autorizadores JWT en](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) la Guía para desarrolladores de API Gateway.*
# Ejemplo de respuesta personalizada para AWS SAM
Puedes personalizar algunas respuestas de error de API Gateway definiendo los encabezados de respuesta en su plantilla de AWS SAM . Para ello, utilice el tipo de datos [Gateway Response Object](https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#gateway-response-object).
A continuación, se muestra un ejemplo de AWS SAM plantilla que crea una respuesta personalizada para el `DEFAULT_5XX` error.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
MyApi:
Type: AWS::Serverless::Api
Properties:
StageName: Prod
GatewayResponses:
DEFAULT_5XX:
ResponseParameters:
Headers:
Access-Control-Expose-Headers: "'WWW-Authenticate'"
Access-Control-Allow-Origin: "'*'"
ErrorHeader: "'MyCustomErrorHeader'"
ResponseTemplates:
application/json: "{\"message\": \"Error on the $context.resourcePath resource\" }"
GetFunction:
Type: AWS::Serverless::Function
Properties:
Runtime: python3.10
Handler: index.handler
InlineCode: |
def handler(event, context):
raise Exception('Check out the new response!')
Events:
GetResource:
Type: Api
Properties:
Path: /error
Method: get
RestApiId: !Ref MyApi
```
Para obtener más información, consulta el tema [Respuestas de Gateway en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) en la *Guía para desarrolladores de API Gateway*.
# Aumente la eficiencia con las capas Lambda con AWS SAM
Con AWS SAMél, puede incluir capas en sus aplicaciones sin servidor. AWS Lambda las capas permiten extraer código de una función de Lambda a una capa de Lambda, que luego se puede utilizar en varias funciones de Lambda. Esto le permite reducir el tamaño de los paquetes de implementación, separar la lógica de las funciones principales de las dependencias y compartir las dependencias entre varias funciones. Para obtener más información acerca de las capas, consulte [Capas Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html), en la *Guía para desarrolladores de AWS Lambda *.
Este tema proporciona información sobre lo siguiente:
+ Incluir capas en la aplicación
+ Cómo se almacenan las capas en caché local
Para obtener información sobre la creación de capas personalizadas, consulta [Creación de capas Lambda en AWS SAM](building-layers.md).
## Incluir capas en la aplicación
Para incluir capas en la aplicación, utiliza la propiedad `Layers` del tipo de recurso [AWS::Serverless::Function](sam-resource-function.md).
A continuación se presenta un ejemplo AWS SAM de plantilla con una función Lambda que incluye una capa:
```
ServerlessFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: my_handler
Runtime: Python3.7
Layers:
-
```
## Cómo se almacenan las capas en caché local
Al invocar la función mediante uno de los comandos `sam local`, el paquete de capas de la función se descarga y se almacena en caché en el host local.
En la tabla siguiente se muestran las ubicaciones predeterminadas de los directorios de caché para los distintos sistemas operativos.
****
| SO | Ubicación |
| --- | --- |
| Windows 7 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| Windows 8 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| Windows 10 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM |
| macOS | \$1/.aws-sam/layers-pkg |
| Unix | \$1/.aws-sam/layers-pkg |
Una vez almacenado el paquete en caché, la CLI de AWS SAM superpone las capas en una imagen de Docker que se utiliza para invocar la función. AWS SAMCLIGenera los nombres de las imágenes que crea, así como las LayerVersions que se guardan en la memoria caché. Encontrará más detalles sobre el esquema en las secciones siguientes.
Para inspeccionar las capas superpuestas, ejecuta el siguiente comando para iniciar una sesión de bash en la imagen que desea inspeccionar:
```
docker run -it --entrypoint=/bin/bash samcli/lambda: -i
```
**Esquema de nombres del directorio de almacenamiento en caché de capas**
Dado LayerVersionArn que a está definido en su plantilla, AWS SAMCLI extrae la versión LayerName y del ARN. Crea un directorio para colocar el contenido de la capa denominada `LayerName-Version-`.
Ejemplo:
```
ARN = arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1
Directory name = myLayer-1-926eeb5ff1
```
**Esquema de etiquetas de Docker Images**
Para calcular el hash de las capas únicas, combine todos los nombres de capa únicos con un delimitador de «-», tome el SHA256 hash y, a continuación, tome los primeros 10 caracteres.
Ejemplo:
```
ServerlessFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: .
Handler: my_handler
Runtime: Python3.7
Layers:
- arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1
- arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1
```
Los nombres únicos se calculan de la misma manera que en el esquema de nombres del directorio de almacenamiento en caché de capas:
```
arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1 = myLayer-1-926eeb5ff1
arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1 = mySecondLayer-1-6bc1022bdf
```
Para calcular el hash de las capas únicas, combina todos los nombres de capa únicos con un delimitador de «-», tome el hash sha256 y, a continuación, tome los primeros 25 caracteres:
```
myLayer-1-926eeb5ff1-mySecondLayer-1-6bc1022bdf = 2dd7ac5ffb30d515926aef
```
A continuación, combina este valor con el tiempo de ejecución y la arquitectura de la función, con un delimitador de '-':
```
python3.7-x86_64-2dd7ac5ffb30d515926aefffd
```
# Reutilice el código y los recursos mediante aplicaciones anidadas en AWS SAM
Una aplicación sin servidor puede incluir una o más **aplicaciones anidadas**. Una aplicación anidada forma parte de una aplicación más grande y se puede empaquetar e implementar como un artefacto independiente o como un componente de una aplicación más grande. Las aplicaciones anidadas permiten convertir el código de uso frecuente en su propia aplicación, que luego se puede reutilizar en una aplicación sin servidor más grande o en varias aplicaciones sin servidor.
A medida que crecen las arquitecturas sin servidor, suelen surgir patrones comunes en los que los mismos componentes se definen en varias plantillas de aplicaciones. Las aplicaciones anidadas le permiten reutilizar el código, la funcionalidad, los recursos y las configuraciones comunes en AWS SAM plantillas independientes, lo que le permite mantener el código de una sola fuente. Esto reduce la duplicación de códigos y configuraciones. Además, este enfoque modular agiliza el desarrollo, mejora la organización del código y facilita la coherencia entre las aplicaciones sin servidor. Con las aplicaciones anidadas, puede concentrarse más en la lógica empresarial exclusiva de tu aplicación.
Para definir una aplicación anidada en tu aplicación sin servidor, utilice el tipo de recurso [AWS::Serverless::Application](sam-resource-application.md).
Puede definir aplicaciones anidadas a partir de las dos fuentes siguientes:
+ Una **aplicación de AWS Serverless Application Repository **: usted puede definir aplicaciones anidadas mediante las aplicaciones que están disponibles para su cuenta en el AWS Serverless Application Repository. Pueden ser aplicaciones *privadas* de su cuenta, aplicaciones que se *comparten de forma privada* con su cuenta o aplicaciones que se *comparten públicamente* en el AWS Serverless Application Repository. Para obtener más información sobre los distintos niveles de permisos de implementación, consulta los [Permisos de implementación de aplicaciones](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#application-deployment-permissions) y la [Publicación de aplicaciones](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-publishing-applications.html) en la *Guía para desarrolladores AWS Serverless Application Repository *.
+ Una **aplicación local**: usted puede definir aplicaciones anidadas mediante aplicaciones almacenadas en el sistema de archivos local.
Consulte las siguientes secciones para obtener información detallada sobre cómo AWS SAM definir estos dos tipos de aplicaciones anidadas en su aplicación sin servidor.
**nota**
El número máximo de aplicaciones que se pueden anidar en una aplicación sin servidor es de 200.
El número máximo de parámetros que puede tener una aplicación anidada es 60.
## Definir una aplicación anidada a partir del AWS Serverless Application Repository
Usted puede definir aplicaciones anidadas mediante las aplicaciones que están disponibles en el AWS Serverless Application Repository. También puede almacenar y distribuir aplicaciones que contengan aplicaciones anidadas mediante el AWS Serverless Application Repository. Para revisar los detalles de una aplicación anidada en AWS Serverless Application Repository, puede usar el AWS SDK, la consola Lambda o la AWS CLI consola Lambda.
Para definir una aplicación que esté alojada AWS Serverless Application Repository en la AWS SAM plantilla de su aplicación sin servidor, utilice el botón **Copiar como recurso SAM** de la página de detalles de cada aplicación. AWS Serverless Application Repository Para ello, sigue estos pasos:
1. Asegúrese de que ha iniciado sesión en Consola de administración de AWS.
1. Busque la aplicación en la que desee insertarla AWS Serverless Application Repository siguiendo los pasos de la sección [Exploración, búsqueda e implementación de aplicaciones](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#browse-and-search-applications ) de la *Guía para AWS Serverless Application Repository desarrolladores*.
1. Seleccione el botón **Copiar como recurso SAM**. La sección de plantillas SAM de la aplicación que está viendo ahora está en su portapapeles.
1. Pegue la sección de la plantilla SAM en la sección de `Resources:` del archivo de plantilla SAM de la aplicación que desee incluir en esta aplicación.
A continuación se muestra un ejemplo de una sección de plantillas SAM para una aplicación anidada que está alojada en el AWS Serverless Application Repository:
```
Transform: AWS::Serverless-2016-10-31
Resources:
applicationaliasname:
Type: AWS::Serverless::Application
Properties:
Location:
ApplicationId: arn:aws:serverlessrepo:us-east-1:123456789012:applications/application-alias-name
SemanticVersion: 1.0.0
Parameters:
# Optional parameter that can have default value overridden
# ParameterName1: 15 # Uncomment to override default value
# Required parameter that needs value to be provided
ParameterName2: YOUR_VALUE
```
Si no hay ninguna configuración de parámetros obligatoria, puede omitir la sección `Parameters:` de la plantilla.
**importante**
Las aplicaciones que contienen aplicaciones anidadas alojadas en ellas AWS Serverless Application Repository heredan las restricciones de uso compartido de las aplicaciones anidadas.
Por ejemplo, supongamos que una aplicación se comparte públicamente, pero contiene una aplicación anidada que solo se comparte de forma privada con la AWS cuenta que creó la aplicación principal. En este caso, si tu AWS cuenta no tiene permiso para implementar la aplicación anidada, no podrás implementar la aplicación principal. Para más información sobre los permisos para implementasr aplicaciones, consulta [Permisos de implementación de aplicaciones](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#application-deployment-permissions) y [Publicación de aplicaciones](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-publishing-applications.html) en la *Guía del desarrollador de AWS Serverless Application Repository *.
## Definir una aplicación anidada desde el sistema de archivos local
Usted puede definir aplicaciones anidadas mediante aplicaciones almacenadas en el sistema de archivos local. Para ello, especifique la ruta al archivo de AWS SAM plantilla que está almacenado en el sistema de archivos local.
A continuación se muestra un ejemplo de una sección de plantillas SAM para una aplicación local anidada:
```
Transform: AWS::Serverless-2016-10-31
Resources:
applicationaliasname:
Type: AWS::Serverless::Application
Properties:
Location: ../my-other-app/template.yaml
Parameters:
# Optional parameter that can have default value overridden
# ParameterName1: 15 # Uncomment to override default value
# Required parameter that needs value to be provided
ParameterName2: YOUR_VALUE
```
Si no hay ninguna configuración de parámetros, puede omitir la sección `Parameters:` de la plantilla.
## Implementar aplicaciones anidadas
Puede implementar tu aplicación anidada mediante el comando `sam deploy` de la AWS SAM CLI. Para obtener más información, consulta [Implemente su aplicación y sus recursos con AWS SAM](serverless-deploying.md).
**nota**
Cuando implementa una aplicación que contiene aplicaciones anidadas, debe reconocer que contiene aplicaciones anidadas. Para ello, pase `CAPABILITY_AUTO_EXPAND` a la [CreateCloudFormationChangeSet API](https://docs.aws.amazon.com/goto/WebAPI/serverlessrepo-2017-09-08/CreateCloudFormationChangeSet) o utilice el [https://docs.aws.amazon.com/cli/latest/reference/serverlessrepo/create-cloud-formation-change-set.html](https://docs.aws.amazon.com/cli/latest/reference/serverlessrepo/create-cloud-formation-change-set.html) AWS CLI comando.
Para obtener más información sobre cómo reconocer las aplicaciones anidadas, consulta [Reconocimiento de los Roles de IAM, las políticas de recursos y las aplicaciones anidadas al implementasr aplicaciones](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/acknowledging-application-capabilities.html) en la *Guía para desarrolladores de AWS Serverless Application Repository *.
# Gestione eventos basados en el tiempo con el EventBridge programador en AWS SAM
El contenido de este tema proporciona detalles sobre qué es Amazon EventBridge Scheduler, qué soporte AWS SAM ofrece, cómo puede crear eventos de Scheduler y ejemplos a los que puede hacer referencia al crear eventos de Scheduler.
## ¿Qué es Amazon EventBridge Scheduler?
Usa EventBridge Scheduler para programar eventos en tus plantillas. AWS SAM Amazon EventBridge Scheduler es un servicio de programación que le permite crear, iniciar y gestionar decenas de millones de eventos y tareas en todos los AWS servicios. Este servicio es especialmente útil para los eventos relacionados con el tiempo. Puede usarlo para programar eventos e invocaciones periódicas basadas en el tiempo. También admite eventos únicos, así como expresiones cronológicas y de frecuencia con una hora de inicio y finalización.
Para obtener más información sobre Amazon EventBridge Scheduler, consulte [¿Qué es Amazon EventBridge Scheduler](https://docs.aws.amazon.com/scheduler/latest/UserGuide/what-is-scheduler.html)? en la Guía del usuario de *EventBridge Scheduler.*
**Topics**
+ [¿Qué es Amazon EventBridge Scheduler?](#using-eventbridge-scheduler-intro)
+ [EventBridge Soporte para el programador en AWS SAM](#using-eventbridge-scheduler-sam-support)
+ [Crear eventos del EventBridge Scheduler en AWS SAM](#using-eventbridge-scheduler-sam-create)
+ [Ejemplos](#using-eventbridge-scheduler-examples)
+ [Más información](#using-eventbridge-scheduler-learn)
## EventBridge Soporte para el programador en AWS SAM
La especificación de la plantilla AWS Serverless Application Model (AWS SAM) proporciona una sintaxis simple y abreviada que puedes usar para programar eventos con EventBridge Scheduler for y. AWS Lambda AWS Step Functions
## Crear eventos del EventBridge Scheduler en AWS SAM
Defina la `ScheduleV2` propiedad como el tipo de evento en su AWS SAM plantilla para definir su evento del EventBridge Scheduler. Esta propiedad admite los tipos de recursos `AWS::Serverless::Function` y `AWS::Serverless::StateMachine`.
```
MyFunction:
Type: AWS::Serverless::Function
Properties:
Events:
CWSchedule:
Type: ScheduleV2
Properties:
ScheduleExpression: 'rate(1 minute)'
Name: TestScheduleV2Function
Description: Test schedule event
MyStateMachine:
Type: AWS::Serverless::StateMachine
Properties:
Events:
CWSchedule:
Type: ScheduleV2
Properties:
ScheduleExpression: 'rate(1 minute)'
Name: TestScheduleV2StateMachine
Description: Test schedule event
```
EventBridge La programación de eventos del programador también admite *colas con letra muerta (DLQ*) para los eventos no procesados. *Para obtener más información sobre las colas de letra muerta, consulte [Configuración de una cola de letra muerta para Scheduler en la Guía del usuario de Scheduler](https://docs.aws.amazon.com/scheduler/latest/UserGuide/configuring-schedule-dlq.html). EventBridge EventBridge *
Cuando se especifica un ARN de DLQ AWS SAM , configura los permisos para que el programador envíe mensajes al DLQ. Cuando no se especifica un ARN de DLQ AWS SAM , se creará el recurso de DLQ.
## Ejemplos
### Ejemplo básico de definición de un evento de Scheduler con EventBridge AWS SAM
```
Transform: AWS::Serverless-2016-10-31
Resources:
MyLambdaFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.8
InlineCode: |
def handler(event, context):
print(event)
return {'body': 'Hello World!', 'statusCode': 200}
MemorySize: 128
Events:
Schedule:
Type: ScheduleV2
Properties:
ScheduleExpression: rate(1 minute)
Input: '{"hello": "simple"}'
MySFNFunction:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: python3.8
InlineCode: |
def handler(event, context):
print(event)
return {'body': 'Hello World!', 'statusCode': 200}
MemorySize: 128
StateMachine:
Type: AWS::Serverless::StateMachine
Properties:
Type: STANDARD
Definition:
StartAt: MyLambdaState
States:
MyLambdaState:
Type: Task
Resource: !GetAtt MySFNFunction.Arn
End: true
Policies:
- LambdaInvokePolicy:
FunctionName: !Ref MySFNFunction
Events:
Schedule:
Type: ScheduleV2
Properties:
ScheduleExpression: rate(1 minute)
Input: '{"hello": "simple"}'
```
## Más información
Para obtener más información sobre la definición de la propiedad `ScheduleV2` EventBridge Scheduler, consulte:
+ [ScheduleV2](sam-property-function-schedulev2.md) para `AWS::Serverless::Function`.
+ [ScheduleV2](sam-property-statemachine-statemachineschedulev2.md) para `AWS::Serverless::StateMachine`.
# Organizar los AWS SAM recursos con AWS Step Functions
Puede utilizarlos [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/)para organizar AWS Lambda funciones y otros AWS recursos para crear flujos de trabajo complejos y sólidos. Step Functions le indica a la aplicación cuándo y en qué condiciones se utilizan sus AWS recursos, como AWS Lambda las funciones. Esto simplifica el proceso de establecer una conexión entre estos recursos. Con [AWS::Serverless::StateMachine](sam-resource-statemachine.md), puede definir los pasos individuales de su flujo de trabajo, asociar los recursos en cada paso y, a continuación, secuenciar estos pasos juntos. También puede agregar transiciones y condiciones donde sea necesario. Esto simplifica el proceso de establecer una conexión entre estos recursos.
**nota**
Para gestionar AWS SAM las plantillas que contienen máquinas de estado de Step Functions, debe utilizar la versión 0.52.0 o posterior de. AWS SAMCLI Puedes comprobar qué versión tienes ejecutando el comando `sam --version`.
Step Functions se basa en los conceptos de [tareas](https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-task-state.html) y [máquinas de estado](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-states.html). Las máquinas de estado se definen mediante [Amazon States Language](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html) basado en JSON. La [consola de Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) muestra una vista gráfica de la estructura de la máquina de estado, para que pueda comprobar visualmente la lógica de la máquina de estado y monitorizar las ejecuciones.
Con la compatibilidad con Step Functions en AWS Serverless Application Model (AWS SAM), puede hacer lo siguiente:
+ Defina las máquinas de estados, ya sea directamente dentro AWS SAM de una plantilla o en un archivo independiente
+ Cree funciones de ejecución de máquinas de estados mediante AWS SAM plantillas de políticas, políticas integradas o políticas gestionadas
+ Activa ejecuciones de máquinas de estado con EventBridge eventos de API Gateway o Amazon, según una programación dentro de una AWS SAM plantilla o llamando APIs directamente
+ Utilice las [plantillas de políticas de AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-policy-templates.html) disponibles para los patrones de desarrollo comunes de Step Functions.
## Ejemplo
El siguiente fragmento de ejemplo de un archivo de AWS SAM plantilla define una máquina de estados de Step Functions en un archivo de definición. Ten en cuenta que el archivo `my_state_machine.asl.json` debe estar inscrito en [Amazon States Language](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html).
```
AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
Description: Sample SAM template with Step Functions State Machine
Resources:
MyStateMachine:
Type: AWS::Serverless::StateMachine
Properties:
DefinitionUri: statemachine/my_state_machine.asl.json
...
```
Para descargar una AWS SAM aplicación de ejemplo que incluye una máquina de estados de Step Functions, consulte [Creación de una máquina de estados de Step Functions mediante AWS SAM](https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-state-machine-using-sam.html) la *Guía para AWS Step Functions desarrolladores*.
## Más información
Para obtener más información sobre Step Functions y su uso con AWS SAM, consulte lo siguiente:
+ [Cómo funciona AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/how-step-functions-works.html)
+ [AWS Step Functions y AWS Serverless Application Model](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-sam-sfn.html)
+ [Tutorial: Crear una máquina de estados de Step Functions usando AWS SAM](https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-state-machine-using-sam.html)
+ [AWS SAM Especificación: AWS::Serverless::StateMachine](sam-resource-statemachine.md)
# Configura la firma de código para tu AWS SAM aplicación
Para garantizar que solo se implemente código confiable, puede utilizar esta opción AWS SAM para habilitar la firma de código en sus aplicaciones sin servidor. Firmar el código ayuda a garantizar que el código no se haya modificado desde la firma y que solo los paquetes de código firmados de editores de confianza se ejecuten en las funciones de Lambda. Esto ayuda a las organizaciones a liberarse de la carga de crear componentes de control en sus procesos de implementación.
Para obtener más información sobre la característica de firma de código, consulta [Configuración de firma de código para funciones de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html) en la *Guía para desarrolladores de AWS Lambda *.
Antes de poder configurar la firma de código para su aplicación sin servidor, debe crear un perfil de firma mediante AWS Signer. Este perfil de firma se utiliza para las siguientes tareas:
1. **Creación de una configuración de firma de código**: declare un recurso [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html) para especificar los perfiles de firma de los editores de confianza y establecer la acción política para las comprobaciones de validación. Puede declarar este objeto en la misma AWS SAM plantilla que la función sin servidor, en una AWS SAM plantilla diferente o en una plantilla. CloudFormation A continuación, habilita la firma de código para una función sin servidor especificando la propiedad de la función [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-codesigningconfigarn](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-codesigningconfigarn) con el nombre de recurso de Amazon (ARN) de un recurso [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html).
1. **Firmar el código**: utiliza el comando [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html) o [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) con la opción `--signing-profiles`.
**nota**
Para poder firmar correctamente el código con los comandos `sam package` o `sam deploy`, el control de versiones debes estar habilitado para el bucket de Amazon S3 que utiliza con estos comandos. Si utiliza el bucket de Amazon S3 que se AWS SAM crea para usted, el control de versiones se habilita automáticamente. Para obtener más información sobre el control de versiones de los buckets de Amazon S3 e instrucciones para habilitar el control de versiones en un bucket de Amazon S3 que proporciones, consulta [Uso del control de versiones en los buckets de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) en la *Guía del usuario de Amazon Simple Storage Service*.
Al implementar una aplicación sin servidor, Lambda realiza comprobaciones de validación en todas las funciones para las que ha habilitado la firma de código. Lambda también realiza comprobaciones de validación en cualquier capa de la que dependan esas funciones. Para obtener más información sobre las comprobaciones de validación de Lambda, consulta la [validación de firmas](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html#config-codesigning-valid) en la *Guía para desarrolladores de AWS Lambda *.
## Ejemplo
### Creación de un perfil de firma
Para crearlo, ejecuta este comando:
```
aws signer put-signing-profile --platform-id "AWSLambda-SHA384-ECDSA" --profile-name MySigningProfile
```
Si el comando anterior se ejecuta correctamente, verás que se devuelve el ARN del perfil de firma. Por ejemplo:
```
{
"arn": "arn:aws:signer:us-east-1:111122223333:/signing-profiles/MySigningProfile",
"profileVersion": "SAMPLEverx",
"profileVersionArn": "arn:aws:signer:us-east-1:111122223333:/signing-profiles/MySigningProfile/SAMPLEverx"
}
```
El campo `profileVersionArn` contiene el ARN que se utilizará al crear la configuración de firma de código.
### Creación de una configuración de firma de código para una función
La siguiente AWS SAM plantilla de ejemplo declara un [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html)recurso y habilita la firma de código para una función Lambda. En este ejemplo, hay un perfil de confianza y las implementaciones se rechazan si las comprobaciones de firma fallan.
```
Resources:
HelloWorld:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.7
CodeSigningConfigArn: !Ref MySignedFunctionCodeSigningConfig
MySignedFunctionCodeSigningConfig:
Type: AWS::Lambda::CodeSigningConfig
Properties:
Description: "Code Signing for MySignedLambdaFunction"
AllowedPublishers:
SigningProfileVersionArns:
- MySigningProfile-profileVersionArn
CodeSigningPolicies:
UntrustedArtifactOnDeployment: "Enforce"
```
### Firmar tu código
Puedes firmar el código al empaquetar o implementar la aplicación. Especifique la opción `--signing-profiles` con el comando `sam package` o `sam deploy`, como se muestra en los siguientes comandos de ejemplo.
Firmar el código de función al empaquetar la aplicación:
```
sam package --signing-profiles HelloWorld=MySigningProfile --s3-bucket amzn-s3-demo-bucket --output-template-file packaged.yaml
```
Firmar el código de la función y la capa de la que depende la función al empaquetar la aplicación:
```
sam package --signing-profiles HelloWorld=MySigningProfile MyLayer=MySigningProfile --s3-bucket amzn-s3-demo-bucket --output-template-file packaged.yaml
```
Firmar el código de la función y una capa y, a continuación, realizar una implementación:
```
sam deploy --signing-profiles HelloWorld=MySigningProfile MyLayer=MySigningProfile --s3-bucket amzn-s3-demo-bucket --template-file packaged.yaml --stack-name --region us-east-1 --capabilities CAPABILITY_IAM
```
**nota**
Para poder firmar correctamente el código con los comandos `sam package` o `sam deploy`, el control de versiones debes estar habilitado para el bucket de Amazon S3 que utiliza con estos comandos. Si utiliza el bucket de Amazon S3 que se AWS SAM crea para usted, el control de versiones se habilita automáticamente. Para obtener más información sobre el control de versiones de los buckets de Amazon S3 e instrucciones para habilitar el control de versiones en un bucket de Amazon S3 que proporciones, consulta [Uso del control de versiones en los buckets de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) en la *Guía del usuario de Amazon Simple Storage Service*.
## Proporcionar perfiles de firma con `sam deploy --guided`
Cuando ejecuta el `sam deploy --guided` comando con una aplicación sin servidor configurada con firma de código, AWS SAM le pide que proporcione el perfil de firma que se utilizará para la firma de código. Para obtener más información sobre `sam deploy --guided`, consulta [sam deploy](sam-cli-command-reference-sam-deploy.md) en la referencia de los comandos de AWS SAM CLI.
# Validar archivos AWS SAM de plantilla
Valide sus plantillas con `sam validate`. Actualmente, este comando valida que la plantilla proporcionada sea JSON/YAML válida. Como ocurre con la mayoría de comandos de la CLI de AWS SAM, busca un archivo `template.[yaml|yml]` en el directorio de trabajo actual de forma predeterminada. Puede especificar una plantilla diferente file/location con la `--template` opción `-t` o.
Ejemplo:
```
$ sam validate
/template.yaml is a valid SAM Template
```
**nota**
El `sam validate` comando requiere que se configuren AWS las credenciales. Para obtener más información, consulte [Configuración de la AWS SAM de CLI](using-sam-cli-configure.md).
# 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
```