As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Configure e gerencie o acesso a recursos em seu AWS SAM modelo
Para que seus AWS recursos interajam entre si, o acesso e as permissões adequados devem ser configurados entre seus recursos. Fazer isso requer a configuração de usuários, funções e políticas AWS Identity and Access Management (IAM) para realizar sua interação de maneira segura.
Os tópicos desta seção estão todos relacionados à configuração do acesso aos recursos definidos no modelo. Esta seção começa com as melhores práticas gerais. Os próximos dois tópicos analisam duas opções que você tem para configurar o acesso e as permissões entre os recursos referenciados em seu aplicativo sem servidor: AWS SAM conectores e modelos de política. AWS SAM O último tópico fornece detalhes para gerenciar o acesso do usuário usando a mesma mecânica CloudFormation usada para gerenciar usuários.
Para saber mais, consulte [Controlar o acesso com AWS Identity and Access Management](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) no *AWS CloudFormation Guia do usuário*.
O AWS Serverless Application Model (AWS SAM) fornece duas opções que simplificam o gerenciamento de acesso e permissões para seus aplicativos sem servidor.
1. AWS SAM conectores
1. Modelos de políticas AWS SAM
## AWS SAM conectores
Os conectores são uma forma de fornecer permissões entre dois recursos. Você faz isso descrevendo como eles devem interagir uns com os outros em seu AWS SAM modelo. Eles podem ser definidos usando o atributo do recurso `Connectors` ou o tipo de recurso `AWS::Serverless::Connector`. Os conectores oferecem suporte ao provisionamento `Read` e `Write` ao acesso de dados e eventos entre uma combinação de recursos. AWS Para saber mais sobre AWS SAM conectores, consulte[Gerenciando permissões de recursos com AWS SAM conectores](managing-permissions-connectors.md).
## Modelos de políticas AWS SAM
AWS SAM os modelos de política são conjuntos predefinidos de permissões que você pode adicionar aos seus AWS SAM modelos para gerenciar o acesso e as permissões entre suas AWS Lambda funções, máquinas de AWS Step Functions estado e os recursos com os quais elas interagem. Para saber mais sobre modelos AWS SAM de política, consulte[Modelos de políticas AWS SAM](serverless-policy-templates.md).
## AWS CloudFormation mecanismos
CloudFormation os mecanismos incluem a configuração de usuários, funções e políticas do IAM para gerenciar permissões entre seus AWS recursos. Para saber mais, consulte [Gerenciando AWS SAM permissões com CloudFormation mecanismos](sam-permissions-cloudformation.md).
## Práticas recomendadas
Em todos os seus aplicativos com tecnologia sem servidor, você pode usar vários métodos para configurar permissões entre seus recursos. Portanto, você pode selecionar a melhor opção para cada cenário e usar várias opções juntas em todos os seus aplicativos. Aqui estão alguns fatores a considerar ao escolher a melhor opção para você:
+ AWS SAM Tanto os conectores quanto os modelos de políticas reduzem a experiência em IAM necessária para facilitar as interações seguras entre seus AWS recursos. Use conectores e modelos de políticas quando houver suporte.
+ AWS SAM os conectores fornecem uma sintaxe abreviada simples e intuitiva para definir permissões em seus AWS SAM modelos e exigem o mínimo de experiência em IAM. Quando houver suporte para AWS SAM conectores e modelos de política, use AWS SAM conectores.
+ AWS SAM os conectores podem provisionar `Read` e `Write` acessar dados e eventos entre os recursos de AWS SAM origem e destino suportados. Para obter uma lista de recursos suportados, consulte [AWS SAM referência do conector](reference-sam-connector.md). Quando suportado, use AWS SAM conectores.
+ Embora os modelos AWS SAM de política estejam limitados às permissões entre suas funções do Lambda, as máquinas de estado do Step Functions e os AWS recursos com os quais elas interagem, os modelos de política oferecem suporte a todas as operações CRUD. Quando houver suporte e quando um modelo AWS SAM de política para seu cenário estiver disponível, use modelos AWS SAM de política. Para obter uma lista de modelos de política disponíveis, consulte [Modelos de políticas AWS SAM](serverless-policy-templates.md).
+ Para todos os outros cenários, ou quando a granularidade for necessária, use CloudFormation mecanismos.
# Gerenciando permissões de recursos com AWS SAM conectores
Os conectores são um tipo de recurso AWS Serverless Application Model (AWS SAM) abstrato, identificado como`AWS::Serverless::Connector`, que fornece permissões simples e bem definidas entre seus recursos de aplicativos sem servidor.
## Benefícios dos AWS SAM conectores
Ao compor automaticamente as políticas de acesso apropriadas entre os recursos, os conectores permitem que você crie seus aplicativos sem servidor e se concentre na arquitetura do aplicativo sem precisar de experiência em recursos de AWS autorização, linguagem de políticas e configurações de segurança específicas do serviço. Portanto, os conectores são um grande benefício para desenvolvedores que podem ser novos no desenvolvimento de tecnologia sem servidor ou desenvolvedores experientes que desejam aumentar sua velocidade de desenvolvimento.
## Usando AWS SAM conectores
Use o atributo de recurso `Connectors` incorporando-o em um recurso de **origem**. Em seguida, defina seu recurso de **destino** e descreva como os dados ou eventos devem fluir entre esses recursos. AWS SAM em seguida, compõe as políticas de acesso necessárias para facilitar as interações necessárias.
A seguir é descrito como esse atributo de recurso é gravado:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
:
Type:
...
Connectors:
:
Properties:
Destination:
Permissions:
...
```
## Como funcionam os conectores
**nota**
Esta seção explica como os conectores provisionam os recursos necessários nos bastidores. Isso acontece automaticamente ao usar conectores.
Primeiro, o atributo de recurso `Connectors` incorporado é transformado em um tipo de recurso `AWS::Serverless::Connector`. Seu ID lógico é criado automaticamente como**.
Por exemplo, aqui está um conector incorporado:
```
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
```
Isso gerará o seguinte 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**
Você também pode definir conectores em seu AWS SAM modelo usando essa sintaxe. Isso é recomendado quando seu recurso de origem é definido em um modelo separado do seu conector.
Em seguida, as políticas de acesso necessárias para essa conexão são compostas automaticamente. Para obter mais informações sobre os recursos gerados por conectores, consulte [CloudFormation recursos gerados quando você especifica AWS::Serverless::Connector](sam-specification-generated-resources-connector.md).
## Exemplo de conectores
O exemplo a seguir mostra como você pode usar conectores para gravar dados de uma AWS Lambda função em uma tabela do Amazon DynamoDB.
![\[Uma função do Lambda gravando dados em uma tabela do DynamoDB usando conectores do AWS SAM .\]](http://docs.aws.amazon.com/pt_br/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
```
O recurso do atributo `Connectors` está incorporado ao recurso de origem da função do Lambda. A tabela do DynamoDB é definida como o recurso de destino usando a propriedade `Id`. Os conectores provisionarão permissões `Write` entre esses dois recursos.
Quando você implanta seu AWS SAM modelo no CloudFormation, AWS SAM ele compõe automaticamente as políticas de acesso necessárias para que essa conexão funcione.
## Conexões suportadas entre recursos de origem e destino
Suporte a conectores `Read` e tipos de permissão de dados e eventos `Write` entre uma combinação selecionada de conexões de recursos de origem e destino. Por exemplo, os conectores oferecem suporte a uma conexão `Write` entre um recurso de origem `AWS::ApiGateway::RestApi` e um recurso de destino `AWS::Lambda::Function`.
Os recursos de origem e destino podem ser definidos usando uma combinação de propriedades compatíveis. Os requisitos de propriedade dependerão da conexão que você está fazendo e de onde os recursos estão definidos.
**nota**
Os conectores podem provisionar permissões entre os tipos de recursos com tecnologia sem servidor e sem tecnologia sem servidor compatíveis.
Para obter uma lista de conexões de recursos compatíveis e seus requisitos de propriedade, consulte [Tipos de recursos de origem e destino suportados para conectores](reference-sam-connector.md#supported-connector-resource-types).
# Defina as permissões de leitura e gravação em AWS SAM
Em AWS SAM, `Read` e `Write` as permissões podem ser provisionadas em um ú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 obter mais informações sobre o uso de conectores, consulte [AWS SAM referência do conector](reference-sam-connector.md).
# Defina recursos usando outras propriedades suportadas no AWS SAM
Para recursos de origem e destino, quando definidos no mesmo modelo, use a propriedade `Id`. Opcionalmente, um `Qualifier` pode ser adicionado para restringir o escopo do seu recurso definido. Quando o recurso não estiver no mesmo modelo, use uma combinação de propriedades compatíveis.
+ Para obter uma lista das combinações de propriedades suportadas para recursos de origem e destino, consulte [Tipos de recursos de origem e destino suportados para conectores](reference-sam-connector.md#supported-connector-resource-types).
+ Para obter uma descrição das propriedades que você pode usar com conectores, consulte [AWS::Serverless::Connector](sam-resource-connector.md).
Ao definir um recurso de origem com uma propriedade diferente de `Id`, use a propriedade `SourceReference`.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
:
Type:
...
Connectors:
:
Properties:
SourceReference:
Qualifier:
Destination:
Permissions:
```
Aqui está um exemplo, usando `Qualifier` para restringir o escopo de um recurso do 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
...
```
Aqui está um exemplo, usando uma combinação compatível de `Arn` e `Type` para definir um recurso de destino a partir de outro modelo:
```
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 obter mais informações sobre o uso de conectores, consulte [AWS SAM referência do conector](reference-sam-connector.md).
# Crie vários conectores de uma única fonte no AWS SAM
Em um recurso de origem, você pode definir vários conectores, cada um com um 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 obter mais informações sobre o uso de conectores, consulte [AWS SAM referência do conector](reference-sam-connector.md).
# Crie conectores de vários destinos em AWS SAM
Dentro de um recurso de origem, você pode definir um único conector com vários recursos de destino. Aqui está um exemplo de um recurso de origem de função do Lambda conectado a um bucket do Amazon Simple Storage Service (Amazon S3) e a uma tabela do 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 obter mais informações sobre o uso de conectores, consulte [AWS SAM referência do conector](reference-sam-connector.md).
# Defina atributos de recursos com conectores em AWS SAM
Os atributos dos recursos podem ser definidos para que os recursos especifiquem comportamentos e relacionamentos adicionais. Para saber mais sobre os atributos de recursos, consulte [Referência de atributos de recurso](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-product-attribute-reference.html) no *AWS CloudFormation Guia do usuário*.
Você pode adicionar atributos de recursos ao seu conector incorporado definindo-os no mesmo nível das propriedades do conector. Quando seu AWS SAM modelo for transformado na implantação, os atributos passarão para os recursos gerados.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Connectors:
MyConn:
DeletionPolicy: Retain
DependsOn: AnotherFunction
Properties:
...
```
Para obter mais informações sobre o uso de conectores, consulte [AWS SAM referência do conector](reference-sam-connector.md).
## Saiba mais
Para obter mais informações sobre o uso de AWS SAM conectores, consulte os tópicos a seguir:
+ [AWS::Serverless::Connector](sam-resource-connector.md)
+ [Defina as permissões de leitura e gravação em AWS SAM](connector-usage-define.md)
+ [Defina recursos usando outras propriedades suportadas no AWS SAM](connector-usage-other-properties.md)
+ [Crie vários conectores de uma única fonte no AWS SAM](connector-usage-single-source.md)
+ [Crie conectores de vários destinos em AWS SAM](connector-usage-multi-destination.md)
+ [Defina as permissões de leitura e gravação em AWS SAM](connector-usage-define.md)
+ [Defina atributos de recursos com conectores em AWS SAM](connector-usage-resource-attributes.md)
## Fornecer feedback
Para fornecer feedback sobre conectores, [envie um novo problema](https://github.com/aws/serverless-application-model/issues/new?assignees=&labels=area%2Fconnectors,stage%2Fneeds-triage&template=other.md&title=%28Feature%20Request%29) no *serverless-application-model AWS GitHubrepositório*.
# Modelos de políticas AWS SAM
O AWS Serverless Application Model (AWS SAM) permite que você escolha em uma lista de modelos de política para definir o escopo das permissões de suas funções e máquinas de AWS Step Functions estado do Lambda para os recursos que são usados pelo seu aplicativo.
AWS SAM os aplicativos do AWS Serverless Application Repository que usam modelos de política não exigem nenhum reconhecimento especial do cliente para implantar o aplicativo a partir do. AWS Serverless Application Repository
Se deseja solicitar um novo modelo de política a ser adicionado, faça o seguinte:
1. Envie uma pull request no arquivo de origem policy\$1templates.json na ramificação do projeto. `develop` AWS SAM GitHub Você pode encontrar o arquivo de origem em [policy\$1templates.json](https://github.com/aws/serverless-application-model/blob/develop/samtranslator/policy_templates_data/policy_templates.json) no site. GitHub
1. Envie um problema no AWS SAM GitHub projeto que inclua os motivos da sua pull request e um link para a solicitação. Use este link para enviar um novo problema: [AWS Serverless Application Model: Problemas](https://github.com/aws/serverless-application-model/issues/new).
## Sintaxe
Para cada modelo de política que você especificar em seu arquivo AWS SAM de modelo, você deve sempre especificar um objeto contendo os valores de espaço reservado do modelo de política. Se um modelo de política não exigir nenhum valor de espaço reservado, você deverá especificar um objeto vazio.
### YAML
```
MyFunction:
Type: AWS::Serverless::Function
Properties:
Policies:
- PolicyTemplateName1: # Policy template with placeholder value
Key1: Value1
- PolicyTemplateName2: {} # Policy template with no placeholder value
```
**nota**
Se você configurou uma política do IAM regular ou gerenciou políticas por meio do Lambda, o modelo de política pode ser definido sem usar um objeto vazio.
## Exemplos
### Exemplo 1: modelo de política com valores de espaços reservados
O exemplo a seguir mostra que o modelo de política [SQSPollerPolicy](serverless-policy-template-list.md#sqs-poller-policy) espera um `QueueName` como recurso. O AWS SAM modelo recupera o nome da fila "`MyQueue`" do Amazon SQS, que você pode criar no mesmo aplicativo ou solicitada como um parâmetro para o aplicativo.
```
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
```
### Exemplo 2: modelo de política sem valores sem valores de espaço reservado
O exemplo a seguir contém o modelo de política [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy), que não tem valores de espaços reservados.
**nota**
Mesmo que não haja valores de espaço reservado, você deve especificar um objeto vazio, caso contrário, ocorrerá um erro.
```
1. MyFunction:
2. Type: 'AWS::Serverless::Function'
3. Properties:
4. CodeUri: ${codeuri}
5. Handler: hello.handler
6. Runtime: python2.7
7. Policies:
8. - CloudWatchPutMetricPolicy: {}
```
### Exemplo 3: modelo de política com valores de espaços reservados e uma política do IAM regular
O exemplo a seguir contém a política e [DynamoDBCrudPolicy](serverless-policy-template-list.md#dynamo-db-crud-policy) o modelo de política do Amazon SQSFull Access. A política do Amazon SQSFull Access é uma política do IAM e não uma AWS SAM política, então você não precisa especificar um objeto vazio, pois a política seria passada diretamente para CloudFormation o.
```
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
```
## Tabela de modelos de política
Veja a seguir uma tabela dos modelos de política disponíveis.
****
| Modelo de política | Description |
| --- | --- |
| [AcmGetCertificatePolicy](serverless-policy-template-list.md#acm-get-certificate-policy) | Dá permissão para ler um certificado de AWS Certificate Manager. |
| [AMIDescribePolicy](serverless-policy-template-list.md#ami-describe-policy) | Dá permissão para descrever Amazon Machine Images (AMIs). |
| [AthenaQueryPolicy](serverless-policy-template-list.md#athena-query-policy) | Concede permissões para executar consultas do Athena. |
| [AWSSecretsManagerGetSecretValuePolicy](serverless-policy-template-list.md#secrets-manager-get-secret-value-policy) | Concede permissão para obter o valor secreto do segredo AWS Secrets Manager especificado. |
| [AWSSecretsManagerRotationPolicy](serverless-policy-template-list.md#secrets-manager-rotation-policy) | Permite a entrada de um segredo no AWS Secrets Manager. |
| [CloudFormationDescribeStacksPolicy](serverless-policy-template-list.md#cloud-formation-describe-stacks-policy) | Dá permissão para descrever CloudFormation pilhas. |
| [CloudWatchDashboardPolicy](serverless-policy-template-list.md#cloudwatch-dashboard-policy) | Concede permissões para colocar métricas em operação em CloudWatch painéis. |
| [CloudWatchDescribeAlarmHistoryPolicy](serverless-policy-template-list.md#cloudwatch-describe-alarm-history-policy) | Permite descrever o histórico CloudWatch de alarmes. |
| [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy) | Dá permissão para enviar métricas para CloudWatch o. |
| [CodeCommitCrudPolicy](serverless-policy-template-list.md#codecommit-crud-policy) | Concede permissões a create/read/update/delete objetos em um CodeCommit repositório específico. |
| [CodeCommitReadPolicy](serverless-policy-template-list.md#codecommit-read-policy) | Concede permissões para ler objetos em um CodeCommit repositório específico. |
| [CodePipelineLambdaExecutionPolicy](serverless-policy-template-list.md#code-pipeline-lambda-execution-policy) | Permite que uma função Lambda invocada por relate CodePipeline o status do trabalho. |
| [CodePipelineReadOnlyPolicy](serverless-policy-template-list.md#code-pipeline-readonly-policy) | Dá permissão de leitura para obter detalhes sobre um CodePipeline funil. |
| [ComprehendBasicAccessPolicy](serverless-policy-template-list.md#comprehend-basic-access-policy) | Concede permissão para a detecção de entidades, frases-chave, idiomas e sentimentos. |
| [CostExplorerReadOnlyPolicy](serverless-policy-template-list.md#cost-explorer-readonly-policy) | Fornece permissão somente de leitura ao Cost APIs Explorer somente para leitura para o histórico de faturamento. |
| [DynamoDBBackupFullAccessPolicy](serverless-policy-template-list.md#ddb-back-full-policy) | Concede permissão de leitura e gravação aos backups do DynamoDB sob demanda para uma tabela. |
| [DynamoDBCrudPolicy](serverless-policy-template-list.md#dynamo-db-crud-policy) | Concede permissões de criação, leitura, atualização e exclusão a uma tabela do Amazon DynamoDB. |
| [DynamoDBReadPolicy](serverless-policy-template-list.md#dynamo-db-read-policy) | Concede permissão somente leitura para uma tabela do DynamoDB. |
| [DynamoDBReconfigurePolicy](serverless-policy-template-list.md#dynamo-db-reconfigure-policy) | Concede permissão para reconfigurar uma tabela do DynamoDB. |
| [DynamoDBRestoreFromBackupPolicy](serverless-policy-template-list.md#ddb-restore-from-backup-policy) | Concede permissão para restaurar uma tabela do DynamoDB do backup. |
| [DynamoDBStreamReadPolicy](serverless-policy-template-list.md#dynamo-db-stream-read-policy) | Concede permissão para descrever e ler streams e registros do DynamoDB. |
| [DynamoDBWritePolicy](serverless-policy-template-list.md#dynamo-db-write-policy) | Concede permissão somente gravação a uma tabela do DynamoDB. |
| [EC2CopyImagePolicy](serverless-policy-template-list.md#ec2-copy-image-policy) | Concede permissão para copiar imagens do Amazon EC2. |
| [EC2DescribePolicy](serverless-policy-template-list.md#ec2-describe-policy) | Concede permissão para descrever instâncias do Amazon Elastic Compute Cloud (Amazon EC2). |
| [EcsRunTaskPolicy](serverless-policy-template-list.md#ecs-run-task-policy) | Concede permissão para iniciar uma nova tarefa para uma definição de tarefa. |
| [EFSWriteAccessPolicy](serverless-policy-template-list.md#efs-write-access-policy) | Concede permissão para montar um sistema de arquivos do Amazon EFS com acesso de gravação. |
| [EKSDescribePolicy](serverless-policy-template-list.md#eks-describe-policy) | Concede permissão para descrever ou listar clusters do Amazon EKS. |
| [ElasticMapReduceAddJobFlowStepsPolicy](serverless-policy-template-list.md#elastic-map-reduce-add-job-flows-policy) | Concede permissão para adicionar novas etapas a um cluster em execução. |
| [ElasticMapReduceCancelStepsPolicy](serverless-policy-template-list.md#elastic-map-reduce-cancel-steps-policy) | Concede permissão para cancelar uma etapa ou etapas pendentes em um cluster em execução. |
| [ElasticMapReduceModifyInstanceFleetPolicy](serverless-policy-template-list.md#elastic-map-reduce-modify-instance-fleet-policy) | Concede permissão para listar detalhes e modificar capacidades para frotas de instâncias em um cluster. |
| [ElasticMapReduceModifyInstanceGroupsPolicy](serverless-policy-template-list.md#elastic-map-reduce-modify-instance-groups-policy) | Concede permissão para listar detalhes e modificar configurações para grupos de instâncias em um cluster. |
| [ElasticMapReduceSetTerminationProtectionPolicy](serverless-policy-template-list.md#elastic-map-reduce-set-termination-protection-policy) | Concede permissão para definir a proteção contra encerramento para um cluster. |
| [ElasticMapReduceTerminateJobFlowsPolicy](serverless-policy-template-list.md#elastic-map-reduce-terminate-job-flows-policy) | Concede permissão para encerrar um cluster. |
| [ElasticsearchHttpPostPolicy](serverless-policy-template-list.md#elastic-search-http-post-policy) | Concede permissão POST ao Amazon OpenSearch Service. |
| [EventBridgePutEventsPolicy](serverless-policy-template-list.md#eventbridge-put-events-policy) | Concede permissões para enviar eventos para EventBridge o. |
| [FilterLogEventsPolicy](serverless-policy-template-list.md#filter-log-events-policy) | Permite filtrar eventos de CloudWatch registros de um grupo de registros especificado. |
| [FirehoseCrudPolicy](serverless-policy-template-list.md#firehose-crud-policy) | Concede permissão para criar, gravar, atualizar e excluir um fluxo de entrega do Firehose. |
| [FirehoseWritePolicy](serverless-policy-template-list.md#firehose-write-policy) | Concede permissão para gravar em um fluxo de entrega do Firehose. |
| [KinesisCrudPolicy](serverless-policy-template-list.md#kinesis-crud-policy) | Concede permissão para criar, publicar e excluir um Amazon Kinesis Stream. |
| [KinesisStreamReadPolicy](serverless-policy-template-list.md#kinesis-stream-read-policy) | Concede permissão para listar e ler um Amazon Kinesis Stream. |
| [KMSDecryptPolicy](serverless-policy-template-list.md#kms-decrypt-policy) | Dá permissão para descriptografar com uma chave AWS Key Management Service ()AWS KMS. |
| [KMSEncryptPolicy](serverless-policy-template-list.md#kms-encrypt-policy) | Dá permissão para criptografar com uma chave AWS Key Management Service (AWS KMS). |
| [LambdaInvokePolicy](serverless-policy-template-list.md#lambda-invoke-policy) | Permite invocar uma AWS Lambda função, alias ou versão. |
| [MobileAnalyticsWriteOnlyAccessPolicy](serverless-policy-template-list.md#mobile-analytics-write-only-access-policy) | Concede permissão somente gravação para colocar dados de eventos para todos os recursos de aplicativos. |
| [OrganizationsListAccountsPolicy](serverless-policy-template-list.md#organizations-list-accounts-policy) | Concede permissão somente para leitura para listar nomes de contas infantis e. IDs |
| [PinpointEndpointAccessPolicy](serverless-policy-template-list.md#pinpoint-endpoint-access-policy) | Concede permissão para obter e atualizar endpoints para um aplicativo Amazon Pinpoint. |
| [PollyFullAccessPolicy](serverless-policy-template-list.md#polly-full-access-policy) | Concede permissão de acesso total aos recursos de léxico do Amazon Polly. |
| [RekognitionDetectOnlyPolicy](serverless-policy-template-list.md#rekognition-detect-only-policy) | Concede permissão para detectar faces, rótulos e texto. |
| [RekognitionFacesManagementPolicy](serverless-policy-template-list.md#rekognition-face-management-policy) | Concede permissão para adicionar, excluir e pesquisar faces em uma coleção do Amazon Rekognition. |
| [RekognitionFacesPolicy](serverless-policy-template-list.md#rekognition-faces-policy) | Concede permissão para comparar e detectar faces e rótulos. |
| [RekognitionLabelsPolicy](serverless-policy-template-list.md#rekognition-labels-policy) | Concede permissão para detectar rótulos de objetos e moderação. |
| [RekognitionNoDataAccessPolicy](serverless-policy-template-list.md#rekognition-no-data-access-policy) | Concede permissão para comparar e detectar faces e rótulos. |
| [RekognitionReadPolicy](serverless-policy-template-list.md#rekognition-read-policy) | Concede permissão para listar e pesquisar faces. |
| [RekognitionWriteOnlyAccessPolicy](serverless-policy-template-list.md#rekognition-write-only-access-policy) | Concede permissão para criar faces de coleção e índice. |
| [Route53ChangeResourceRecordSetsPolicy](serverless-policy-template-list.md#route53-change-resource-record-sets-policy) | Concede permissão para alterar conjuntos de registros de recursos no Route 53. |
| [S3CrudPolicy](serverless-policy-template-list.md#s3-crud-policy) | Concede permissão de criação, leitura, atualização e exclusão para atuar nos objetos em um bucket do Amazon S3. |
| [S3FullAccessPolicy](serverless-policy-template-list.md#s3-full-access-policy) | Concede permissão de acesso total para atuar nos objetos em um bucket do Amazon S3. |
| [S3ReadPolicy](serverless-policy-template-list.md#s3-read-policy) | Concede permissão somente leitura para ler objetos em um bucket do Amazon Simple Storage Service (Amazon S3). |
| [S3WritePolicy](serverless-policy-template-list.md#s3-write-policy) | Concede permissão de gravação para gravar objetos em um bucket do Amazon S3. |
| [SageMakerCreateEndpointConfigPolicy](serverless-policy-template-list.md#sagemaker-create-endpoint-config-policy) | Dá permissão para criar uma configuração de endpoint na SageMaker IA. |
| [SageMakerCreateEndpointPolicy](serverless-policy-template-list.md#sagemaker-create-endpoint-policy) | Dá permissão para criar um endpoint na SageMaker IA. |
| [ServerlessRepoReadWriteAccessPolicy](serverless-policy-template-list.md#serverlessrepo-read-write-access-policy) | Dá permissão para criar e listar aplicativos no AWS Serverless Application Repository serviço. |
| [SESBulkTemplatedCrudPolicy](serverless-policy-template-list.md#ses-bulk-templated-crud-policy) | Concede permissão para enviar e-mail, e-mail modelo, e-mail em massa modelo e verificar identidade. |
| [SESBulkTemplatedCrudPolicy\$1v2](serverless-policy-template-list.md#ses-bulk-templated-crud-policy-v2) | Concede permissão para enviar e-mails, e-mails modelados e e-mails em massa modelados para o Amazon SES e para verificar a identidade. |
| [SESCrudPolicy](serverless-policy-template-list.md#ses-crud-policy) | Concede permissão para enviar e-mails e verificar identidades. |
| [SESEmailTemplateCrudPolicy](serverless-policy-template-list.md#ses-email-template-crud-policy) | Concede permissão para criar, obter, listar, atualizar e excluir modelos de e-mail do Amazon SES. |
| [SESSendBouncePolicy](serverless-policy-template-list.md#ses-send-bounce-policy) | Concede SendBounce permissão a uma identidade do Amazon Simple Email Service (Amazon SES). |
| [SNSCrudPolicy](serverless-policy-template-list.md#sns-crud-policy) | Concede permissão para criar, publicar e assinar tópicos do Amazon SNS. |
| [SNSPublishMessagePolicy](serverless-policy-template-list.md#sqs-publish-message-policy) | Concede permissão para publicar mensagens de eventos em um tópico do Amazon Simple Notification Service (Amazon SNS). |
| [SQSPollerPolicy](serverless-policy-template-list.md#sqs-poller-policy) | Concede permissão para pesquisar uma fila do Amazon Simple Queue Service (Amazon SQS). |
| [SQSSendMessagePolicy](serverless-policy-template-list.md#sqs-send-message-policy) | Concede permissão para enviar mensagens para uma fila do Amazon SQS. |
| [SSMParameterReadPolicy](serverless-policy-template-list.md#ssm-parameter-read-policy) | Concede permissão para acessar um parâmetro de um armazenamento de parâmetros do Amazon EC2 Systems Manager (SSM) para carregar segredos nesta conta. Use quando o nome do parâmetro não tiver prefixo de barra. |
| [SSMParameterWithSlashPrefixReadPolicy](serverless-policy-template-list.md#ssm-parameter-slash-read-policy) | Concede permissão para acessar um parâmetro de um armazenamento de parâmetros do Amazon EC2 Systems Manager (SSM) para carregar segredos nessa conta. Use quando o nome do parâmetro tiver prefixo de barra. |
| [StepFunctionsExecutionPolicy](serverless-policy-template-list.md#stepfunctions-execution-policy) | Concede permissão para iniciar a execução de uma máquina de estado do Step Functions. |
| [TextractDetectAnalyzePolicy](serverless-policy-template-list.md#textract-detect-analyze-policy) | Concede acesso para detectar e analisar documentos com Amazon Textract. |
| [TextractGetResultPolicy](serverless-policy-template-list.md#textract-get-result-policy) | Concede acesso para detectar e analisar documentos com o Amazon Textract. |
| [TextractPolicy](serverless-policy-template-list.md#textract-policy) | Concede acesso total ao Amazon Textract. |
| [VPCAccessPolicy](serverless-policy-template-list.md#vpc-access-policy) | Concede acesso para criar, excluir, descrever e desanexar interfaces de rede elásticas. |
## Solução de problemas
### Erro de CLI do SAM: “É necessário especificar valores de parâmetros válidos para o modelo de política policy-template-name '< >'”
Ao executar `sam build`, você verá o seguinte erro:
```
"Must specify valid parameter values for policy template ''"
```
Isso significa que você não passou um objeto vazio ao declarar um modelo de política que não tem nenhum valor de espaço reservado.
Para corrigir isso, declare a política como no exemplo a seguir para [CloudWatchPutMetricPolicy](serverless-policy-template-list.md#cloudwatch-put-metric-policy).
```
1. MyFunction:
2. Policies:
3. - CloudWatchPutMetricPolicy: {}
```
# AWS SAM lista de modelos de políticas
A seguir estão os modelos de política disponíveis, juntamente com as permissões que são aplicadas a cada um. AWS Serverless Application Model (AWS SAM) preenche automaticamente os itens de espaço reservado (como AWS região e ID da conta) com as informações apropriadas.
**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
Dá permissão para ler um certificado de AWS Certificate Manager.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"acm:GetCertificate"
],
"Resource": {
"Fn::Sub": [
"${certificateArn}",
{
"certificateArn": {
"Ref": "CertificateArn"
}
}
]
}
}
]
```
## AMIDescribePolicy
Dá permissão para descrever Amazon Machine Images (AMIs).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeImages"
],
"Resource": "*"
}
]
```
## AthenaQueryPolicy
Concede permissões para executar consultas do 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
Dá permissão para obter o valor secreto do AWS Secrets Manager segredo especificado.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": {
"Fn::Sub": [
"${secretArn}",
{
"secretArn": {
"Ref": "SecretArn"
}
}
]
}
}
]
```
## AWSSecretsManagerRotationPolicy
Permite a entrada de um segredo no 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
Dá permissão para descrever CloudFormation pilhas.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudformation:DescribeStacks"
],
"Resource": {
"Fn::Sub": "arn:${AWS::Partition}:cloudformation:${AWS::Region}:${AWS::AccountId}:stack/*"
}
}
]
```
## CloudWatchDashboardPolicy
Concede permissões para colocar métricas em operação em CloudWatch painéis.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:GetDashboard",
"cloudwatch:ListDashboards",
"cloudwatch:PutDashboard",
"cloudwatch:ListMetrics"
],
"Resource": "*"
}
]
```
## CloudWatchDescribeAlarmHistoryPolicy
Permite descrever o histórico de CloudWatch alarmes da Amazon.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:DescribeAlarmHistory"
],
"Resource": "*"
}
]
```
## CloudWatchPutMetricPolicy
Dá permissão para enviar métricas para CloudWatch o.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricData"
],
"Resource": "*"
}
]
```
## CodePipelineLambdaExecutionPolicy
Permite que uma função Lambda invocada por relate AWS CodePipeline o status do trabalho.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:PutJobSuccessResult",
"codepipeline:PutJobFailureResult"
],
"Resource": "*"
}
]
```
## CodePipelineReadOnlyPolicy
Dá permissão de leitura para obter detalhes sobre um CodePipeline funil.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:ListPipelineExecutions"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:codepipeline:${AWS::Region}:${AWS::AccountId}:${pipelinename}",
{
"pipelinename": {
"Ref": "PipelineName"
}
}
]
}
}
]
```
## CodeCommitCrudPolicy
Concede permissões para criar, ler, atualizar e excluir objetos em um CodeCommit repositório 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
Concede permissões para ler objetos em um CodeCommit repositório 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 permissão para a detecção de entidades, frases-chave, idiomas e sentimentos.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"comprehend:BatchDetectKeyPhrases",
"comprehend:DetectDominantLanguage",
"comprehend:DetectEntities",
"comprehend:BatchDetectEntities",
"comprehend:DetectKeyPhrases",
"comprehend:DetectSentiment",
"comprehend:BatchDetectDominantLanguage",
"comprehend:BatchDetectSentiment"
],
"Resource": "*"
}
]
```
## CostExplorerReadOnlyPolicy
Concede permissão somente de leitura para o histórico de faturamento somente para leitura (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 permissão de leitura e gravação aos backups do DynamoDB sob demanda para uma tabela.
```
"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 permissões de criação, leitura, atualização e exclusão a uma tabela do 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 permissão somente leitura para uma tabela do 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 permissão para reconfigurar uma tabela do 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 permissão para restaurar uma tabela do DynamoDB do backup.
```
"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 permissão para descrever e ler streams e registros do 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 permissão somente gravação a uma tabela do 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
Permite copiar EC2 imagens da Amazon.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CopyImage"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:ec2:${AWS::Region}:${AWS::AccountId}:image/${imageId}",
{
"imageId": {
"Ref": "ImageId"
}
}
]
}
}
]
```
## EC2DescribePolicy
Dá permissão para descrever instâncias do Amazon Elastic Compute Cloud (Amazon EC2).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:DescribeRegions",
"ec2:DescribeInstances"
],
"Resource": "*"
}
]
```
## EcsRunTaskPolicy
Concede permissão para iniciar uma nova tarefa para uma definição de tarefa.
```
"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 permissão para montar um sistema de arquivos do Amazon EFS com acesso de gravação.
```
"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 permissão para descrever ou listar clusters do Amazon Elastic Kubernetes Service (Amazon EKS).
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"eks:DescribeCluster",
"eks:ListClusters"
],
"Resource": "*"
}
]
```
## ElasticMapReduceAddJobFlowStepsPolicy
Concede permissão para adicionar novas etapas a um cluster em execução.
```
"Statement": [
{
"Action": "elasticmapreduce:AddJobFlowSteps",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceCancelStepsPolicy
Concede permissão para cancelar uma etapa ou etapas pendentes em um cluster em execução.
```
"Statement": [
{
"Action": "elasticmapreduce:CancelSteps",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceModifyInstanceFleetPolicy
Concede permissão para listar detalhes e modificar capacidades para frotas de instâncias em um cluster.
```
"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 permissão para listar detalhes e modificar configurações para grupos de instâncias em um cluster.
```
"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 permissão para definir a proteção contra encerramento para um cluster.
```
"Statement": [
{
"Action": "elasticmapreduce:SetTerminationProtection",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticMapReduceTerminateJobFlowsPolicy
Concede permissão para encerrar um cluster.
```
"Statement": [
{
"Action": "elasticmapreduce:TerminateJobFlows",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:elasticmapreduce:${AWS::Region}:${AWS::AccountId}:cluster/${clusterId}",
{
"clusterId": {
"Ref": "ClusterId"
}
}
]
},
"Effect": "Allow"
}
]
```
## ElasticsearchHttpPostPolicy
Concede permissão POST e PUT ao 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
Concede permissões para enviar eventos para 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
Permite filtrar eventos de CloudWatch registros de um grupo de registros especificado.
```
"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 permissão para criar, gravar, atualizar e excluir um fluxo de entrega do 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 permissão para gravar em um fluxo de entrega do 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 permissão para criar, publicar e excluir um Amazon Kinesis Stream.
```
"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 permissão para listar e ler um Amazon Kinesis Stream.
```
"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
Dá permissão para descriptografar com uma chave AWS Key Management Service ()AWS KMS. Observe que `keyId` deve ser um ID de AWS KMS chave e não um alias de chave.
```
"Statement": [
{
"Action": "kms:Decrypt",
"Effect": "Allow",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kms:${AWS::Region}:${AWS::AccountId}:key/${keyId}",
{
"keyId": {
"Ref": "KeyId"
}
}
]
}
}
]
```
## KMSEncryptPolicy
Dá permissão para criptografar com uma AWS KMS chave. Observe que keyID deve ser um ID de AWS KMS chave e não um alias de chave.
```
"Statement": [
{
"Action": "kms:Encrypt",
"Effect": "Allow",
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:kms:${AWS::Region}:${AWS::AccountId}:key/${keyId}",
{
"keyId": {
"Ref": "KeyId"
}
}
]
}
}
]
```
## LambdaInvokePolicy
Permite invocar uma AWS Lambda função, alias ou versão.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:lambda:${AWS::Region}:${AWS::AccountId}:function:${functionName}*",
{
"functionName": {
"Ref": "FunctionName"
}
}
]
}
}
]
```
## MobileAnalyticsWriteOnlyAccessPolicy
Concede permissão somente gravação para colocar dados de eventos para todos os recursos de aplicativos.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"mobileanalytics:PutEvents"
],
"Resource": "*"
}
]
```
## OrganizationsListAccountsPolicy
Concede permissão somente para leitura para listar nomes de contas infantis e. IDs
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"organizations:ListAccounts"
],
"Resource": "*"
}
]
```
## PinpointEndpointAccessPolicy
Concede permissão para obter e atualizar endpoints para um aplicativo 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 permissão de acesso total aos recursos de léxico do 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 permissão para detectar faces, rótulos e texto.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:DetectFaces",
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels",
"rekognition:DetectText"
],
"Resource": "*"
}
]
```
## RekognitionFacesManagementPolicy
Concede permissão para adicionar, excluir e pesquisar faces em uma coleção do 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 permissão para comparar e detectar faces e rótulos.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:CompareFaces",
"rekognition:DetectFaces"
],
"Resource": "*"
}
]
```
## RekognitionLabelsPolicy
Concede permissão para detectar rótulos de objetos e moderação.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"rekognition:DetectLabels",
"rekognition:DetectModerationLabels"
],
"Resource": "*"
}
]
```
## RekognitionNoDataAccessPolicy
Concede permissão para comparar e detectar faces e rótulos.
```
"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 permissão para listar e pesquisar faces.
```
"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 permissão para criar faces de coleção e índice.
```
"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 permissão para alterar conjuntos de registros de recursos no Route 53.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"route53:ChangeResourceRecordSets"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:route53:::hostedzone/${HostedZoneId}",
{
"HostedZoneId": {
"Ref": "HostedZoneId"
}
}
]
}
}
]
```
## S3CrudPolicy
Concede permissão de criação, leitura, atualização e exclusão para atuar nos objetos em um bucket do 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 permissão de acesso total para atuar nos objetos em um bucket do 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 permissão somente leitura para ler objetos em um bucket do 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 permissão de gravação para gravar objetos em um bucket do 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
Dá permissão para criar uma configuração de endpoint na SageMaker IA.
```
"Statement": [
{
"Action": [
"sagemaker:CreateEndpointConfig"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sagemaker:${AWS::Region}:${AWS::AccountId}:endpoint-config/${endpointConfigName}",
{
"endpointConfigName": {
"Ref": "EndpointConfigName"
}
}
]
},
"Effect": "Allow"
}
]
```
## SageMakerCreateEndpointPolicy
Dá permissão para criar um endpoint na 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
Dá permissão para criar e listar aplicativos no serviço 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 permissão para enviar e-mails, e-mails modelados e e-mails em massa modelados para o Amazon SES e para verificar a identidade.
**nota**
A ação `ses:SendTemplatedEmail` requer um modelo de ARN. Use `SESBulkTemplatedCrudPolicy_v2` em vez disso.
```
"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 permissão para enviar e-mails, e-mails modelados e e-mails em massa modelados para o Amazon SES e para verificar a identidade.
```
"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 permissão para enviar e-mails e verificar identidades.
```
"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 permissão para criar, obter, listar, atualizar e excluir modelos de e-mail do Amazon SES.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ses:CreateTemplate",
"ses:GetTemplate",
"ses:ListTemplates",
"ses:UpdateTemplate",
"ses:DeleteTemplate",
"ses:TestRenderTemplate"
],
"Resource": "*"
}
]
```
## SESSendBouncePolicy
Concede SendBounce permissão a uma identidade do 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 permissão para criar, publicar e assinar tópicos do 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 permissão para publicar mensagens de eventos em um tópico do 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 permissão para pesquisar uma fila do 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 permissão para enviar mensagens para uma fila do Amazon SQS.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"sqs:SendMessage*"
],
"Resource": {
"Fn::Sub": [
"arn:${AWS::Partition}:sqs:${AWS::Region}:${AWS::AccountId}:${queueName}",
{
"queueName": {
"Ref": "QueueName"
}
}
]
}
}
]
```
## SSMParameterReadPolicy
Permite acessar um parâmetro de um armazenamento de parâmetros do Amazon EC2 Systems Manager (SSM) para carregar segredos nessa conta. Use quando o nome do parâmetro não tiver prefixo de barra.
**nota**
Se você não estiver usando a chave padrão, também precisará da política de `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
Permite acessar um parâmetro de um armazenamento de parâmetros do Amazon EC2 Systems Manager (SSM) para carregar segredos nessa conta. Use quando o nome do parâmetro tiver prefixo de barra.
**nota**
Se você não estiver usando a chave padrão, também precisará da política de `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 permissão para iniciar a execução de uma máquina de estado do 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 acesso para detectar e analisar documentos com Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:DetectDocumentText",
"textract:StartDocumentTextDetection",
"textract:StartDocumentAnalysis",
"textract:AnalyzeDocument"
],
"Resource": "*"
}
]
```
## TextractGetResultPolicy
Concede acesso para detectar e analisar documentos com o Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:GetDocumentTextDetection",
"textract:GetDocumentAnalysis"
],
"Resource": "*"
}
]
```
## TextractPolicy
Concede acesso total ao Amazon Textract.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"textract:*"
],
"Resource": "*"
}
]
```
## VPCAccessPolicy
Concede acesso para criar, excluir, descrever e desanexar interfaces de rede elásticas.
```
"Statement": [
{
"Effect": "Allow",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:DeleteNetworkInterface",
"ec2:DescribeNetworkInterfaces",
"ec2:DetachNetworkInterface"
],
"Resource": "*"
}
]
```
# Gerenciando AWS SAM permissões com CloudFormation mecanismos
Para controlar o acesso aos AWS recursos, o AWS Serverless Application Model (AWS SAM) pode usar os mesmos mecanismos que CloudFormation. Para obter mais informações, consulte [Controlar o acesso com o AWS Identity and Access Management](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) no *Guia do usuário do AWS CloudFormation *.
Há três opções principais para conceder permissão ao usuário para gerenciar aplicativos sem servidor. Cada opção fornece aos usuários diferentes níveis de controle de acesso.
+ Conceder permissões de administrador.
+ Anexe as políticas AWS gerenciadas necessárias.
+ Conceda permissões específicas AWS Identity and Access Management (IAM).
Dependendo da opção escolhida, os usuários podem gerenciar somente aplicativos sem servidor que contenham AWS recursos que eles tenham permissão para acessar.
As seções a seguir descrevem essa opção em mais detalhes.
## Conceder permissões de administrador
Se você conceder permissões de administrador a um usuário, ele poderá gerenciar aplicativos sem servidor que contenham qualquer combinação de AWS recursos. Essa é a opção mais simples, mas também concede aos usuários o conjunto mais amplo de permissões, o que lhes permite realizar ações com o maior impacto.
Para obter mais informações sobre como conceder permissões de administrador a um usuário, consulte [Criar seu primeiro usuário e grupo administrador do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) no *Guia do usuário do IAM*.
## Anexe as políticas AWS gerenciadas necessárias
Você pode conceder aos usuários um subconjunto de permissões usando as [políticas gerenciadas pela AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies), em vez de conceder permissões completas de administrador. Se você usar essa opção, verifique se o conjunto de políticas AWS gerenciadas abrange todas as ações e recursos necessários para os aplicativos sem servidor que os usuários gerenciam.
Por exemplo, as seguintes políticas AWS gerenciadas são suficientes para [implantar o aplicativo Hello World de amostra](serverless-getting-started-hello-world.md):
+ AWSCloudFormationFullAccess
+ IAMFullAcesso
+ AWSLambda\$1FullAccess
+ APIGatewayAdministrador da Amazon
+ Amazon S3 FullAccess
+ Amazon EC2 ContainerRegistryFullAccess
Para obter informações sobre como anexar políticas a um usuário do IAM, consulte [Alterar permissões para um usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html) no *Guia do usuário do IAM*.
## Conceda permissões específicas do IAM
Para obter o nível mais granular de controle de acesso, você pode conceder permissões específicas do IAM aos usuários usando [declarações de política](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_statement.html). Se você usar essa opção, certifique-se de que a declaração de política inclua todas as ações e recursos necessários para os aplicativos sem servidor que os usuários gerenciam.
A melhor prática com essa opção é negar aos usuários a permissão para criar funções, incluindo funções de execução do Lambda, para que eles não possam conceder a si mesmos permissões escalonadas. Portanto, você, como administrador, deve primeiro criar uma [função de execução do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) que será especificada nos aplicativos sem servidor que os usuários gerenciarão. Para obter informações sobre a criação de funções de execução do Lambda, consulte [Criação de uma função de execução no console do IAM](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html#permissions-executionrole-console).
Para o [aplicativo Hello World de amostra](serverless-getting-started-hello-world.md), **AWSLambdaBasicExecutionRole**é suficiente para executar o aplicativo. Depois de criar uma função de execução do Lambda, modifique o arquivo de AWS SAM modelo do aplicativo Hello World de amostra para adicionar a seguinte propriedade ao `AWS::Serverless::Function` recurso:
```
Role: lambda-execution-role-arn
```
Com o aplicativo Hello World modificado em vigor, a declaração de política a seguir concede permissões suficientes para que os usuários implantem, atualizem e excluam o aplicativo:
**nota**
O exemplo de declaração de política nesta seção concede permissão suficiente para você implantar, atualizar e excluir a [amostra do aplicativo Hello World](serverless-getting-started-hello-world.md). Se você adicionar outros tipos de recursos ao seu aplicativo, precisará atualizar a declaração de política para incluir o seguinte:
Permissão para que seu aplicativo chame as ações do serviço.
O diretor do serviço, se necessário para as ações do serviço.
Por exemplo, se você adicionar um fluxo de trabalho do Step Functions, talvez seja necessário adicionar permissões para as ações listadas [aqui](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsstepfunctions.html#awsstepfunctions-actions-as-permissions) e para o responsável pelo serviço principal`states.amazonaws.com`.
Para obter mais informações sobre o gerenciamento de políticas, consulte [Gerenciar políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html) no *Guia do usuário do IAM*.