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.
# 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).