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á. # Defina sua infraestrutura com AWS SAM Agora que você criou seu projeto, você está pronto para definir sua infraestrutura de aplicativos com AWS SAM. Faça isso configurando seu AWS SAM modelo para definir os recursos e propriedades do seu aplicativo, que é o `template.yaml` arquivo em seu AWS SAM projeto. Os tópicos desta seção fornecem conteúdo sobre como definir sua infraestrutura em seu AWS SAM modelo (seu `template.yaml` arquivo). Ele também contém tópicos sobre a definição de recursos para casos de uso específicos, como trabalhar com camadas Lambda, usar aplicativos aninhados, controlar o acesso ao API Gateway APIs, orquestrar recursos com AWS Step Functions, assinar códigos em seus aplicativos e validar seu modelo. AWS SAM **Topics** + [Defina os recursos do aplicativo em seu AWS SAM modelo](authoring-define-resources.md) + [Configure e gerencie o acesso a recursos em seu AWS SAM modelo](sam-permissions.md) + [Controle o acesso à API com seu AWS SAM modelo](serverless-controlling-access-to-apis.md) + [Aumente a eficiência usando camadas Lambda com AWS SAM](serverless-sam-cli-layers.md) + [Reutilize código e recursos usando aplicativos aninhados no AWS SAM](serverless-sam-template-nested-applications.md) + [Gerencie eventos baseados em tempo com o EventBridge Scheduler em AWS SAM](using-eventbridge-scheduler.md) + [Orquestrando recursos com AWS SAM AWS Step Functions](serverless-step-functions-in-sam.md) + [Configure a assinatura de código para seu AWS SAM aplicativo](authoring-codesigning.md) + [Validar arquivos AWS SAM de modelo](serverless-sam-cli-using-validate.md) # Defina os recursos do aplicativo em seu AWS SAM modelo Você define os AWS recursos que seu aplicativo sem servidor usa na `Resources` seção do seu AWS SAM modelo. Ao definir um recurso, você identifica o que é o recurso, como ele interage com outros recursos e como ele pode ser acessado (ou seja, as permissões do recurso). A `Resources` seção do seu AWS SAM modelo pode conter uma combinação de CloudFormation recursos e AWS SAM recursos. Além disso, você pode usar AWS SAM a sintaxe abreviada para os seguintes recursos: | AWS SAM sintaxe abreviada | O que ele faz com um AWS recurso relacionado | | --- | --- | | [AWS::Serverless::Api](sam-resource-api.md) | Cria uma coleção de recursos e métodos do API Gateway que podem ser invocados por meio de endpoints HTTPS. | | [AWS::Serverless::Application](sam-resource-application.md) | Incorpora um aplicativo com tecnologia sem servidor de [AWS Serverless Application Repository](https://serverlessrepo.aws.amazon.com/applications) ou de um bucket do Amazon S3 como um aplicativo aninhado. | | [AWS::Serverless::Connector](sam-resource-connector.md) | Configura as permissões entre dois recursos. Para obter uma introdução aos conectores, consulte [Gerenciando permissões de recursos com AWS SAM conectores](managing-permissions-connectors.md). | | [AWS::Serverless::Function](sam-resource-function.md) | Cria uma AWS Lambda função, uma função de execução AWS Identity and Access Management (IAM) e mapeamentos de origem de eventos que acionam a função. | | [AWS::Serverless::GraphQLApi](sam-resource-graphqlapi.md) | cria e configura uma AWS AppSync GraphQL API para seu aplicativo sem servidor. | | [AWS::Serverless::HttpApi](sam-resource-httpapi.md) | Cria uma API HTTP do Amazon API Gateway, que permite criar RESTful APIs com menor latência e custos mais baixos do que o REST APIs. | | [AWS::Serverless::LayerVersion](sam-resource-layerversion.md) | Cria um Lambda LayerVersion que contém a biblioteca ou o código de tempo de execução necessário para uma função Lambda. | | [AWS::Serverless::SimpleTable](sam-resource-simpletable.md) | Cria uma tabela do DynamoDB com uma chave primária de atributo único. | | [AWS::Serverless::StateMachine](sam-resource-statemachine.md) | Cria uma máquina de AWS Step Functions estado, que você pode usar para orquestrar AWS Lambda funções e outros AWS recursos para formar fluxos de trabalho complexos e robustos. | Os recursos acima também estão listados em [AWS SAM recursos e propriedades](sam-specification-resources-and-properties.md). Para obter informações de referência sobre todos os tipos de AWS recursos e propriedades CloudFormation e AWS SAM suporte, consulte a [referência de tipos de AWS recursos e propriedades](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html) no *Guia AWS CloudFormation do usuário*. # 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*. # Controle o acesso à API com seu AWS SAM modelo O controle do acesso ao seu API Gateway APIs ajuda a garantir que seu aplicativo sem servidor esteja seguro e só possa ser acessado por meio da autorização que você habilita. Você pode ativar a autorização em seu AWS SAM modelo para controlar quem pode acessar seu API Gateway APIs. AWS SAM suporta vários mecanismos para controlar o acesso ao seu API Gateway APIs. O conjunto de mecanismos suportados difere entre os tipos de recursos `AWS::Serverless::HttpApi` e `AWS::Serverless::Api`. A tabela a seguir resume os mecanismos suportados por cada tipo de recurso. | Mecanismos para controlar o acesso | AWS::Serverless::HttpApi | AWS::Serverless::Api | | --- | --- | --- | | Autorizadores do Lambda | ✓ | ✓ | | Permissões do IAM | | ✓ | | Grupos de usuários do Amazon Cognito | ✓ \$1 | ✓ | | Chaves de API | | ✓ | | Políticas de recursos | | ✓ | | OAuth 2.0/Autorizadores JWT | ✓ | | \$1 O Amazon Cognito pode ser usado como emissor do JSON Web Token (JWT) com o tipo de recurso `AWS::Serverless::HttpApi`. + **Autorizadores do Lambda** – Um autorizador do Lambda (anteriormente conhecido como *autorizador personalizado*) é uma função do Lambda que você fornece para controlar o acesso à sua API. Quando sua API é chamada, essa função do Lambda é invocada com um contexto de solicitação ou um token de autorização fornecido pelo aplicativo cliente. A função do Lambda responde se o chamador está autorizado a realizar a operação solicitada. Tanto o tipo `AWS::Serverless::HttpApi` quanto o tipo `AWS::Serverless::Api` de recurso oferecem suporte aos autorizadores Lambda. Para obter mais informações sobre autorizadores Lambda com`AWS::Serverless::HttpApi`, consulte Como [trabalhar com AWS Lambda autorizadores para HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-lambda-authorizer.html) no Guia do desenvolvedor do APIs *API* Gateway. Para obter mais informações sobre autorizadores do Lambda com `AWS::Serverless::Api`, consulte [Usar os autorizadores do Lambda do API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) no *Guida do desenvolvedor do API Gateway*. Para obter exemplos de autorizadores Lambda para qualquer tipo de recurso, consulte [Exemplos de autorizadores Lambda para AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md). + **Permissões do IAM** — Você pode controlar quem pode invocar sua API usando [as permissões AWS Identity and Access Management (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_controlling.html). Os usuários que chamam sua API devem ser autenticados com as credenciais do IAM. As chamadas para sua API são bem-sucedidas somente se houver uma política do IAM anexada ao usuário do IAM que representa o chamador da API, um grupo do IAM que contém o usuário ou um perfil do IAM que o usuário assume. Somente o tipo `AWS::Serverless::Api` de recurso é compatível com permissões do IAM. Para mais informações [Controlar o acesso a uma API com permissões do IAM](https://docs.aws.amazon.com/apigateway/latest/developerguide/permissions.html) no *Guia do desenvolvedor do API Gateway*. Para ver um exemplo, consulte [Exemplo de permissão do IAM para AWS SAM](serverless-controlling-access-to-apis-permissions.md). + Grupos de usuários do **Amazon Cognito — Os grupos de usuários do** Amazon Cognito são diretórios de usuários no Amazon Cognito. Um cliente da sua API deve primeiro inscrever um usuário no grupo de usuários e obter uma identidade ou token de acesso para o usuário. Em seguida, o cliente chama sua API com um dos tokens retornados. A chamada da API será bem-sucedida somente se o token necessário for válido. O tipo `AWS::Serverless::Api` de recurso é compatível com grupos de usuários do Amazon Cognito. O tipo `AWS::Serverless::HttpApi` de recurso aceita o uso do Amazon Cognito como emissor do JWT. Para mais informações, consulte [Controlar o acesso a uma API REST usando um grupo de usuários do Amazon Cognito como autorizador](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) no *Guia do desenvolvedor do API Gateway*. Para ver um exemplo, consulte [Exemplo de grupo de usuários do Amazon Cognito para AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md). + **Chaves de API** – As chaves de API são valores de strings alfanuméricas distribuídas para clientes de desenvolvedores de aplicativos para conceder acesso à API. Somente o tipo `AWS::Serverless::Api` de recurso é compatível com chaves de API. Para obter mais informações, consulte [Criação e uso de planos de uso com chaves de API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) no *Guia do desenvolvedor do API Gateway*. Para ver um exemplo de chaves de API, consulte [Exemplo de chave de API para AWS SAM](serverless-controlling-access-to-apis-keys.md). + **Políticas de recurso** — Políticas de recurso são documentos de políticas JSON que você pode anexar a uma API do API Gateway. Use políticas de recursos para controlar se um principal especificado (normalmente um usuário ou perfil do IAM) pode invocar a API. Somente o tipo de `AWS::Serverless::Api` recurso suporta políticas de recursos como um mecanismo para controlar o acesso ao API Gateway APIs. Para obter mais informações sobre políticas de recursos, consulte Como [controlar o acesso a uma API com as políticas de recursos do API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) no *Guia do desenvolvedor do API Gateway*. Para obter exemplos de políticas de recursos, consulte [Exemplo de política de recursos para AWS SAM](serverless-controlling-access-to-apis-resource-policies.md). + **OAuth Autorizadores 2.0/JWT** [— Você pode usar JWTs como parte das estruturas OpenID [Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) e OAuth 2.0 para controlar o acesso ao seu.](https://oauth.net/2/) APIs O API Gateway valida o JWTs que os clientes enviam com solicitações de API e permite ou nega solicitações com base na validação do token e, opcionalmente, nos escopos do token. Somente o tipo de `AWS::Serverless::HttpApi` recurso é compatível com autorizadores OAuth 2.0/JWT. Para obter mais informações, consulte [Controle do acesso ao HTTP APIs com autorizadores JWT](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) no Guia do *desenvolvedor do API Gateway*. Para ver um exemplo, consulte [OAuth Exemplo de autorizador 2.0/JWT para AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md). ## Escolher um mecanismo para controlar o acesso O mecanismo que você escolhe usar para controlar o acesso ao seu API Gateway APIs depende de alguns fatores. Por exemplo, se você tem um projeto novo sem autorização ou controle de acesso configurado, os grupos de usuários do Amazon Cognito podem ser sua melhor opção. Isso ocorre porque, ao configurar grupos de usuários, você também configura automaticamente a autenticação e o controle de acesso. No entanto, se seu aplicativo já tiver a autenticação configurada, usar autorizadores Lambda pode ser sua melhor opção. Isso ocorre porque você pode chamar seu serviço de autenticação existente e retornar um documento de política com base na resposta. Além disso, se seu aplicativo exigir autenticação personalizada ou lógica de controle de acesso que os grupos de usuários não suportam, os autorizadores Lambda podem ser sua melhor opção. Depois de escolher qual mecanismo usar, consulte a seção correspondente [Exemplos](#serverless-controlling-access-to-apis-examples) para saber como usar AWS SAM para configurar seu aplicativo para usar esse mecanismo. ## Como personalizar respostas de erro Você pode usar AWS SAM para personalizar o conteúdo de algumas respostas de erro do API Gateway. Somente o tipo `AWS::Serverless::Api` de recurso é compatível com respostas personalizadas do API Gateway. Para obter mais informações sobre as respostas do API Gateway, consulte [Respostas do gateway no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) no *Guia do desenvolvedor do API Gateway*. Para obter um exemplo de respostas personalizadas, consulte [Exemplo de resposta personalizada para AWS SAM](serverless-controlling-access-to-apis-customize-response.md). ## Exemplos + [Exemplos de autorizadores Lambda para AWS SAM](serverless-controlling-access-to-apis-lambda-authorizer.md) + [Exemplo de permissão do IAM para AWS SAM](serverless-controlling-access-to-apis-permissions.md) + [Exemplo de grupo de usuários do Amazon Cognito para AWS SAM](serverless-controlling-access-to-apis-cognito-user-pool.md) + [Exemplo de chave de API para AWS SAM](serverless-controlling-access-to-apis-keys.md) + [Exemplo de política de recursos para AWS SAM](serverless-controlling-access-to-apis-resource-policies.md) + [OAuth Exemplo de autorizador 2.0/JWT para AWS SAM](serverless-controlling-access-to-apis-oauth2-authorizer.md) + [Exemplo de resposta personalizada para AWS SAM](serverless-controlling-access-to-apis-customize-response.md) # Exemplos de autorizadores Lambda para AWS SAM O tipo `AWS::Serverless::Api` de recurso oferece suporte a dois tipos de autorizadores Lambda: autorizadores e `TOKEN` autorizadores `REQUEST`. O tipo de recurso `AWS::Serverless::HttpApi` suporta somente autorizadores `REQUEST`. Veja a seguir exemplos de cada parâmetro. ## Exemplo de `TOKEN` autorizador Lambda (AWS::Serverless::Api) Você pode controlar o acesso ao seu APIs definindo um `TOKEN` autorizador Lambda em seu modelo. AWS SAM Para fazer isso, você usa o tipo de [ApiAuth](sam-property-api-apiauth.md) dados. Veja a seguir um exemplo de seção AWS SAM de modelo para um autorizador Lambda`TOKEN`: **nota** No exemplo a seguir, `FunctionRole` do SAM é gerado implicitamente. ``` Resources: MyApi: Type: AWS::Serverless::Api Properties: StageName: Prod Auth: DefaultAuthorizer: MyLambdaTokenAuthorizer Authorizers: MyLambdaTokenAuthorizer: FunctionArn: !GetAtt MyAuthFunction.Arn MyFunction: Type: AWS::Serverless::Function Properties: CodeUri: ./src Handler: index.handler Runtime: nodejs12.x Events: GetRoot: Type: Api Properties: RestApiId: !Ref MyApi Path: / Method: get MyAuthFunction: Type: AWS::Serverless::Function Properties: CodeUri: ./src Handler: authorizer.handler Runtime: nodejs12.x ``` Para obter mais informações sobre autorizadores do Lambda, consulte [Usar autorizadores Lambda do API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) no *Guia do desenvolvedor do API Gateway*. ## Exemplo de `REQUEST` autorizador Lambda (AWS::Serverless::Api) Você pode controlar o acesso ao seu APIs definindo um `REQUEST` autorizador Lambda em seu modelo. AWS SAM Para fazer isso, você usa o tipo de [ApiAuth](sam-property-api-apiauth.md) dados. Veja a seguir um exemplo de seção AWS SAM de modelo para um autorizador Lambda`REQUEST`: ``` Resources: MyApi: Type: AWS::Serverless::Api Properties: StageName: Prod Auth: DefaultAuthorizer: MyLambdaRequestAuthorizer Authorizers: MyLambdaRequestAuthorizer: FunctionPayloadType: REQUEST FunctionArn: !GetAtt MyAuthFunction.Arn Identity: QueryStrings: - auth MyFunction: Type: AWS::Serverless::Function Properties: CodeUri: ./src Handler: index.handler Runtime: nodejs12.x Events: GetRoot: Type: Api Properties: RestApiId: !Ref MyApi Path: / Method: get MyAuthFunction: Type: AWS::Serverless::Function Properties: CodeUri: ./src Handler: authorizer.handler Runtime: nodejs12.x ``` Para obter mais informações sobre autorizadores do Lambda, consulte [Usar autorizadores Lambda do API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) no *Guia do desenvolvedor do API Gateway*. ## Exemplo de autorizador Lambda (AWS::Serverless::HttpApi) Você pode controlar o acesso ao seu HTTP APIs definindo um autorizador Lambda em seu modelo. AWS SAM Para fazer isso, você usa o tipo de [HttpApiAuth](sam-property-httpapi-httpapiauth.md) dados. Veja a seguir um exemplo de seção AWS SAM de modelo para um autorizador Lambda: ``` Resources: MyApi: Type: AWS::Serverless::HttpApi Properties: StageName: Prod Auth: DefaultAuthorizer: MyLambdaRequestAuthorizer Authorizers: MyLambdaRequestAuthorizer: FunctionArn: !GetAtt MyAuthFunction.Arn FunctionInvokeRole: !GetAtt MyAuthFunctionRole.Arn Identity: Headers: - Authorization AuthorizerPayloadFormatVersion: 2.0 EnableSimpleResponses: true MyFunction: Type: AWS::Serverless::Function Properties: CodeUri: ./src Handler: index.handler Runtime: nodejs12.x Events: GetRoot: Type: HttpApi Properties: ApiId: !Ref MyApi Path: / Method: get PayloadFormatVersion: "2.0" MyAuthFunction: Type: AWS::Serverless::Function Properties: CodeUri: ./src Handler: authorizer.handler Runtime: nodejs12.x ``` # Exemplo de permissão do IAM para AWS SAM Você pode controlar o acesso ao seu APIs definindo as permissões do IAM em seu AWS SAM modelo. Para fazer isso, você usa o tipo de [ApiAuth](sam-property-api-apiauth.md) dados. Veja a seguir um exemplo AWS SAM de modelo usado para permissões do IAM: ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Resources: MyApi: Type: AWS::Serverless::Api Properties: StageName: Prod Description: 'API with IAM authorization' Auth: DefaultAuthorizer: AWS_IAM #sets AWS_IAM auth for all methods in this API MyFunction: Type: AWS::Serverless::Function Properties: Handler: index.handler Runtime: python3.10 Events: GetRoot: Type: Api Properties: RestApiId: !Ref MyApi Path: / Method: get InlineCode: | def handler(event, context): return {'body': 'Hello World!', 'statusCode': 200} ``` Para obter mais informações sobre as permissões do IAM, consulte [Controlar o acesso para invocar uma API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-control-access-using-iam-policies-to-invoke-api.html) no *Guia do desenvolvedor do API Gateway*. # Exemplo de grupo de usuários do Amazon Cognito para AWS SAM Você pode controlar o acesso ao seu APIs definindo grupos de usuários do Amazon Cognito dentro do seu AWS SAM modelo. Para fazer isso, você usa o tipo de [ApiAuth](sam-property-api-apiauth.md) dados. Veja a seguir um exemplo de seção AWS SAM de modelo para um grupo de usuários: ``` Resources: MyApi: Type: AWS::Serverless::Api Properties: StageName: Prod Cors: "'*'" Auth: DefaultAuthorizer: MyCognitoAuthorizer Authorizers: MyCognitoAuthorizer: UserPoolArn: !GetAtt MyCognitoUserPool.Arn MyFunction: Type: AWS::Serverless::Function Properties: CodeUri: ./src Handler: lambda.handler Runtime: nodejs12.x Events: Root: Type: Api Properties: RestApiId: !Ref MyApi Path: / Method: GET MyCognitoUserPool: Type: AWS::Cognito::UserPool Properties: UserPoolName: !Ref CognitoUserPoolName Policies: PasswordPolicy: MinimumLength: 8 UsernameAttributes: - email Schema: - AttributeDataType: String Name: email Required: false MyCognitoUserPoolClient: Type: AWS::Cognito::UserPoolClient Properties: UserPoolId: !Ref MyCognitoUserPool ClientName: !Ref CognitoUserPoolClientName GenerateSecret: false ``` Para mais informações sobre grupo de usuários do Amazon Cognito, consulte [Controlar o acesso a uma API REST usando um grupo de usuários do Amazon Cognito como autorizador](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-integrate-with-cognito.html) no *Guia do desenvolvedor do API Gateway*. # Exemplo de chave de API para AWS SAM Você pode controlar o acesso ao seu APIs exigindo chaves de API em seu AWS SAM modelo. Para fazer isso, você usa o tipo de [ApiAuth](sam-property-api-apiauth.md) dados. Veja a seguir um exemplo de seção AWS SAM de modelo para chaves de API: ``` Resources: MyApi: Type: AWS::Serverless::Api Properties: StageName: Prod Auth: ApiKeyRequired: true # sets for all methods MyFunction: Type: AWS::Serverless::Function Properties: CodeUri: . Handler: index.handler Runtime: nodejs12.x Events: ApiKey: Type: Api Properties: RestApiId: !Ref MyApi Path: / Method: get Auth: ApiKeyRequired: true ``` Para obter mais informações, consulte [Criação e uso de planos de uso com chaves de API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-usage-plans.html) no *Guia do desenvolvedor do API Gateway*. # Exemplo de política de recursos para AWS SAM Você pode controlar o acesso ao seu APIs anexando uma política de recursos ao seu AWS SAM modelo. Para fazer isso, você usa o tipo de [ApiAuth](sam-property-api-apiauth.md) dados. Veja a seguir um exemplo AWS SAM de modelo para uma API privada. Uma API privada deve ter uma política de recursos a ser implantada. ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Resources: MyPrivateApi: Type: AWS::Serverless::Api Properties: StageName: Prod EndpointConfiguration: PRIVATE # Creates a private API. Resource policies are required for all private APIs. Auth: ResourcePolicy: CustomStatements: - Effect: 'Allow' Action: 'execute-api:Invoke' Resource: ['execute-api:/*/*/*'] Principal: '*' - Effect: 'Deny' Action: 'execute-api:Invoke' Resource: ['execute-api:/*/*/*'] Principal: '*' MyFunction: Type: 'AWS::Serverless::Function' Properties: InlineCode: | def handler(event, context): return {'body': 'Hello World!', 'statusCode': 200} Handler: index.handler Runtime: python3.10 Events: AddItem: Type: Api Properties: RestApiId: Ref: MyPrivateApi Path: / Method: get ``` Para obter mais informações sobre políticas de recursos, consulte Como [controlar o acesso a uma API com as políticas de recursos do API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) no *Guia do desenvolvedor do API Gateway*. Para obter mais informações sobre privacidade APIs, consulte [Criação de uma API privada no Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-apis.html) no *Guia do desenvolvedor do API Gateway*. # OAuth Exemplo de autorizador 2.0/JWT para AWS SAM [Você pode controlar o acesso ao seu APIs uso JWTs como parte das estruturas [OpenID Connect (OIDC)](https://openid.net/specs/openid-connect-core-1_0.html) e 2.0. OAuth ](https://oauth.net/2/) Para fazer isso, você usa o tipo de [HttpApiAuth](sam-property-httpapi-httpapiauth.md) dados. Veja a seguir um exemplo de seção AWS SAM de modelo para um autorizador OAuth 2.0/JWT: ``` Resources: MyApi: Type: AWS::Serverless::HttpApi Properties: Auth: Authorizers: MyOauth2Authorizer: AuthorizationScopes: - scope IdentitySource: $request.header.Authorization JwtConfiguration: audience: - audience1 - audience2 issuer: "https://www.example.com/v1/connect/oidc" DefaultAuthorizer: MyOauth2Authorizer StageName: Prod MyFunction: Type: AWS::Serverless::Function Properties: CodeUri: ./src Events: GetRoot: Properties: ApiId: MyApi Method: get Path: / PayloadFormatVersion: "2.0" Type: HttpApi Handler: index.handler Runtime: nodejs12.x ``` *Para obter mais informações sobre autorizadores OAuth 2.0/JWT, consulte [Controle do acesso ao HTTP APIs com autorizadores JWT no](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) Guia do desenvolvedor do API Gateway.* # Exemplo de resposta personalizada para AWS SAM Você pode personalizar algumas respostas de erro do API Gateway definindo cabeçalhos de resposta em seu modelo AWS SAM . Para fazer isso, use o tipo de dados [Gateway Response Object](https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#gateway-response-object). Veja a seguir um exemplo AWS SAM de modelo que cria uma resposta personalizada para o `DEFAULT_5XX` erro. ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Resources: MyApi: Type: AWS::Serverless::Api Properties: StageName: Prod GatewayResponses: DEFAULT_5XX: ResponseParameters: Headers: Access-Control-Expose-Headers: "'WWW-Authenticate'" Access-Control-Allow-Origin: "'*'" ErrorHeader: "'MyCustomErrorHeader'" ResponseTemplates: application/json: "{\"message\": \"Error on the $context.resourcePath resource\" }" GetFunction: Type: AWS::Serverless::Function Properties: Runtime: python3.10 Handler: index.handler InlineCode: | def handler(event, context): raise Exception('Check out the new response!') Events: GetResource: Type: Api Properties: Path: /error Method: get RestApiId: !Ref MyApi ``` Para obter mais informações sobre as respostas do API Gateway, consulte [Respostas do gateway no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-gatewayResponse-definition.html) no *Guia do desenvolvedor do API Gateway*. # Aumente a eficiência usando camadas Lambda com AWS SAM Usando AWS SAM, você pode incluir camadas em seus aplicativos sem servidor. AWS Lambda camadas permitem que você extraia código de uma função Lambda em uma camada Lambda que pode ser usada em várias funções Lambda. Fazer isso permite a redução do tamanho dos pacotes de implantação, a separação da lógica da função de núcleo das dependências e o compartilhamento de dependências em várias funções. Para obter informações sobre camadas, consulte [Camadas do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) no *Guia do desenvolvedor do AWS Lambda *. Este tópico fornece informações sobre o seguinte: + Incluindo camadas em seu aplicativo + Como as camadas são armazenadas em cache localmente Para obter informações sobre como construir camadas personalizadas, consulte [Construindo camadas Lambda em AWS SAM](building-layers.md). ## Incluindo camadas em seu aplicativo Para incluir camadas em seu aplicativo, use a propriedade `Layers` do tipo de recurso [AWS::Serverless::Function](sam-resource-function.md). Veja a seguir um exemplo AWS SAM de modelo com uma função Lambda que inclui uma camada: ``` ServerlessFunction: Type: AWS::Serverless::Function Properties: CodeUri: . Handler: my_handler Runtime: Python3.7 Layers: - ``` ## Como as camadas são armazenadas em cache localmente Quando você invoca sua função usando um dos `sam local` comandos, o pacote de camadas da sua função é baixado e armazenado em cache no seu host local. A tabela a seguir mostra os locais padrão dos diretórios de cache de diferentes sistemas operacionais. **** | SO | Local | | --- | --- | | Windows 7 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM | | Windows 8 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM | | Windows 10 | C:\$1Users\$1\$1AppData\$1Roaming\$1AWS SAM | | macOS | \$1/.aws-sam/layers-pkg | | Unix | \$1/.aws-sam/layers-pkg | Depois que o pacote é armazenado em cache, as camadas são AWS SAMCLI sobrepostas em uma imagem do Docker usada para invocar sua função. Ele AWS SAMCLI gera os nomes das imagens que ele cria, bem como as LayerVersions que são mantidas no cache. Você pode encontrar mais detalhes sobre o esquema nas seções a seguir. Para inspecionar as camadas sobrepostas, execute o seguinte comando para iniciar uma sessão bash na imagem que você deseja inspecionar: ``` docker run -it --entrypoint=/bin/bash samcli/lambda: -i ``` **Esquema de nome do diretório de cache de camadas** Dado LayerVersionArn que está definido em seu modelo, o AWS SAMCLI extrai a versão LayerName e do ARN. Ele cria um diretório para colocar o conteúdo da camada em chamado `LayerName-Version-`. Exemplo: ``` ARN = arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1 Directory name = myLayer-1-926eeb5ff1 ``` **Esquema de tags do Docker Images** Para calcular o hash de camadas exclusivo, combine todos os nomes de camadas exclusivos com um delimitador de '-', pegue o SHA256 hash e, em seguida, use os 10 primeiros caracteres. Exemplo: ``` ServerlessFunction: Type: AWS::Serverless::Function Properties: CodeUri: . Handler: my_handler Runtime: Python3.7 Layers: - arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1 - arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1 ``` Os nomes exclusivos são computados da mesma forma que o esquema de nomes do Layer Caching Directory: ``` arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1 = myLayer-1-926eeb5ff1 arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1 = mySecondLayer-1-6bc1022bdf ``` Para calcular o hash de camadas exclusivo, combine todos os nomes de camadas exclusivos com um delimitador de '-', use o hash sha256 e, em seguida, use os primeiros 25 caracteres: ``` myLayer-1-926eeb5ff1-mySecondLayer-1-6bc1022bdf = 2dd7ac5ffb30d515926aef ``` Em seguida, combine esse valor com o tempo de execução e a arquitetura da função, com um delimitador de '-': ``` python3.7-x86_64-2dd7ac5ffb30d515926aefffd ``` # Reutilize código e recursos usando aplicativos aninhados no AWS SAM Um aplicativo sem servidor pode incluir um ou mais **aplicativos aninhados**. Uma aplicação aninhada faz parte de um aplicação maior e pode ser empacotada e implantada como um artefato independente ou como um componente de uma aplicação maior. As aplicações aninhadas permitem que você transforme códigos usados com frequência em sua própria aplicação, que pode ser reutilizado em uma aplicação sem servidor maior ou em várias aplicações sem servidor. À medida que as arquiteturas sem servidor crescem, normalmente surgem padrões comuns nos quais os mesmos componentes são definidos em vários modelos de aplicação. Os aplicativos aninhados permitem que você reutilize códigos, funcionalidades, recursos e configurações comuns em AWS SAM modelos separados, permitindo que você mantenha apenas o código de uma única fonte. Isso reduz código e configurações duplicadas. Além disso, essa abordagem modular simplifica o desenvolvimento, aprimora a organização do código e facilita a consistência em aplicações sem servidor. Com aplicativos aninhados, você pode se concentrar mais na lógica de negócios exclusiva do seu aplicativo. Para definir um aplicativo aninhado em seu aplicativo sem servidor, use o tipo de recurso [AWS::Serverless::Application](sam-resource-application.md). Você pode definir aplicativos aninhados a partir das duas fontes a seguir: + Um **AWS Serverless Application Repository aplicativo** — Você pode definir aplicativos aninhados usando aplicativos que estão disponíveis para sua conta na AWS Serverless Application Repository. Eles podem ser aplicativos *privados* em sua conta, aplicativos que são *compartilhados de forma privada* com sua conta ou aplicativos que são *compartilhados publicamente* no AWS Serverless Application Repository. Para obter mais informações sobre os diferentes níveis de permissões de implantação, consulte [Permissões de implantação de aplicativos](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#application-deployment-permissions) e [aplicativos de publicação](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-publishing-applications.html) no *AWS Serverless Application Repository Guia do desenvolvedor*. + Um **aplicativo local** — você pode definir aplicativos aninhados usando aplicativos armazenados em seu sistema de arquivos local. Consulte as seções a seguir para obter detalhes sobre como usar AWS SAM para definir esses dois tipos de aplicativos aninhados em seu aplicativo sem servidor. **nota** O número máximo de aplicativos que podem ser aninhados em um aplicativo sem servidor é 200. O número máximo de parâmetros que um aplicativo aninhado pode ter é 60. ## Definindo um aplicativo aninhado a partir do AWS Serverless Application Repository Você pode definir aplicativos aninhados usando aplicativos que estão disponíveis no AWS Serverless Application Repository. Você também pode armazenar e distribuir aplicativos que contêm aplicativos aninhados usando AWS Serverless Application Repository. Para revisar os detalhes de um aplicativo aninhado no AWS Serverless Application Repository, você pode usar o AWS SDK AWS CLI, o ou o console Lambda. Para definir um aplicativo hospedado no AWS SAM modelo do seu aplicativo sem servidor, use o botão **Copiar como recurso do SAM** na página de detalhes de cada AWS Serverless Application Repository aplicativo. AWS Serverless Application Repository Para isso, siga estas etapas: 1. Certifique-se de estar conectado ao Console de gerenciamento da AWS. 1. Encontre o aplicativo no qual você deseja aninhar AWS Serverless Application Repository usando as etapas na seção [Navegação, Pesquisa e Implantação de Aplicativos](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#browse-and-search-applications ) do *Guia do AWS Serverless Application Repository Desenvolvedor*. 1. Escolha o botão **Copiar como recurso do SAM**. A seção de modelo do SAM para o aplicativo que você está visualizando agora está na sua área de transferência. 1. Cole a seção do modelo do SAM na seção `Resources:` do arquivo de modelo do SAM do aplicativo que você deseja aninhar nesse aplicativo. Veja a seguir um exemplo de seção de modelo de SAM para um aplicativo aninhado hospedado no AWS Serverless Application Repository: ``` Transform: AWS::Serverless-2016-10-31 Resources: applicationaliasname: Type: AWS::Serverless::Application Properties: Location: ApplicationId: arn:aws:serverlessrepo:us-east-1:123456789012:applications/application-alias-name SemanticVersion: 1.0.0 Parameters: # Optional parameter that can have default value overridden # ParameterName1: 15 # Uncomment to override default value # Required parameter that needs value to be provided ParameterName2: YOUR_VALUE ``` Se não houver configurações de parâmetros obrigatórias, você poderá omitir a seção `Parameters:` do modelo. **Importante** Os aplicativos que contêm aplicativos aninhados hospedados no AWS Serverless Application Repository herdam as restrições de compartilhamento dos aplicativos aninhados. Por exemplo, suponha que um aplicativo seja compartilhado publicamente, mas contenha um aplicativo aninhado que só é compartilhado de forma privada com a AWS conta que criou o aplicativo principal. Nesse caso, se sua AWS conta não tiver permissão para implantar o aplicativo aninhado, você não poderá implantar o aplicativo principal. Para obter mais informações sobre permissões para implantar aplicativos, consulte [Permissões de implantação de aplicativos](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-consuming-applications.html#application-deployment-permissions) e [publicação de aplicativos](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverless-app-publishing-applications.html) no *AWS Serverless Application Repository Guia do desenvolvedor*. ## Definindo um aplicativo aninhado a partir do sistema de arquivos local Você pode definir aplicativos aninhados usando aplicativos armazenados no sistema de arquivos local. Você faz isso especificando o caminho para o arquivo AWS SAM de modelo que está armazenado no sistema de arquivos local. Veja a seguir um exemplo de seção de modelo de SAM para um aplicativo local aninhado: ``` Transform: AWS::Serverless-2016-10-31 Resources: applicationaliasname: Type: AWS::Serverless::Application Properties: Location: ../my-other-app/template.yaml Parameters: # Optional parameter that can have default value overridden # ParameterName1: 15 # Uncomment to override default value # Required parameter that needs value to be provided ParameterName2: YOUR_VALUE ``` Se não houver configurações de parâmetros, você poderá omitir a seção `Parameters:` do modelo. ## Implantar aplicativos aninhados Você pode implantar seu aplicativo aninhado usando o comando `sam deploy` do AWS SAM CLI. Consulte mais detalhes em [Implante seu aplicativo e seus recursos com AWS SAM](serverless-deploying.md). **nota** Quando você implanta uma aplicação que contém aplicações aninhadas, deve reconhecer que ela contém aplicações aninhadas. Você faz isso passando `CAPABILITY_AUTO_EXPAND` para a [CreateCloudFormationChangeSet API](https://docs.aws.amazon.com/goto/WebAPI/serverlessrepo-2017-09-08/CreateCloudFormationChangeSet) ou usando o [https://docs.aws.amazon.com/cli/latest/reference/serverlessrepo/create-cloud-formation-change-set.html](https://docs.aws.amazon.com/cli/latest/reference/serverlessrepo/create-cloud-formation-change-set.html) AWS CLI comando. Para obter mais informações sobre como reconhecer aplicativos aninhados, consulte [Reconhecer funções, políticas de recursos e aplicativos aninhados do perfil do IAM ao implantar aplicativos](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/acknowledging-application-capabilities.html) no *Guia do desenvolvedor do AWS Serverless Application Repository *. # Gerencie eventos baseados em tempo com o EventBridge Scheduler em AWS SAM O conteúdo deste tópico fornece detalhes sobre o que é o Amazon EventBridge Scheduler, quais AWS SAM ofertas de suporte, como você pode criar eventos do Scheduler e exemplos que você pode consultar ao criar eventos do Scheduler. ## O que é o Amazon EventBridge Scheduler? Use o EventBridge Scheduler para agendar eventos em seus AWS SAM modelos. O Amazon EventBridge Scheduler é um serviço de agendamento que permite criar, iniciar e gerenciar dezenas de milhões de eventos e tarefas em todos os serviços. AWS Esse serviço é particularmente útil para eventos relacionados a tempo. Você pode usá-lo para agendar eventos e invocações recorrentes baseadas em tempo. Ele também oferece suporte a eventos únicos, bem como a expressões de taxa e cron com horários de início e de término. Para saber mais sobre o Amazon EventBridge Scheduler, consulte [O que é o Amazon EventBridge Scheduler](https://docs.aws.amazon.com/scheduler/latest/UserGuide/what-is-scheduler.html)? no *Guia do usuário do EventBridge Scheduler*. **Topics** + [O que é o Amazon EventBridge Scheduler?](#using-eventbridge-scheduler-intro) + [EventBridge Suporte ao agendador em AWS SAM](#using-eventbridge-scheduler-sam-support) + [Criação de eventos do EventBridge Scheduler em AWS SAM](#using-eventbridge-scheduler-sam-create) + [Exemplos](#using-eventbridge-scheduler-examples) + [Saiba mais](#using-eventbridge-scheduler-learn) ## EventBridge Suporte ao agendador em AWS SAM A especificação do modelo AWS Serverless Application Model (AWS SAM) fornece uma sintaxe simples e abreviada que você pode usar para agendar eventos com o EventBridge Scheduler for e. AWS Lambda AWS Step Functions ## Criação de eventos do EventBridge Scheduler em AWS SAM Defina a `ScheduleV2` propriedade como o tipo de evento em seu AWS SAM modelo para definir seu evento do EventBridge Scheduler. Essa propriedade oferece suporte aos tipos de recurso `AWS::Serverless::Function` e `AWS::Serverless::StateMachine`. ``` MyFunction: Type: AWS::Serverless::Function Properties: Events: CWSchedule: Type: ScheduleV2 Properties: ScheduleExpression: 'rate(1 minute)' Name: TestScheduleV2Function Description: Test schedule event MyStateMachine: Type: AWS::Serverless::StateMachine Properties: Events: CWSchedule: Type: ScheduleV2 Properties: ScheduleExpression: 'rate(1 minute)' Name: TestScheduleV2StateMachine Description: Test schedule event ``` EventBridge O agendamento de eventos do Scheduler também oferece suporte a *filas de cartas mortas (DLQ*) para eventos não processados. *Para obter mais informações sobre filas de mensagens mortas, consulte [Configurando uma fila de mensagens mortas para EventBridge o Scheduler no Guia do usuário do Scheduler](https://docs.aws.amazon.com/scheduler/latest/UserGuide/configuring-schedule-dlq.html). EventBridge * Quando um ARN de DLQ é especificado AWS SAM , configura permissões para que o agendador envie mensagens para o DLQ. Quando um ARN DLQ não for especificado AWS SAM , criará o recurso DLQ. ## Exemplos ### Exemplo básico de definição de um evento do EventBridge Scheduler com AWS SAM ``` Transform: AWS::Serverless-2016-10-31 Resources: MyLambdaFunction: Type: AWS::Serverless::Function Properties: Handler: index.handler Runtime: python3.8 InlineCode: | def handler(event, context): print(event) return {'body': 'Hello World!', 'statusCode': 200} MemorySize: 128 Events: Schedule: Type: ScheduleV2 Properties: ScheduleExpression: rate(1 minute) Input: '{"hello": "simple"}' MySFNFunction: Type: AWS::Serverless::Function Properties: Handler: index.handler Runtime: python3.8 InlineCode: | def handler(event, context): print(event) return {'body': 'Hello World!', 'statusCode': 200} MemorySize: 128 StateMachine: Type: AWS::Serverless::StateMachine Properties: Type: STANDARD Definition: StartAt: MyLambdaState States: MyLambdaState: Type: Task Resource: !GetAtt MySFNFunction.Arn End: true Policies: - LambdaInvokePolicy: FunctionName: !Ref MySFNFunction Events: Schedule: Type: ScheduleV2 Properties: ScheduleExpression: rate(1 minute) Input: '{"hello": "simple"}' ``` ## Saiba mais Para saber mais sobre como definir a propriedade `ScheduleV2` EventBridge Scheduler, consulte: + [ScheduleV2](sam-property-function-schedulev2.md) para `AWS::Serverless::Function`. + [ScheduleV2](sam-property-statemachine-statemachineschedulev2.md) para `AWS::Serverless::StateMachine`. # Orquestrando recursos com AWS SAM AWS Step Functions Você pode usar [AWS Step Functions](https://docs.aws.amazon.com/step-functions/latest/dg/)para orquestrar AWS Lambda funções e outros AWS recursos para formar fluxos de trabalho complexos e robustos. Step Functions para informar ao seu aplicativo quando e sob quais condições seus AWS recursos, como AWS Lambda funções, são usados. Isso simplifica o processo da formação de fluxos de trabalho complexos e robustos. Usando [AWS::Serverless::StateMachine](sam-resource-statemachine.md), você define as etapas individuais do fluxo de trabalho, associa recursos em cada etapa e, em seguida, sequencia essas etapas em conjunto. Você também adiciona transições e condições onde elas são necessárias. Isso simplifica o processo de criar um fluxo de trabalho complexo e robusto. **nota** Para gerenciar AWS SAM modelos que contêm máquinas de estado do Step Functions, você deve usar a versão 0.52.0 ou posterior do. AWS SAMCLI Para verificar qual versão você tem, execute o comando `sam --version`. Step Functions é baseado nos conceitos de [tarefas](https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-task-state.html) e [máquinas de estado](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-states.html). Você define uma máquina de estado usando a [Amazon States Language](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html) baseada em JSON. O [console do Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) apresenta uma visualização gráfica da estrutura da sua máquina de estado para que você possa verificar visualmente a lógica da sua máquina de estado e monitorar as execuções. Com o suporte para Step Functions em AWS Serverless Application Model (AWS SAM), você pode fazer o seguinte: + Defina máquinas de estado, diretamente em um AWS SAM modelo ou em um arquivo separado + Crie funções de execução de máquinas de estado por meio AWS SAM de modelos de políticas, políticas embutidas ou políticas gerenciadas + Acione execuções de máquinas de estado com o API Gateway ou EventBridge eventos da Amazon, de acordo com uma programação dentro AWS SAM de um modelo ou ligando diretamente APIs + Use os [modelos AWS SAM de política](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-policy-templates.html) disponíveis para padrões comuns de desenvolvimento de Step Functions. ## Exemplo O trecho de exemplo a seguir de um arquivo de AWS SAM modelo define uma máquina de estado Step Functions em um arquivo de definição. Observe que o `my_state_machine.asl.json` arquivo deve ser escrito em [Amazon States Language](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html). ``` AWSTemplateFormatVersion: "2010-09-09" Transform: AWS::Serverless-2016-10-31 Description: Sample SAM template with Step Functions State Machine Resources: MyStateMachine: Type: AWS::Serverless::StateMachine Properties: DefinitionUri: statemachine/my_state_machine.asl.json ... ``` Para baixar um AWS SAM aplicativo de amostra que inclui uma máquina de estado Step Functions, consulte [Create a Step Functions State Machine usando AWS SAM](https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-state-machine-using-sam.html) no *AWS Step Functions Developer Guide*. ## Mais informações Para saber mais sobre Step Functions e como usá-lo com AWS SAM, veja o seguinte: + [Com o AWS Step Functions funciona](https://docs.aws.amazon.com/step-functions/latest/dg/how-step-functions-works.html) + [AWS Step Functions and AWS Serverless Application Model](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-sam-sfn.html) + [Tutorial: Crie uma máquina de estado do Step Functions usando AWS SAM](https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-state-machine-using-sam.html) + [AWS SAM Especificação: AWS::Serverless::StateMachine](sam-resource-statemachine.md) # Configure a assinatura de código para seu AWS SAM aplicativo Para garantir que somente código confiável seja implantado, você pode usar AWS SAM para habilitar a assinatura de código com seus aplicativos sem servidor. Assinar o código ajuda a garantir que o código não tenha sido alterado desde a assinatura e que somente pacotes de código assinados de publicadores confiáveis sejam executados nas funções do Lambda. Isso ajuda a liberar as organizações da carga de criar componentes do gatekeeper em seus pipelines de implantação. Para obter mais informações sobre assinatura de código, consulte [Configurar assinatura de código das funções do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html) no *Guia do desenvolvedor do AWS Lambda *. Antes de configurar a assinatura de código para seu aplicativo sem servidor, você deve criar um perfil de assinatura usando o AWS Signer. Você usa esse perfil de assinatura para as seguintes tarefas: 1. **Criação de uma configuração de assinatura de código** — Declare um [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html)recurso para especificar os perfis de assinatura de editores confiáveis e definir a ação política para verificações de validação. Você pode declarar esse objeto no mesmo AWS SAM modelo da sua função sem servidor, em um AWS SAM modelo diferente ou em um modelo. CloudFormation Em seguida, você habilita a assinatura de código para uma função sem servidor especificando a propriedade [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-codesigningconfigarn](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-codesigningconfigarn) da função com o nome de recurso da Amazon (ARN) de um recurso[https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html). 1. **Assinando seu código** — Use o comando [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html) ou [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html) com a opção `--signing-profiles`. **nota** Para assinar com sucesso seu código com os comandos `sam package` ou `sam deploy`, o versionamento deve estar habilitado para o bucket do Amazon S3 que você usa com esses comandos. Se você estiver usando o Amazon S3 Bucket AWS SAM criado para você, o controle de versão será ativado automaticamente. Para obter mais informações sobre o versionamento de buckets do Amazon S3 e instruções para habilitar o versionamento em um bucket do Amazon S3 fornecido por você, consulte [Uso do versionamento em buckets do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) no *Guia do usuário do Amazon Simple Storage Service*. Quando você implanta um aplicativo sem servidor, o Lambda executa verificações de validação em todas as funções para as quais você habilitou a assinatura de código. O Lambda também realiza verificações de validação em todas as camadas das quais essas funções dependem. Para obter mais informações sobre as verificações de validação do Lambda, consulte [Validação de assinatura](https://docs.aws.amazon.com/lambda/latest/dg/configuration-codesigning.html#config-codesigning-valid) no *Guia do AWS Lambda desenvolvedor*. ## Exemplo ### Criar um perfil de assinatura Para criar um perfil de assinatura, execute o seguinte comando: ``` aws signer put-signing-profile --platform-id "AWSLambda-SHA384-ECDSA" --profile-name MySigningProfile ``` Se o comando anterior é bem-sucedido, o ARN do perfil de assinatura é retornado. Por exemplo: ``` { "arn": "arn:aws:signer:us-east-1:111122223333:/signing-profiles/MySigningProfile", "profileVersion": "SAMPLEverx", "profileVersionArn": "arn:aws:signer:us-east-1:111122223333:/signing-profiles/MySigningProfile/SAMPLEverx" } ``` O `profileVersionArn` campo contém o ARN a ser usado ao criar a configuração de assinatura de código. ### Criar uma configuração de assinatura de código e habilitar a assinatura de código para uma função O AWS SAM modelo de exemplo a seguir declara um [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-codesigningconfig.html)recurso e permite a assinatura de código para uma função Lambda. Neste exemplo, há um perfil confiável e as implantações são rejeitadas se as verificações de assinatura falharem. ``` Resources: HelloWorld: Type: AWS::Serverless::Function Properties: CodeUri: hello_world/ Handler: app.lambda_handler Runtime: python3.7 CodeSigningConfigArn: !Ref MySignedFunctionCodeSigningConfig MySignedFunctionCodeSigningConfig: Type: AWS::Lambda::CodeSigningConfig Properties: Description: "Code Signing for MySignedLambdaFunction" AllowedPublishers: SigningProfileVersionArns: - MySigningProfile-profileVersionArn CodeSigningPolicies: UntrustedArtifactOnDeployment: "Enforce" ``` ### Assinando seu código Você pode assinar seu código ao empacotar ou implantar seu aplicativo. Especifique a opção `--signing-profiles` com o comando `sam package` ou `sam deploy`, conforme mostrado nos seguintes exemplos de comandos. Assinando seu código de função ao empacotar seu aplicativo: ``` sam package --signing-profiles HelloWorld=MySigningProfile --s3-bucket amzn-s3-demo-bucket --output-template-file packaged.yaml ``` Assinar seu código de função e uma camada da qual sua função depende ao empacotar seu aplicativo: ``` sam package --signing-profiles HelloWorld=MySigningProfile MyLayer=MySigningProfile --s3-bucket amzn-s3-demo-bucket --output-template-file packaged.yaml ``` Assinando seu código de função e uma camada e, em seguida, executando uma implantação: ``` sam deploy --signing-profiles HelloWorld=MySigningProfile MyLayer=MySigningProfile --s3-bucket amzn-s3-demo-bucket --template-file packaged.yaml --stack-name --region us-east-1 --capabilities CAPABILITY_IAM ``` **nota** Para assinar com sucesso seu código com os comandos `sam package` ou `sam deploy`, o versionamento deve estar habilitado para o bucket do Amazon S3 que você usa com esses comandos. Se você estiver usando o Amazon S3 Bucket AWS SAM criado para você, o controle de versão será ativado automaticamente. Para obter mais informações sobre o versionamento de buckets do Amazon S3 e instruções para habilitar o versionamento em um bucket do Amazon S3 fornecido por você, consulte [Uso do versionamento em buckets do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) no *Guia do usuário do Amazon Simple Storage Service*. ## Fornecendo perfis de assinatura com `sam deploy --guided` Quando você executa o `sam deploy --guided` comando com um aplicativo sem servidor configurado com assinatura de código, AWS SAM solicita que você forneça o perfil de assinatura a ser usado na assinatura de código. Para obter mais informações sobre prompts `sam deploy --guided`, consulte [sam deploy](sam-cli-command-reference-sam-deploy.md) na Referência de comandos de AWS SAMCLI. # Validar arquivos AWS SAM de modelo Valide seus modelos com `sam validate`. Atualmente, esse comando valida se o modelo fornecido é JSON/YAML válido. Como acontece com a maioria dos comandos, AWS SAM CLI, ele procura um arquivo `template.[yaml|yml]` no seu diretório de trabalho atual por padrão. Você pode especificar um modelo diferente file/location com a `--template` opção `-t` ou. Exemplo: ``` $ sam validate /template.yaml is a valid SAM Template ``` **nota** O `sam validate` comando exige que AWS as credenciais sejam configuradas. Para obter mais informações, consulte [Configurando o AWS SAM CLI](using-sam-cli-configure.md).