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