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á.
# Desenvolva seu aplicativo sem servidor com AWS SAM
Esta seção contém tópicos sobre como validar seu AWS SAM modelo e criar seu aplicativo com dependências. Ele também contém tópicos sobre o uso AWS SAM em determinados casos de uso, como trabalhar com camadas Lambda, usar aplicativos aninhados, controlar o acesso ao API Gateway APIs, orquestrar recursos com AWS Step Functions e assinar códigos em seus aplicativos. Os três principais marcos de que você precisa concluir para desenvolver a aplicação estão listados abaixo.
**Topics**
+ [Crie seu aplicativo em AWS SAM](using-sam-cli-init.md)
+ [Defina sua infraestrutura com AWS SAM](serverless-authoring.md)
+ [Crie seu aplicativo com AWS SAM](serverless-building.md)
# Crie seu aplicativo em AWS SAM
Depois de concluir os [Conceitos básicos](serverless-getting-started.md) e ler [Como usar AWS Serverless Application Model (AWS SAM)](chapter-using-sam.md), tudo estará pronto para criar um projeto do AWS SAM no seu ambiente de desenvolvedor. Seu AWS SAM projeto servirá como ponto de partida para escrever seu aplicativo sem servidor. Para obter uma lista de opções de AWS SAMCLI `sam init` comando, consulte[sam init](sam-cli-command-reference-sam-init.md).
O AWS Serverless Application Model comando Command Line Interface (AWS SAMCLI) `sam init` fornece opções para inicializar um novo aplicativo sem servidor que consiste em:
+ Um AWS SAM modelo para definir seu código de infraestrutura.
+ Uma estrutura de pastas que organiza seu aplicativo.
+ Configuração para suas AWS Lambda funções.
Para criar um AWS SAM projeto, consulte os tópicos desta seção.
**nota**
`sam init`inclui modelos de projeto para funções duráveis em tempos de execução compatíveis (TypeScript, Python, Java). Esses modelos fornecem código inicial e configuração para criar aplicativos sem servidor com estado.
**Topics**
+ [Inicialize um novo aplicativo com tecnologia sem servidor.](#using-sam-cli-init-new)
+ [Opções para o sam init](#using-sam-cli-init-options)
+ [Solução de problemas](#using-sam-cli-init-troubleshooting)
+ [Exemplos](#using-sam-cli-init-examples)
+ [Saiba mais](#using-sam-cli-init-learn)
+ [Próximas etapas](#w2aac18c11c39)
## Inicialize um novo aplicativo com tecnologia sem servidor.
**Para inicializar um novo aplicativo com tecnologia sem servidor usando o AWS SAM CLI**
1. `cd` para um diretório inicial.
1. Execute o seguinte na linha de comando:
```
$ sam init
```
1. O AWS SAMCLI o guiará por um fluxo interativo para criar um novo aplicativo com tecnologia sem servidor.
**nota**
Conforme detalhado em [Tutorial: implante um aplicativo Hello World com AWS SAM](serverless-getting-started-hello-world.md), esse comando inicializa a aplicação sem servidor, criando o diretório do projeto. Esse diretório conterá vários arquivos e pastas. O arquivo mais importante é `template.yaml`. Esse é o seu AWS SAM modelo. A versão do python deve corresponder à versão do python listada no arquivo `template.yaml` criado pelo comando **sam init**.
### Escolha um modelo inicial
Um *modelo* consiste no seguinte:
1. Um AWS SAM modelo para seu código de infraestrutura.
1. Um diretório inicial do projeto que organiza seus arquivos de projeto. Por exemplo, isso pode incluir:
1. Uma estrutura para o código de função do Lambda e suas dependências.
1. Uma pasta `events` que contém eventos de teste para testes locais.
1. Uma pasta `tests` para oferecer suporte ao teste de unidade.
1. Um arquivo `samconfig.toml` para definir as configurações do projeto.
1. Um arquivo `ReadMe` e outros arquivos básicos do projeto inicial.
Veja a seguir um exemplo de um diretório de projeto inicial:
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
├── integration
│ ├── __init__.py
│ └── test_api_gateway.py
├── requirements.txt
└── unit
├── __init__.py
└── test_handler.py
```
Você pode selecionar em uma lista de *AWS modelos de início rápido* disponíveis ou fornecer sua própria *localização de modelo personalizado*.
**Para escolher um modelo de início AWS rápido**
1. Quando solicitado, selecione **AWS Modelos de início rápido**.
1. Selecione um modelo de Início AWS Rápido para começar. Este é um exemplo:
```
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
4 - Scheduled task
5 - Standalone function
6 - Data processing
7 - Hello World Example With Powertools
8 - Infrastructure event management
9 - Serverless Connector Hello World Example
10 - Multi-step workflow with Connectors
11 - Lambda EFS example
12 - DynamoDB Example
13 - Machine Learning
Template: 4
```
**Para escolher sua própria localização de modelo personalizado**
1. Quando solicitado, selecione a **localização do modelo personalizado**.
```
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 2
```
1. O AWS SAMCLI solicitará que você forneça uma localização do modelo.
```
Template location (git, mercurial, http(s), zip, path):
```
Forneça qualquer uma das seguintes localizações para o arquivo de arquivos.zip do modelo:
+ **GitHubrepositório** — O caminho para o arquivo.zip no seu repositório GitHub. O arquivo deve estar na raiz do seu repositório.
+ **Mercurialrepositório** — O caminho para o arquivo.zip no seu repositório Mercurial. O arquivo deve estar na raiz do seu repositório.
+ **caminho.zip** — Um caminho HTTPS ou localização para seu arquivo.zip.
1. O AWS SAMCLI inicializará seu aplicativo com tecnologia sem servidor usando seu modelo personalizado.
### Escolher um tempo de execução
Quando você escolhe um *AWS Modelo de início rápido*, o AWS SAMCLI solicitará que você selecione um tempo de execução para suas funções do Lambda. A lista de opções exibida pelo AWS SAMCLI são os tempos de execução suportados nativamente pelo Lambda.
+ O [tempo de execução](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-runtime) fornece um ambiente específico de linguagem que é executado no ambiente de execução.
+ [Quando implantado no Nuvem AWS, o serviço Lambda invoca sua função em um ambiente de execução.](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtime-environment.html)
Você pode usar qualquer outra linguagem de programação com um tempo de execução personalizado. Para fazer isso, você precisa criar manualmente a estrutura inicial do aplicativo. Em seguida, você pode usar o `sam init` para inicializar rapidamente seu aplicativo configurando uma localização de modelo personalizado.
A partir da sua seleção, o AWS SAMCLI cria o diretório inicial para o código e as dependências da função do Lambda.
Se o Lambda oferecer suporte a vários gerenciadores de dependências para seu tempo de execução, você será solicitado a escolher seu gerenciador de dependências preferido.
### Escolha um tipo de pacote
Quando você escolhe um *AWS modelo de início rápido* e um *tempo de execução*, o AWS SAMCLI solicita que você selecione um *tipo de pacote*. O tipo de pacote determina como suas funções do Lambda são implantadas para uso com o serviço Lambda. Os dois tipos de pacotes compatíveis são:
1. **Imagem de contêiner** – Contém o sistema operacional de base, o tempo de execução, as extensões do Lambda, o código do seu aplicativo e suas dependências.
1. **arquivo .zip** – Contém o código do seu aplicativo e suas dependências.
Para saber mais sobre os tipos de pacotes de implantação, consulte [Pacotes de implantação do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) no *AWS Lambda Guia do desenvolvedor*.
Veja a seguir um exemplo de estrutura de diretórios de um aplicativo com uma função do Lambda empacotada como uma imagem de contêiner. O AWS SAMCLI baixa a imagem e cria um `Dockerfile` no diretório da função para especificar a imagem.
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── Dockerfile
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
└── unit
├── __init__.py
└── test_handler.py
```
A seguir está um exemplo de estrutura do diretório de um aplicativo com uma função empacotada como um arquivo .zip.
```
sam-app
├── README.md
├── __init__.py
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
├── __init__.py
├── integration
│ ├── __init__.py
│ └── test_api_gateway.py
├── requirements.txt
└── unit
├── __init__.py
└── test_handler.py
```
### Configurar o AWS X-Ray rastreamento
Você pode optar por ativar o AWS X-Ray rastreamento. Para saber mais, consulte [O que é AWS X-Ray?](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html) no *Guia do AWS X-Ray desenvolvedor*.
Se você ativar, ele AWS SAMCLI configura seu AWS SAM modelo. Este é um exemplo:
```
Globals:
Function:
...
Tracing: Active
Api:
TracingEnabled: True
```
### Configure o monitoramento com o Amazon CloudWatch Application Insights
Você pode optar por ativar o monitoramento usando o Amazon CloudWatch Application Insights. Para saber mais, consulte [Amazon CloudWatch Application Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html) no *Guia CloudWatch do usuário da Amazon*.
Se você ativar, ele AWS SAMCLI configura seu AWS SAM modelo. Este é um exemplo:
```
Resources:
ApplicationResourceGroup:
Type: AWS::ResourceGroups::Group
Properties:
Name:
Fn::Join:
- ''
- - ApplicationInsights-SAM-
- Ref: AWS::StackName
ResourceQuery:
Type: CLOUDFORMATION_STACK_1_0
ApplicationInsightsMonitoring:
Type: AWS::ApplicationInsights::Application
Properties:
ResourceGroupName:
Fn::Join:
- ''
- - ApplicationInsights-SAM-
- Ref: AWS::StackName
AutoConfigurationEnabled: 'true'
DependsOn: ApplicationResourceGroup
```
### Dê um nome para o seu aplicativo
Forneça um nome para seu aplicativo. O AWS SAMCLI cria uma pasta de nível superior para seu aplicativo usando esse nome.
## Opções para o sam init
Veja a seguir algumas das opções principais que você pode usar com o comando `sam init`. Para obter uma lista de todas as opções, consulte [sam init](sam-cli-command-reference-sam-init.md).
### Inicializar um aplicativo usando um local de modelo personalizado
Use a opção `--location` e forneça um local de modelo personalizado compatível. Veja um exemplo a seguir.
```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```
### Inicializar um aplicativo sem o fluxo interativo
Use a opção `--no-interactive` e forneça suas opções de configuração na linha de comando para ignorar o fluxo interativo. Veja um exemplo a seguir.
```
$ sam init --no-interactive --runtime go1.x --name go-demo --dependency-manager mod --app-template hello-world
```
## Solução de problemas
Para solucionar o problema do AWS SAMCLI, consulte[AWS SAM CLI solução de problemas](sam-cli-troubleshooting.md).
## Exemplos
### Inicialize um novo aplicativo sem servidor usando o Hello World Starter Template AWS
Para este exemplo, consulte [Etapa 1: Inicialize o aplicativo de amostra Hello World](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-init) no *Tutorial: Implantação de um aplicativo Hello World*.
### Inicialize um novo aplicativo com tecnologia sem servidor com um local de modelo personalizado
Veja a seguir exemplos de como fornecer uma localização GitHub para seu modelo personalizado:
```
$ sam init --location gh:aws-samples/cookiecutter-aws-sam-python
$ sam init --location git+sh://git@github.com/aws-samples/cookiecutter-aws-sam-python.git
$ sam init --location hg+ssh://hg@bitbucket.org/repo/template-name
```
Veja a seguir um exemplo de caminho de arquivo local:
```
$ sam init --location /path/to/template.zip
```
Veja a seguir um exemplo de um caminho acessível por HTTPS:
```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```
## Saiba mais
Para obter mais informações sobre como usar o comando`sam init`, consulte:
+ **[Aprendizagem AWS SAM: sam init](https://www.youtube.com/watch?v=9m3R-leD5Xo)** — série Serverless Land “Aprendizagem AWS SAM” sobre. YouTube
+ **[Estruturação de aplicativos com tecnologia sem servidor para uso com o AWS SAMCLI (Sessões com SAM S2E7)](https://www.youtube.com/watch?v=k9IRdgze9fQ)** — Sessões com séries AWS SAM no YouTube.
## Próximas etapas
Agora que você criou seu AWS SAM projeto, você está pronto para começar a criar seu aplicativo. Consulte [Defina sua infraestrutura com AWS SAM](serverless-authoring.md) para obter instruções detalhadas sobre as tarefas que você precisa concluir para fazer isso.
# 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).
# Crie seu aplicativo com AWS SAM
Depois de adicionar sua infraestrutura como código (IaC) ao seu AWS SAM modelo, você estará pronto para começar a criar seu aplicativo usando o **sam build** comando. Esse comando cria artefatos de construção a partir dos arquivos no diretório do projeto do aplicativo (ou seja, seu arquivo de AWS SAM modelo, código do aplicativo e quaisquer arquivos e dependências específicos do idioma aplicável). Esses artefatos de construção preparam seu aplicativo sem servidor para as etapas posteriores do desenvolvimento do seu aplicativo, como testes locais e implantação na nuvem. AWS Tanto o teste quanto a implantação usam artefatos de compilação como entradas.
Você pode usar **sam build** para criar toda a aplicação sem servidor. Além disso, você pode criar compilações personalizadas, como aquelas com funções, camadas ou runtimes personalizados específicos. Para ler mais sobre como e por que usar **sam build**, consulte os tópicos desta seção. Para obter uma introdução sobre como usar o comando `sam build`, consulte [Introdução à construção com AWS SAM](using-sam-cli-build.md).
**Topics**
+ [Introdução à construção com AWS SAM](using-sam-cli-build.md)
+ [Compilação padrão com AWS SAM](serverless-sam-cli-using-build.md)
+ [Personalize construções com AWS SAM](building-lambda-functions.md)
# Introdução à construção com AWS SAM
Use o AWS Serverless Application Model comando Command Line Interface (AWS SAMCLI) `sam build` para preparar seu aplicativo sem servidor para as etapas subsequentes do fluxo de trabalho de desenvolvimento, como testes locais ou implantação no. Nuvem AWS Esse comando cria um diretório `.aws-sam` que estrutura seu aplicativo em um formato e localização que o `sam local` e o `sam deploy` exigem.
+ Para obter uma introdução ao AWS SAMCLI, consulte[O que é o AWS SAMCLI?](what-is-sam-overview.md#what-is-sam-cli).
+ Para obter uma lista de opções de comando `sam build`, consulte [sam build](sam-cli-command-reference-sam-build.md).
+ Para obter um exemplo de uso do `sam build` durante um fluxo de trabalho de desenvolvimento típico, consulte [Etapa 2: crie seu aplicativo](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-build).
**nota**
O uso de `sam build` exige que você comece com os componentes básicos de um aplicativo com tecnologia sem servidor em sua máquina de desenvolvimento. Isso inclui um AWS SAM modelo, código de AWS Lambda função e quaisquer arquivos e dependências específicos do idioma. Para saber mais, consulte [Crie seu aplicativo em AWS SAM](using-sam-cli-init.md).
**Topics**
+ [Construindo aplicativos com Sam Build](#using-sam-cli-build-apps)
+ [Teste e implantação locais](#using-sam-cli-build-test-deploy)
+ [Práticas recomendadas](#using-sam-cli-build-best)
+ [Opções para sam build](#using-sam-cli-build-options)
+ [Solução de problemas](#using-sam-cli-build-troubleshooting)
+ [Exemplos](#using-sam-cli-build-examples)
+ [Saiba mais](#using-sam-cli-build-learn)
## Construindo aplicativos com Sam Build
Antes de usar o `sam build`, considere a configuração do seguinte:
1. **Funções e camadas do Lambda** — O `sam build` comando pode construir funções e camadas do Lambda. Para saber mais sobre as camadas do Lambda, consulte [Construindo camadas Lambda em AWS SAM](building-layers.md).
1. **Tempo de execução do Lambda** – O *tempo de execução* fornece um ambiente específico de linguagem que executa sua função no ambiente de execução quando invocado. Você pode configurar runtimes nativos e personalizados.
1. **Tempo de execução nativo** — Crie suas funções do Lambda em um tempo de execução do Lambda compatível e construa suas funções para usar um tempo de execução do Lambda nativo no Nuvem AWS.
1. **Tempo de execução personalizado** — Crie suas funções do Lambda usando qualquer linguagem de programação e construa seu tempo de execução usando um processo personalizado definido em um construtor makefile ou em um criador terceirizado, como esbuild. Para saber mais, consulte [Criação de funções Lambda com tempos de execução personalizados no AWS SAM](building-custom-runtimes.md).
1. **Tipo de pacote Lambda** — As funções do Lambda podem ser empacotadas nos seguintes tipos de pacotes de implantação do Lambda:
1. **arquivo .zip** – Contém o código do seu aplicativo e suas dependências.
1. **Imagem de contêiner** – Contém o sistema operacional de base, o tempo de execução, as extensões do Lambda, o código do seu aplicativo e suas dependências.
Essas configurações do aplicativo podem ser definidas ao inicializar um aplicativo usando o `sam init`.
+ Para saber mais sobre o uso do `sam init`, consulte [Crie seu aplicativo em AWS SAM](using-sam-cli-init.md).
+ Para saber mais sobre como definir essas configurações em seu aplicativo, consulte [Compilação padrão com AWS SAM](serverless-sam-cli-using-build.md).
**Para construir um aplicativo**
1. `cd` até a raiz do seu projeto. Esse é o mesmo local do seu AWS SAM modelo.
```
$ cd sam-app
```
1. Execute o seguinte:
```
sam-app $ sam build
```
**nota**
Uma opção comumente usada é o `--use-container`. Para saber mais, consulte [Construindo uma função do Lambda dentro de um contêiner fornecido](#using-sam-cli-build-options-container).
A seguir, veja um exemplo de saída do AWS SAM CLI:
```
sam-app $ sam build
Starting Build use cache
Manifest file is changed (new hash: 3298f1304...d4d421) or dependency folder (.aws-sam/deps/4d3dfad6-a267-47a6-a6cd-e07d6fae318c) is missing for (HelloWorldFunction), downloading dependencies and copying/building source
Building codeuri: /Users/.../sam-app/hello_world runtime: python3.12 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CleanUp
Running PythonPipBuilder:ResolveDependencies
Running PythonPipBuilder:CopySource
Running PythonPipBuilder:CopySource
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
1. O AWS SAMCLI cria um diretório de compilação `.aws-sam`. Veja um exemplo a seguir:
```
.aws-sam
├── build
│ ├── HelloWorldFunction
│ │ ├── __init__.py
│ │ ├── app.py
│ │ └── requirements.txt
│ └── template.yaml
└── build.toml
```
Dependendo de como seu aplicativo está configurado, o AWS SAMCLI faz o seguinte:
1. Faz o download, instala e organiza as dependências no diretório `.aws-sam/build`.
1. Prepara seu código Lambda. Isso pode incluir compilar seu código, criar binários executáveis e criar imagens de contêiner.
1. Copia artefatos de construção para o diretório `.aws-sam`. O formato variará de acordo com o tipo de pacote do aplicativo.
1. Para tipos de pacotes.zip, os artefatos ainda não foram compactados para que possam ser usados para testes locais. O AWS SAMCLI fecha seu aplicativo ao usar o `sam deploy`.
1. Para tipos de pacote de imagem de contêiner, uma imagem de contêiner é criada localmente e referenciada no arquivo `.aws-sam/build.toml`.
1. Copia o AWS SAM modelo para o `.aws-sam` diretório e o modifica com novos caminhos de arquivo quando necessário.
A seguir estão os principais componentes que compõem seus artefatos de construção no diretório `.aws-sam`:
+ **O diretório de construção** — contém suas funções e camadas do Lambda estruturadas independentemente umas das outras. Isso resulta em uma estrutura exclusiva para cada função ou camada no diretório `.aws-sam/build`.
+ **O AWS SAM modelo** — Modificado com valores atualizados com base nas alterações durante o processo de criação.
+ **O arquivo build.toml — Um arquivo** de configuração que contém as configurações de compilação usadas pelo. AWS SAMCLI
## Teste e implantação locais
Ao realizar testes locais com o `sam local` ou implantar com o `sam deploy`, o AWS SAMCLI faz o seguinte:
1. Primeiro, ele verifica se existe um `.aws-sam` diretório e se um AWS SAM modelo está localizado dentro desse diretório. Se essas condições forem atendidas, o AWS SAMCLI considerará como o diretório raiz do seu aplicativo.
1. Se essas condições não forem atendidas, o AWS SAMCLI considera o local original do seu AWS SAM modelo como o diretório raiz do seu aplicativo.
Ao desenvolver, se forem feitas alterações nos arquivos originais do aplicativo, execute `sam build` para atualizar o diretório `.aws-sam` antes de testar localmente.
## Práticas recomendadas
+ Não edite nenhum código no diretório `.aws-sam/build`. Em vez disso, atualize o código-fonte original na pasta do projeto e execute `sam build` para atualizar o diretório `.aws-sam/build`.
+ Ao modificar seus arquivos originais, execute `sam build` para atualizar o diretório `.aws-sam/build`.
+ Talvez você queira que o AWS SAMCLI referencie o diretório raiz original do seu projeto em vez do diretório `.aws-sam`, como ao desenvolver e testar com o `sam local`. Exclua o `.aws-sam` diretório ou o AWS SAM modelo no `.aws-sam` diretório para que ele AWS SAMCLI reconheça o diretório original do projeto como o diretório raiz do projeto. Quando estiver pronto, execute `sam build` novamente para criar o diretório `.aws-sam`.
+ Quando você executa o `sam build`, o diretório `.aws-sam/build` é sobrescrito a cada vez. O diretório `.aws-sam` não. Se você quiser armazenar arquivos, como registros, armazene-os no `.aws-sam` para evitar que sejam sobrescritos.
## Opções para sam build
### Criar um único recurso
Forneça a ID lógica do recurso para criar somente esse recurso. Este é um exemplo:
```
$ sam build HelloWorldFunction
```
Para criar um recurso de uma pilha ou aplicativo aninhado, forneça o ID lógico do aplicativo ou da pilha junto com o ID lógico do recurso usando o formato `/`:
```
$ sam build MyNestedStack/MyFunction
```
### Construindo uma função do Lambda dentro de um contêiner fornecido
A opção `--use-container` baixa uma imagem de contêiner e a usa para criar suas funções do Lambda. O contêiner local é então referenciado em seu arquivo `.aws-sam/build.toml`.
Esta opção requer Docker instalação. Para obter instruções, consulte [Instalação do Docker](install-docker.md).
A seguir está um exemplo deste comando:
```
$ sam build --use-container
```
Você pode especificar a imagem do contêiner a ser usada com a opção `--build-image`. Veja um exemplo a seguir:
```
$ sam build --use-container --build-image amazon/aws-sam-cli-build-image-nodejs20.x
```
Para especificar a imagem do contêiner a ser usada para uma única função, forneça o ID lógico da função. Veja um exemplo a seguir:
```
$ sam build --use-container --build-image Function1=amazon/aws-sam-cli-build-image-python3.12
```
### Passe variáveis de ambiente para o contêiner de build
Use o `--container-env-var` para passar variáveis de ambiente para o contêiner de build. Veja um exemplo a seguir:
```
$ sam build --use-container --container-env-var Function1.GITHUB_TOKEN= --container-env-var GLOBAL_ENV_VAR=
```
Para passar variáveis de ambiente de um arquivo, use a opção `--container-env-var-file`. Veja um exemplo a seguir:
```
$ sam build --use-container --container-env-var-file
```
Exemplo do arquivo `env.json`:
```
{
"MyFunction1": {
"GITHUB_TOKEN": "TOKEN1"
},
"MyFunction2": {
"GITHUB_TOKEN": "TOKEN2"
}
}
```
### Acelere a criação de aplicativos que contêm várias funções
Quando você executa `sam build` em um aplicativo com várias funções, o AWS SAMCLI cria uma função de cada vez. Para acelerar o processo de criação, use a opção `--parallel`. Isso cria todas as suas funções e camadas ao mesmo tempo.
A seguir está um exemplo deste comando:
```
$ sam build —-parallel
```
### Acelere os tempos de compilação criando seu projeto na pasta de origem.
Para runtimes e métodos de compilação compatíveis, você pode usar a opção `--build-in-source` de criar seu projeto diretamente na pasta de origem. Por padrão, eles AWS SAM CLI são compilados em um diretório temporário, o que envolve a cópia do código-fonte e dos arquivos do projeto. Com`--build-in-source`, AWS SAM CLI as compilações diretamente na sua pasta de origem, o que acelera o processo de compilação ao eliminar a necessidade de copiar arquivos para um diretório temporário.
Para ver uma lista de runtimes compatíveis, consulte `--build-in-source`.
## Solução de problemas
Para solucionar o problema do AWS SAMCLI, consulte[AWS SAM CLI solução de problemas](sam-cli-troubleshooting.md).
## Exemplos
### Criação de um aplicativo que usa um tempo de execução nativo e um tipo de pacote.zip
Para este exemplo, consulte [Tutorial: implante um aplicativo Hello World com AWS SAM](serverless-getting-started-hello-world.md).
### Criação de um aplicativo que usa um tempo de execução nativo e um tipo de pacote de imagem
Primeiro, executamos `sam init` para inicializar um novo aplicativo. Durante o fluxo interativo, selecionamos o tipo de pacote `Image`. Veja um exemplo a seguir:
```
$ sam init
...
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
4 - Scheduled task
5 - Standalone function
6 - Data processing
7 - Hello World Example With Powertools
8 - Infrastructure event management
9 - Serverless Connector Hello World Example
10 - Multi-step workflow with Connectors
11 - Lambda EFS example
12 - DynamoDB Example
13 - Machine Learning
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
...
10 - java8
11 - nodejs20.x
12 - nodejs18.x
13 - nodejs16.x
...
Runtime: 12
What package type would you like to use?
1 - Zip
2 - Image
Package type: 2
Based on your selections, the only dependency manager available is npm.
We will proceed copying the template using npm.
Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER
Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER
Project name [sam-app]: ENTER
Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment)
-----------------------
Generating application:
-----------------------
Name: sam-app
Base Image: amazon/nodejs18.x-base
Architectures: x86_64
Dependency Manager: npm
Output Directory: .
Configuration file: sam-app/samconfig.toml
Next steps can be found in the README file at sam-app/README.md
...
```
O AWS SAMCLI inicializa um aplicativo e cria o seguinte diretório de projeto:
```
sam-app
├── README.md
├── events
│ └── event.json
├── hello-world
│ ├── Dockerfile
│ ├── app.mjs
│ ├── package.json
│ └── tests
│ └── unit
│ └── test-handler.mjs
├── samconfig.toml
└── template.yaml
```
Em seguida, executamos `sam build` para criar nosso aplicativo:
```
sam-app $ sam build
Building codeuri: /Users/.../build-demo/sam-app runtime: None metadata: {'DockerTag': 'nodejs18.x-v1', 'DockerContext': '/Users/.../build-demo/sam-app/hello-world', 'Dockerfile': 'Dockerfile'} architecture: arm64 functions: HelloWorldFunction
Building image for HelloWorldFunction function
Setting DockerBuildArgs: {} for HelloWorldFunction function
Step 1/4 : FROM public.ecr.aws/lambda/nodejs:18
---> f5b68038c080
Step 2/4 : COPY app.mjs package*.json ./
---> Using cache
---> 834e565aae80
Step 3/4 : RUN npm install
---> Using cache
---> 31c2209dd7b5
Step 4/4 : CMD ["app.lambdaHandler"]
---> Using cache
---> 2ce2a438e89d
Successfully built 2ce2a438e89d
Successfully tagged helloworldfunction:nodejs18.x-v1
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
### Como construir um aplicativo que inclua uma linguagem de programação compilada
Neste exemplo, criamos um aplicativo que contém uma função do Lambda usando o tempo de execução Go.
Primeiro, inicializamos um novo aplicativo usando `sam init` e configuramos nosso aplicativo para usar Go:
```
$ sam init
...
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
...
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
...
4 - dotnetcore3.1
5 - go1.x
6 - go (provided.al2)
...
Runtime: 5
What package type would you like to use?
1 - Zip
2 - Image
Package type: 1
Based on your selections, the only dependency manager available is mod.
We will proceed copying the template using mod.
Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER
Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER
Project name [sam-app]: ENTER
Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment)
-----------------------
Generating application:
-----------------------
Name: sam-app
Runtime: go1.x
Architectures: x86_64
Dependency Manager: mod
Application Template: hello-world
Output Directory: .
Configuration file: sam-app/samconfig.toml
Next steps can be found in the README file at sam-app-go/README.md
...
```
O AWS SAMCLI inicializa o aplicativo. A seguir está um exemplo da estrutura de diretórios do aplicativo:
```
sam-app
├── Makefile
├── README.md
├── events
│ └── event.json
├── hello-world
│ ├── go.mod
│ ├── go.sum
│ ├── main.go
│ └── main_test.go
├── samconfig.toml
└── template.yaml
```
Nós referenciamos o arquivo `README.md` para os requisitos desse aplicativo.
```
...
## Requirements
* AWS CLI already configured with Administrator permission
* [Docker installed](https://www.docker.com/community-edition)
* [Golang](https://golang.org)
* SAM CLI - [Install the SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html)
...
```
Em seguida, executamos `sam local invoke` para testar nossa função. Esse comando comete um erro, pois Go não está instalado em nossa máquina local:
```
sam-app $ sam local invoke
Invoking hello-world (go1.x)
Local image was not found.
Removing rapid images for repo public.ecr.aws/sam/emulation-go1.x
Building image.................................................................................................................................................................................................................................................
Using local image: public.ecr.aws/lambda/go:1-rapid-x86_64.
Mounting /Users/.../Playground/build/sam-app/hello-world as /var/task:ro,delegated inside runtime container
START RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31 Version: $LATEST
fork/exec /var/task/hello-world: no such file or directory: PathError
null
END RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31
REPORT RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31 Init Duration: 0.88 ms Duration: 175.75 ms Billed Duration: 176 ms Memory Size: 128 MB Max Memory Used: 128 MB
{"errorMessage":"fork/exec /var/task/hello-world: no such file or directory","errorType":"PathError"}%
```
A seguir `sam build`, executamos para construir nosso aplicativo. Encontramos um erro porque Go não está instalado em sua máquina local:
```
sam-app $ sam build
Starting Build use cache
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../Playground/build/sam-app/hello-world runtime: go1.x metadata: {} architecture: x86_64 functions: HelloWorldFunction
Build Failed
Error: GoModulesBuilder:Resolver - Path resolution for runtime: go1.x of binary: go was not successful
```
Embora pudéssemos configurar nossa máquina local para criar adequadamente nossa função, usamos a opção `--use-container` com `sam build`. Ele AWS SAMCLI baixa uma imagem de contêiner, cria nossa função usando o nativo GoModulesBuilder e copia o binário resultante em nosso `.aws-sam/build/HelloWorldFunction` diretório.
```
sam-app $ sam build --use-container
Starting Build use cache
Starting Build inside a container
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../build/sam-app/hello-world runtime: go1.x metadata: {} architecture: x86_64 functions: HelloWorldFunction
Fetching public.ecr.aws/sam/build-go1.x:latest-x86_64 Docker container image.....................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
Mounting /Users/.../build/sam-app/hello-world as /tmp/samcli/source:ro,delegated inside runtime container
Running GoModulesBuilder:Build
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
A seguir está um exemplo do diretório `.aws-sam`:
```
.aws-sam
├── build
│ ├── HelloWorldFunction
│ │ └── hello-world
│ └── template.yaml
├── build.toml
├── cache
│ └── c860d011-4147-4010-addb-2eaa289f4d95
│ └── hello-world
└── deps
```
Em seguida, executamos `sam local invoke`. Nossa função foi invocada com sucesso:
```
sam-app $ sam local invoke
Invoking hello-world (go1.x)
Local image is up-to-date
Using local image: public.ecr.aws/lambda/go:1-rapid-x86_64.
Mounting /Users/.../Playground/build/sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated inside runtime container
START RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479 Version: $LATEST
END RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479
REPORT RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479 Init Duration: 1.20 ms Duration: 1782.46 ms Billed Duration: 1783 ms Memory Size: 128 MB Max Memory Used: 128 MB
{"statusCode":200,"headers":null,"multiValueHeaders":null,"body":"Hello, 72.21.198.67\n"}%
```
## Saiba mais
Para obter mais informações sobre como usar o comando`sam build`, consulte:
+ **[Learning AWS SAM: sam build](https://www.youtube.com/watch?v=fDhYKp4op_g)** — Série Serverless Land “Learning AWS SAM” sobre. YouTube
+ **[Learning AWS SAM \$1 sam build \$1 E3](https://www.youtube.com/watch?v=vsAvRyLnB7Y)** — Série “Learning AWS SAM” da Serverless Land sobre. YouTube
+ **[AWS SAM build: como ele fornece artefatos para implantação (Sessões com SAM S2E8) — Sessões](https://www.youtube.com/watch?v=bNbBd6XoDHg)** com séries ativadas. AWS SAM YouTube
+ **[AWS SAM compilações personalizadas: Como usar Makefiles para personalizar compilações no SAM (S2E9) — Sessões](https://www.youtube.com/watch?v=wpccutnSbAk)** com séries ativadas. AWS SAM YouTube
# Compilação padrão com AWS SAM
Para criar seu aplicativo sem servidor, use o comando `sam build`. Esse comando também reúne os artefatos de construção das dependências do seu aplicativo e os coloca no formato e no local adequados para as próximas etapas, como teste, empacotamento e implantação locais.
Você especifica as dependências do seu aplicativo em um arquivo de manifesto, como `requirements.txt` (Python) `package.json` ou (Node.js), ou usando `Layers` a propriedade de um recurso de função. A propriedade `Layers` contém uma lista de recursos de [camada AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) dos quais a função do Lambda depende.
O formato dos artefatos de construção do seu aplicativo depende da propriedade `PackageType` de cada função. As opções para essa propriedade são:
+ **`Zip`** – Um arquivo .zip inclui o código da aplicação e as dependências dele. Se você empacotar seu código como um arquivo.zip, você deve especificar um runtime do Lambda para sua função.
+ **`Image`** – Uma imagem de contêiner inclui o sistema operacional de base, o runtime, as extensões, o código da aplicação e dependências dele.
Para obter informações sobre os tipos de pacotes do Lambda, consulte [Pacotes de implantação do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) no *Guia do desenvolvedor do AWS Lambda *.
**Topics**
+ [Criando um arquivo .zip](#build-zip-archive)
+ [Criar uma imagem de contêiner](#build-container-image)
+ [As variáveis de ambiente do contêiner](#serverless-sam-cli-using-container-environment-file)
+ [Acelere os tempos de compilação criando seu projeto na pasta de origem.](#serverless-sam-cli-using-build-in-source)
+ [Exemplos](#building-applications-examples)
+ [Funções de construção fora do AWS SAM](#building-applications-skip)
## Criando um arquivo .zip
Para criar seu aplicativo sem servidor como um arquivo.zip, você deve declarar `PackageType: Zip` sua função sem servidor.
AWS SAM cria seu aplicativo para a [arquitetura](sam-resource-function.md#sam-function-architectures) que você especifica. Se você não especificar uma arquitetura, AWS SAM usa `x86_64` por padrão.
Se sua função do Lambda depender de pacotes que tenham programas compilados de forma nativa, use o sinalizador `--use-container`. Essa sinalização compila localmente suas funções em um contêiner que se comporta como um ambiente Lambda, para que elas estejam no formato certo quando você as implanta na nuvem. AWS
Quando você usa a `--use-container` opção, por padrão, AWS SAM extrai a imagem do contêiner do [Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/public/what-is-ecr.html) Public. Se quiser extrair uma imagem de contêiner de outro repositório ou de uma versão específica da AWS SAM CLI, você pode usar a opção e fornecer `--build-image` o URI de uma imagem de contêiner alternativa. Veja a seguir dois exemplos de comandos para criar aplicativos usando imagens de contêiner de uma versão específica da AWS SAM CLI:
```
# Build a Node.js 20 application using a container image for a specific version of AWS SAM CLI (1.136.0)
sam build --use-container --build-image public.ecr.aws/sam/build-nodejs22.x:1.136.0
# Build a function resource using the Python 3.13 container image from a specific version of AWS SAM CLI (1.136.0)(
sam build --use-container --build-image Function1=public.ecr.aws/sam/build-python3.13:1.136.0
```
Para obter exemplos adicionais de criação de um aplicativo de arquivamento de arquivamento de arquivamento de arquivamento, consulte a seção Exemplos mais adiante neste tópico.
## Criar uma imagem de contêiner
Para criar seu aplicativo sem servidor como uma imagem de contêiner, declare `PackageType: Image` sua função sem servidor. Você também deve declarar o atributo do recurso `Metadata` com as seguintes entradas:
`Dockerfile`
O nome do Dockerfile associado à função do Lambda.
`DockerContext`
A localização do Dockerfile.
`DockerTag`
(Opcional) Uma tag a ser aplicada à imagem criada.
`DockerBuildArgs`
Crie argumentos para a construção.
A CLI do AWS SAM não oculta nem ofusca quaisquer informações incluídas nos argumentos `DockerBuildArgs`. É altamente recomendável não usar essa seção para armazenar informações confidenciais, como senhas ou segredos.
Veja a seguir um exemplo de seção `Metadata` de atributo de recurso:
```
Metadata:
Dockerfile: Dockerfile
DockerContext: ./hello_world
DockerTag: v1
```
Para baixar um exemplo de aplicação configurada com o tipo de pacote `Image`, consulte [Tutorial: implante um aplicativo Hello World com AWS SAM](serverless-getting-started-hello-world.md). No prompt perguntando qual tipo de pacote você deseja instalar, escolha`Image`.
**nota**
Se você especificar uma imagem base de várias arquiteturas em seu Dockerfile, AWS SAM criará sua imagem de contêiner para a arquitetura da sua máquina host. Para criar para uma arquitetura diferente, especifique uma imagem base que use a arquitetura de destino específica.
## As variáveis de ambiente do contêiner
Para fornecer um arquivo JSON que contenha variáveis de ambiente para o contêiner de compilação, use o argumento `--container-env-var-file` com o comando `sam build`. Você pode fornecer uma única variável de ambiente que se aplique a todos os recursos sem servidor ou variáveis de ambiente diferentes para cada recurso.
### Formato
O formato para passar variáveis de ambiente para um contêiner de compilação depende de quantas variáveis de ambiente você fornece para seus recursos.
Para fornecer uma única variável de ambiente para todos os recursos, especifique um `Parameters` objeto como o seguinte:
```
{
"Parameters": {
"GITHUB_TOKEN": "TOKEN_GLOBAL"
}
}
```
Para fornecer variáveis de ambiente diferentes para cada recurso, especifique objetos para cada recurso da seguinte forma:
```
{
"MyFunction1": {
"GITHUB_TOKEN": "TOKEN1"
},
"MyFunction2": {
"GITHUB_TOKEN": "TOKEN2"
}
}
```
Salve suas variáveis de ambiente como um arquivo, por exemplo, chamado `env.json`. O comando a seguir usa esse arquivo para passar suas variáveis de ambiente para o contêiner de compilação:
```
sam build --use-container --container-env-var-file env.json
```
### Precedência
+ As variáveis de ambiente que você fornece para recursos específicos têm precedência sobre a única variável de ambiente para todos os recursos.
+ As variáveis de ambiente que você fornece na linha de comando têm precedência sobre as variáveis de ambiente em um arquivo.
## Acelere os tempos de compilação criando seu projeto na pasta de origem.
Para runtimes e métodos de compilação compatíveis, você pode usar a opção `--build-in-source` de criar seu projeto diretamente na pasta de origem. Por padrão, eles AWS SAM CLI são compilados em um diretório temporário, o que envolve a cópia do código-fonte e dos arquivos do projeto. Com`--build-in-source`, AWS SAM CLI as compilações diretamente na sua pasta de origem, o que acelera o processo de compilação ao eliminar a necessidade de copiar arquivos para um diretório temporário.
Para ver uma lista de runtimes e métodos de compilação compatíveis, consulte `--build-in-source`.
## Exemplos
### Exemplo 1: arquivo .zip
Os comandos `sam build` a seguir criam um arquivo .zip:
```
# Build all functions and layers, and their dependencies
sam build
# Run the build process inside a Docker container that functions like a Lambda environment
sam build --use-container
# Build a Node.js 20 application using a container image for a specific version of AWS SAM CLI (1.136.0)
sam build --use-container --build-image public.ecr.aws/sam/build-nodejs22.x:1.136.0
# Build a function resource using the Python 3.13 container image from a specific version of AWS SAM CLI (1.136.0)(
sam build --use-container --build-image Function1=public.ecr.aws/sam/build-python3.13:1.136.0
# Build and run your functions locally
sam build && sam local invoke
# For more options
sam build --help
```
### Exemplo 2: imagem do contêiner
O AWS SAM modelo a seguir é criado como uma imagem de contêiner:
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
PackageType: Image
ImageConfig:
Command: ["app.lambda_handler"]
Metadata:
Dockerfile: Dockerfile
DockerContext: ./hello_world
DockerTag: v1
```
Veja a seguir um exemplo de Dockerfile:
```
FROM public.ecr.aws/lambda/python:3.12
COPY app.py requirements.txt ./
RUN python3.12 -m pip install -r requirements.txt
# Overwrite the command by providing a different command directly in the template.
CMD ["app.lambda_handler"]
```
### Exemplo 3: npm ci
Para aplicativos Node.js, você pode usar `npm ci` em vez de `npm install` instalar dependências. Para usar `npm ci`, especifique `UseNpmCi: True` debaixo de `BuildProperties` no atributo de recurso `Metadata` da sua função do Lambda. Para ser usado `npm ci`, seu aplicativo deve ter um arquivo `package-lock.json` ou `npm-shrinkwrap.json` presente na `CodeUri` para sua função do Lambda.
O exemplo a seguir é usado `npm ci` para instalar dependências quando você `sam build` executa:
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello-world/
Handler: app.handler
Runtime: nodejs20.x
Architectures:
- x86_64
Events:
HelloWorld:
Type: Api
Properties:
Path: /hello
Method: get
Metadata:
BuildProperties:
UseNpmCi: True
```
### Pacotes principais do Python
Para aplicações do Python, você pode preservar sua estrutura de pacotes durante o processo de criação para permitir importações absolutas. Para preservar a estrutura do pacote, especifique `ParentPackageMode` em `BuildProperties` no atributo de recurso `Metadata` de sua função do Lambda.
O exemplo a seguir preserva a estrutura do pacote `app` quando você executa `sam build`:
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello-world/
Handler: app.main.handler
Runtime: python3.12
Architectures:
- x86_64
Metadata:
BuildProperties:
ParentPackageMode: explicit
ParentPackages: app
```
Com essa configuração, seu código pode usar importações absolutas, como `from app.utils import logger` em vez de importações relativas, como `from .utils import logger`.
## Funções de construção fora do AWS SAM
Por padrão, quando você executa**sam build**, AWS SAM cria todos os seus recursos de função. Outras opções incluem:
+ **Crie todos os recursos de função fora de AWS SAM** — Se você criar todos os seus recursos de função manualmente ou por meio de outra ferramenta, não **sam build** é necessário. Você pode pular **sam build** e passar para a próxima etapa do processo, como realizar testes locais ou implantar seu aplicativo.
+ **Crie alguns recursos de função fora de AWS SAM** — Se você quiser AWS SAM criar alguns de seus recursos de função e ter outros recursos de função criados fora dele AWS SAM, você pode especificar isso em seu AWS SAM modelo.
### Crie alguns recursos funcionais fora do AWS SAM
Para AWS SAM pular uma função durante o uso**sam build**, configure o seguinte em seu AWS SAM modelo:
1. Adicione a propriedade de `SkipBuild: True` metadados à função do.
1. Especifique o caminho para seus recursos de função criados.
Aqui está um exemplo, `TestFunction` configurado para ser ignorado. Seus recursos construídos estão localizados em`built-resources/TestFunction.zip`.
```
TestFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: built-resources/TestFunction.zip
Handler: TimeHandler::handleRequest
Runtime: java11
Metadata:
SkipBuild: True
```
Agora, ao executar**sam build**, AWS SAM fará o seguinte:
1. AWS SAM ignorará as funções configuradas com`SkipBuild: True`.
1. AWS SAM criará todos os outros recursos da função e os armazenará em cache no diretório de `.aws-sam` compilação.
1. Para funções ignoradas, seu modelo no diretório de `.aws-sam` construção será atualizado automaticamente para referenciar o caminho especificado para seus recursos de função criados.
Aqui está um exemplo do modelo `TestFunction` em cache para o diretório de `.aws-sam` compilação:
```
TestFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ../../built-resources/TestFunction.zip
Handler: TimeHandler::handleRequest
Runtime: java11
Metadata:
SkipBuild: True
```
# Personalize construções com AWS SAM
Você pode personalizar a criação para incluir funções específicas ou camadas do Lambda. Uma função é um recurso que você pode invocar para executar o código no Lambda. Uma camada do Lambda permite que você extraia código de uma função do Lambda que pode ser reutilizado em várias funções do Lambda. Você pode optar por personalizar a criação com funções específicas do Lambda quando quiser se concentrar no desenvolvimento e na implantação de funções individuais sem servidor sem a complexidade de gerenciar dependências ou recursos compartilhados. Além disso, você pode optar por criar uma camada do Lambda para ajudar na redução do tamanho dos pacotes de implantação, na separação da lógica da função de núcleo das dependências e na permissão para compartilhar dependências em várias funções.
Os tópicos desta seção exploram algumas das diferentes maneiras pelas quais você pode criar funções Lambda com. AWS SAM Isso inclui a criação de funções do Lambda com os runtimes do cliente e a criação de camadas do Lambda. Os tempos de execução personalizados permitem que você instale e use uma linguagem não listada nos tempos de execução do Lambda no AWS Lambda Guia do desenvolvedor. Isso permite que você crie um ambiente de execução especializado para executar funções e aplicações sem servidor. Criar somente camadas do Lambda (em vez de toda a aplicação) pode trazer benefícios de algumas maneiras. Isso pode ajudar na redução do tamanho dos pacotes de implantação, na separação da lógica da função de núcleo das dependências e na permissão para compartilhar dependências em várias funções.
Para obter mais informações, consulte [Conceitos do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html) no *Guia do desenvolvedor do AWS Lambda *.
**Topics**
+ [Construindo funções Lambda do Node.js com esbuild em AWS SAM](serverless-sam-cli-using-build-typescript.md)
+ [Criação de funções do.NET Lambda com compilação AOT nativa no AWS SAM](build-dotnet7.md)
+ [Construindo funções do Rust Lambda com o Cargo Lambda AWS SAM](building-rust.md)
+ [Construindo funções Python Lambda com o uv AWS SAM](building-python-uv.md)
+ [Criação de funções Lambda com tempos de execução personalizados no AWS SAM](building-custom-runtimes.md)
+ [Construindo camadas Lambda em AWS SAM](building-layers.md)
# Construindo funções Lambda do Node.js com esbuild em AWS SAM
Para criar e empacotar AWS Lambda as funções do Node.js, você pode usar o AWS SAMCLI com o JavaScript bundler esbuild. O bundler esbuild oferece suporte às funções Lambda nas quais você escreve. TypeScript
Para criar uma função do Lambda Node.js com esbuild, adicione um objeto `Metadata` ao seu recurso `AWS:Serverless::Function` e especifique `esbuild` para `BuildMethod`. Quando você executa o **sam build** comando, AWS SAM usa o esbuild para agrupar o código da função Lambda.
## Propriedades de metadados
O objeto `Metadata` é compatível com as seguintes propriedades para esbuild.
### BuildMethod
Especifica o empacotador do aplicativo. O único valor aceito é `esbuild`.
### BuildProperties
Especifica as propriedades de construção do código da função do Lambda.
O objeto `BuildProperties` é compatível com as seguintes propriedades para esbuild. Todas as propriedades são opcionais. Por padrão, AWS SAM usa seu manipulador de funções Lambda como ponto de entrada.
**EntryPoints**
Especifica pontos de entrada para seu aplicativo.
**Externo**
Especifica a lista de pacotes a serem omitidos da compilação. Para obter mais informações, consulte [Externo](https://esbuild.github.io/api/#external) no *site da esbuild*.
**Formato**
Especifica o formato de saída dos JavaScript arquivos gerados em seu aplicativo. Para obter mais informações, consulte [Formato](https://esbuild.github.io/api/#format) no *site do esbuild*.
**Carregador**
Especifica a lista de configurações para carregar dados de um determinado tipo de arquivo.
**MainFields**
Especifica quais campos `package.json` tentar importar ao resolver um pacote. O valor padrão é `main,module`.
**Minimizar**
Especifica se o código de saída incluído deve ser minimizado. O valor padrão é `true`.
**OutExtension**
Personalize a extensão dos arquivos que o esbuild gera. Para obter mais informações, consulte [Extensão de saída](https://esbuild.github.io/api/#out-extension) no *site da esbuild*.
**Mapa de origem**
Especifica se o bundler produz um arquivo de mapa de origem. O valor padrão é `false`.
Quando definido como `true`, `NODE_OPTIONS: --enable-source-maps` é anexado às variáveis de ambiente da função do Lambda e um mapa de origem é gerado e incluído na função.
Como alternativa, quando `NODE_OPTIONS: --enable-source-maps` é incluído nas variáveis de ambiente da função, `Sourcemap` é automaticamente definido como `true`.
Quando conflitante, `Sourcemap: false` tem precedência sobre `NODE_OPTIONS: --enable-source-maps`.
Por padrão, o Lambda criptografa todas as variáveis de ambiente em repouso com AWS Key Management Service (AWS KMS). Ao usar mapas de origem, para que a implantação seja bem-sucedida, a função de execução da sua função deve ter permissão para realizar a ação `kms:Encrypt`.
**SourcesContent**
Especifica se o código-fonte deve ser incluído no arquivo do mapa de origem. Configure essa propriedade quando `Sourcemap` estiver definido como `'true'`.
+ Especifique `SourcesContent: 'true'` para incluir todo o código-fonte.
+ Especifique `SourcesContent: 'false'` para excluir todo o código-fonte. Isso resulta em tamanhos menores de arquivos de mapas de origem, o que é útil na produção ao reduzir os tempos de inicialização. No entanto, o código-fonte não estará disponível no depurador.
O valor padrão é `SourcesContent: true`.
Para obter mais informações, consulte [Conteúdo de fontes](https://esbuild.github.io/api/#sources-content) no *site esbuild*.
**Destino**
Especifica a ECMAScript versão de destino. O valor padrão é `es2020`.
## TypeScript Exemplo de função Lambda
O exemplo de trecho AWS SAM de modelo a seguir usa esbuild para criar uma função Lambda Node.js a partir do código em. TypeScript `hello-world/app.ts`
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello-world/
Handler: app.handler
Runtime: nodejs20.x
Architectures:
- x86_64
Events:
HelloWorld:
Type: Api
Properties:
Path: /hello
Method: get
Environment:
Variables:
NODE_OPTIONS: --enable-source-maps
Metadata:
BuildMethod: esbuild
BuildProperties:
Format: esm
Minify: false
OutExtension:
- .js=.mjs
Target: "es2020"
Sourcemap: true
EntryPoints:
- app.ts
External:
- ""
```
# Criação de funções do.NET Lambda com compilação AOT nativa no AWS SAM
Crie e empacote suas AWS Lambda funções do.NET 8 com o AWS Serverless Application Model (AWS SAM), utilizando a compilação nativa Ahead-of-Time (AOT) para melhorar AWS Lambda os tempos de inicialização a frio.
**Topics**
+ [Visão geral da AOT nativa do .NET 8](#build-dotnet7-overview)
+ [Usando AWS SAM com suas funções Lambda do.NET 8](#build-dotnet7-sam)
+ [Pré-requisitos de instalação](#build-dotnet7-prerequisites)
+ [Defina as funções Lambda do.NET 8 em seu modelo AWS SAM](#build-dotnet7-sam-define)
+ [Crie seu aplicativo com o AWS SAMCLI](#build-dotnet7-sam-build)
+ [Saiba mais](#build-dotnet7-learn-more)
## Visão geral da AOT nativa do .NET 8
Historicamente, as funções .NET Lambda têm tempos de inicialização a frio que afetam a experiência do usuário, a latência do sistema e os custos de uso de seus aplicativos sem servidor. Com a compilação AOT nativa do.NET, você pode melhorar os tempos de inicialização a frio das suas funções do Lambda. Para saber mais sobre o AOT nativo para.NET 8, consulte [Usando o AOT nativo no repositório GitHub ](https://github.com/dotnet/runtime/tree/main/src/coreclr/nativeaot#readme) *Dotnet*.
## Usando AWS SAM com suas funções Lambda do.NET 8
Faça o seguinte para configurar as funções do Lambda com .NET 8 com o AWS Serverless Application Model (AWS SAM):
+ Instale os pré-requisitos em sua máquina de desenvolvimento.
+ Defina as funções Lambda do.NET 8 em seu AWS SAM modelo.
+ Crie seu aplicativo com AWS SAMCLI o.
## Pré-requisitos de instalação
Os seguintes pré-requisitos são exigidos:
+ O AWS SAMCLI
+ .NET Core CLI
+ Amazon.Lambda.Tools .NET Core Global Tool
+ Docker
**Instale o AWS SAM CLI**
1. Para verificar se você já tem AWS SAMCLI instalado, execute o seguinte:
```
sam --version
```
1. Para instalar o AWS SAMCLI, consulte[Instale o AWS SAM CLI](install-sam-cli.md).
1. Para atualizar uma versão instalada do AWS SAMCLI, consulte[Atualizar o AWS SAM CLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade).
**Instalado o .NET Core CLI**
1. Para fazer download e instalar a .NET Core CLI, consulte [Download .NET](https://dotnet.microsoft.com/download) do website da Microsoft.
1. *Para obter mais informações sobre a CLI do.NET Core, consulte [.NET Core CLI](https://docs.aws.amazon.com/lambda/latest/dg/csharp-package-cli.html) no AWS Lambda Guia do Desenvolvedor*.
**Instale o Amazon.Lambda.Tools .NET Core Global Tool**
1. Execute este comando: .
```
dotnet tool install -g Amazon.Lambda.Tools
```
1. Se você já tiver a ferramenta instalada, certifique-se de que esteja usando a versão mais recente com o seguinte comando:
```
dotnet tool update -g Amazon.Lambda.Tools
```
1. Para obter mais informações sobre a ferramenta global Amazon.Lambda.Tools .NET Core, consulte o repositório Extensions [AWS for](https://github.com/aws/aws-extensions-for-dotnet-cli) .NET CLI em. GitHub
**Instalar o Docker**
+ Construir com AOT nativo, precisa que Docker seja instalado. Para obter instruções de instalação, consulte [Instalando o Docker para usar com o AWS SAMCLI](install-docker.md).
## Defina as funções Lambda do.NET 8 em seu modelo AWS SAM
Para definir um. NET8 Função Lambda em seu AWS SAM modelo, faça o seguinte:
1. Execute o seguinte comando em um diretório inicial de sua escolha:
```
sam init
```
1. Selecione `AWS Quick Start Templates` para escolher um modelo inicial.
1. Escolha o modelo `Hello World Example`.
1. Escolha não usar o runtime e o tipo de pacote mais populares inserindo `n`.
1. Em runtime, escolha `dotnet8`.
1. Em tipo de pacote, escolha `Zip`.
1. Em modelo inicial, escolha `Hello World Example using native AOT`.
**Instalar o Docker**
+ Construir com AOT nativo, precisa que Docker seja instalado. Para obter instruções de instalação, consulte [Instalando o Docker para usar com o AWS SAMCLI](install-docker.md).
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./src/HelloWorldAot/
Handler: bootstrap
Runtime: dotnet8
Architectures:
- x86_64
Events:
HelloWorldAot:
Type: Api
Properties:
Path: /hello
Method: get
```
**nota**
Quando a `Event` propriedade de um `AWS::Serverless::Function` é definida como`Api`, mas a `RestApiId` propriedade não é especificada, AWS SAM gera o `AWS::ApiGateway::RestApi` CloudFormation recurso.
## Crie seu aplicativo com o AWS SAMCLI
No diretório raiz do seu projeto, execute o comando `sam build` para começar a criar sua aplicação. Se a propriedade `PublishAot` tiver sido definida no arquivo de projeto do .NET 8, a CLI do AWS SAM será criada com a compilação AOT nativa. Para saber mais sobre a propriedade `PublishAot`, consulte [Implantação nativa de AOT](https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/) na documentação *.NET* da Microsoft.
Para criar a sua função, AWS SAM CLI invoca a CLI do .NET Core CLI, que usa a ferramenta Amazon.Lambda.Lambda.Tools .NET Core Global.
**nota**
Ao criar, se um arquivo `.sln` existir no mesmo diretório ou no diretório principal do seu projeto, o diretório que contém o arquivo `.sln` será montado no contêiner. Se um arquivo `.sln` não for encontrado, somente a pasta do projeto será montada. Portanto, se você estiver criando um aplicativo de vários projetos, verifique se o arquivo `.sln` está localizado na propriedade.
## Saiba mais
Para obter mais informações sobre a criação de funções do Lambda com .NET 8, consulte [Introdução ao runtime do .NET 8 para o AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-net-8-runtime-for-aws-lambda/).
Para obter uma referência do comando **sam build**, consulte [sam build](sam-cli-command-reference-sam-build.md).
# Construindo funções do Rust Lambda com o Cargo Lambda AWS SAM
| |
| --- |
| Esse recurso está na versão prévia AWS SAM e está sujeito a alterações. |
Use a interface de linha de AWS Serverless Application Model comando (AWS SAMCLI) com suas AWS Lambda funções do Rust.
**Topics**
+ [Pré-requisitos](#building-rust-prerequisites)
+ [Configurando AWS SAM para usar com as funções do Rust Lambda](#building-rust-configure)
+ [Exemplos](#building-rust-examples)
## Pré-requisitos
**Linguagem Rust**
Para instalarRust, consulte [Instalar Rust](https://www.rust-lang.org/tools/install) no *Rust site do idioma*.
**Cargo Lambda**
O AWS SAMCLI requer a instalação de um subcomando [https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html](https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html), para Cargo. Para obter instruções, consulte [Instalação](https://www.cargo-lambda.info/guide/installation.html) na *Documentação do Cargo Lambda*.
**Docker**
É necessário criar e testar as Rust funções do Lambda Docker. Para obter instruções de instalação, consulte [Instalação do Docker](install-docker.md).
**Opte pelo recurso AWS SAMCLI beta**
Como esse recurso está em versão prévia, opte por usar um dos seguintes métodos:
1. Use as variáveis de ambiente: `SAM_CLI_BETA_RUST_CARGO_LAMBDA=1`.
1. Adicione o seguinte ao arquivo `samconfig.toml`:
```
[default.build.parameters]
beta_features = true
[default.sync.parameters]
beta_features = true
```
1. Use a opção `--beta-features` ao usar um comando do AWS SAM CLI compatível. Por exemplo:
```
$ sam build --beta-features
```
1. Escolha a opção `y` quando AWS SAM CLI solicitar que você se inscreva. Este é um exemplo:
```
$ sam build
Starting Build use cache
Build method "rust-cargolambda" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
```
## Configurando AWS SAM para usar com as funções do Rust Lambda
### Etapa 1: configurar seu AWS SAM modelo
Configure seu AWS SAM modelo com o seguinte:
+ **Binário** - Opcional. Especifique quando seu modelo contém várias funções do Rust Lambda.
+ **BuildMethod** – `rust-cargolambda`.
+ **CodeUri**— caminho para seu `Cargo.toml` arquivo.
+ **Manipulador** – `bootstrap`.
+ **Tempo de execução** – `provided.al2`.
Para saber mais sobre tempos de execução personalizados, consulte [AWS Lambda Tempos de execução personalizados](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html) no Guia do *AWS Lambda desenvolvedor*.
Aqui está um exemplo de um AWS SAM modelo configurado:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties: function_a
Properties:
CodeUri: ./rust_app
Handler: bootstrap
Runtime: provided.al2
...
```
### Etapa 2: use o AWS SAM CLI com sua função Rust Lambda
Use qualquer AWS SAMCLI comando com seu AWS SAM modelo. Para obter mais informações, consulte [AWS SAM CLI](using-sam-cli.md).
## Exemplos
### Exemplo do Hello World
**Neste exemplo, criamos o aplicativo Hello World de amostra usando Rust como nosso tempo de execução.**
Primeiro, inicializamos um novo aplicativo sem servidor usando o `sam init`. Durante o fluxo interativo, selecionamos o **aplicativo Hello World** e escolhemos o tempo de execução do **Rust**.
```
$ sam init
...
Which template source would you like to use?
1 - AWS Quick Start Templates
2 - Custom Template Location
Choice: 1
Choose an AWS Quick Start application template
1 - Hello World Example
2 - Multi-step workflow
3 - Serverless API
...
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
1 - dotnet8
2 - dotnet6
3 - go (provided.al2)
...
18 - python3.11
19 - python3.10
20 - ruby3.3
21 - ruby3.2
22 - rust (provided.al2)
23 - rust (provided.al2023)
Runtime: 22
Based on your selections, the only Package type available is Zip.
We will proceed to selecting the Package type as Zip.
Based on your selections, the only dependency manager available is cargo.
We will proceed copying the template using cargo.
Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER
Would you like to enable monitoring using CloudWatch Application Insights?
For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER
Project name [sam-app]: hello-rust
-----------------------
Generating application:
-----------------------
Name: hello-rust
Runtime: rust (provided.al2)
Architectures: x86_64
Dependency Manager: cargo
Application Template: hello-world
Output Directory: .
Configuration file: hello-rust/samconfig.toml
Next steps can be found in the README file at hello-rust/README.md
Commands you can use next
=========================
[*] Create pipeline: cd hello-rust && sam pipeline init --bootstrap
[*] Validate SAM template: cd hello-rust && sam validate
[*] Test Function in the Cloud: cd hello-rust && sam sync --stack-name {stack-name} --watch
```
A seguir está a estrutura do nosso aplicativo Hello World:
```
hello-rust
├── README.md
├── events
│ └── event.json
├── rust_app
│ ├── Cargo.toml
│ └── src
│ └── main.rs
├── samconfig.toml
└── template.yaml
```
Em nosso AWS SAM modelo, nossa Rust função é definida da seguinte forma:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
Properties:
CodeUri: ./rust_app
Handler: bootstrap
Runtime: provided.al2
Architectures:
- x86_64
Events:
HelloWorld:
Type: Api
Path: /hello
Method: get
```
Em seguida, executamos `sam build` para criar nosso aplicativo e nos preparar para a implantação. O AWS SAMCLI cria um diretório `.aws-sam` e organiza nossos artefatos de construção lá. Nossa função é construída usando Cargo Lambda e armazenada como um binário executável em `.aws-sam/build/HelloWorldFunction/bootstrap`.
**nota**
Se você planeja executar o comando **sam local invoke** no macOS, precisa criar funções diferentes antes de invocar. Para fazer isso, use o seguinte comando:
**SAM\$1BUILD\$1MODE=debug sam build**
Esse comando só será necessário se for feito um teste local. Isso não é recomendado na criação para implantação.
```
hello-rust$ sam build
Starting Build use cache
Build method "rust-cargolambda" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
Experimental features are enabled for this session.
Visit the docs page to learn more about the AWS Beta terms https://aws.amazon.com/service-terms/.
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../hello-rust/rust_app runtime: provided.al2 metadata: {'BuildMethod': 'rust-cargolambda'} architecture: x86_64 functions: HelloWorldFunction
Running RustCargoLambdaBuilder:CargoLambdaBuild
Running RustCargoLambdaBuilder:RustCopyAndRename
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
Em seguida, implantamos nosso aplicativo usando `sam deploy --guided`.
```
hello-rust$ sam deploy --guided
Configuring SAM deploy
======================
Looking for config file [samconfig.toml] : Found
Reading default arguments : Success
Setting default arguments for 'sam deploy'
=========================================
Stack Name [hello-rust]: ENTER
AWS Region [us-west-2]: ENTER
#Shows you resources changes to be deployed and require a 'Y' to initiate deploy
Confirm changes before deploy [Y/n]: ENTER
#SAM needs permission to be able to create roles to connect to the resources in your template
Allow SAM CLI IAM role creation [Y/n]: ENTER
#Preserves the state of previously provisioned resources when an operation fails
Disable rollback [y/N]: ENTER
HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y
Save arguments to configuration file [Y/n]: ENTER
SAM configuration file [samconfig.toml]: ENTER
SAM configuration environment [default]: ENTER
Looking for resources needed for deployment:
...
Uploading to hello-rust/56ba6585d80577dd82a7eaaee5945c0b 817973 / 817973 (100.00%)
Deploying with following values
===============================
Stack name : hello-rust
Region : us-west-2
Confirm changeset : True
Disable rollback : False
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_IAM"]
Parameter overrides : {}
Signing Profiles : {}
Initiating deployment
=====================
Uploading to hello-rust/a4fc54cb6ab75dd0129e4cdb564b5e89.template 1239 / 1239 (100.00%)
Waiting for changeset to be created..
CloudFormation stack changeset
---------------------------------------------------------------------------------------------------------
Operation LogicalResourceId ResourceType Replacement
---------------------------------------------------------------------------------------------------------
+ Add HelloWorldFunctionHelloW AWS::Lambda::Permission N/A
orldPermissionProd
...
---------------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1681427201/f0ef1563-5ab6-4b07-9361-864ca3de6ad6
Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: y
2023-04-13 13:07:17 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 5.0 seconds)
---------------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
---------------------------------------------------------------------------------------------------------
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation
...
---------------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
---------------------------------------------------------------------------------------------------------
Outputs
---------------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/hello-rust-HelloWorldFunctionRole-10II2P13AUDUY
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/
Key HelloWorldFunction
Description Hello World Lambda Function ARN
Value arn:aws:lambda:us-west-2:012345678910:function:hello-rust-HelloWorldFunction-
yk4HzGzYeZBj
---------------------------------------------------------------------------------------------------------
Successfully created/updated stack - hello-rust in us-west-2
```
Para testar, podemos invocar nossa função do Lambda usando o endpoint da API.
```
$ curl https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/
Hello World!%
```
Para testar nossa função localmente, primeiro garantimos que a propriedade `Architectures` de nossa função corresponda à nossa máquina local.
```
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
Metadata:
BuildMethod: rust-cargolambda # More info about Cargo Lambda: https://github.com/cargo-lambda/cargo-lambda
Properties:
CodeUri: ./rust_app # Points to dir of Cargo.toml
Handler: bootstrap # Do not change, as this is the default executable name produced by Cargo Lambda
Runtime: provided.al2
Architectures:
- arm64
...
```
Como modificamos nossa arquitetura de `x86_64` para `arm64` neste exemplo, executamos `sam build` para atualizar nossos artefatos de construção. Em seguida, executamos `sam local invoke` para invocar localmente nossa função.
```
hello-rust$ sam local invoke
Invoking bootstrap (provided.al2)
Local image was not found.
Removing rapid images for repo public.ecr.aws/sam/emulation-provided.al2
Building image.....................................................................................................................................
Using local image: public.ecr.aws/lambda/provided:al2-rapid-arm64.
Mounting /Users/.../hello-rust/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container
START RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 Version: $LATEST
{"statusCode":200,"body":"Hello World!"}END RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6
REPORT RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 Init Duration: 0.68 ms Duration: 130.63 ms Billed Duration: 131 ms Memory Size: 128 MB Max Memory Used: 128 MB
```
### Projeto de função do Lambda única
**Aqui está um exemplo de um aplicativo sem servidor contendo uma função Rust Lambda.**
Estrutura do diretório do projeto:
```
.
├── Cargo.lock
├── Cargo.toml
├── src
│ └── main.rs
└── template.yaml
```
AWS SAM modelo:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
...
```
### Projeto de função do Lambda Múltipla
**Aqui está um exemplo de um aplicativo sem servidor contendo várias funções do Rust Lambda.**
Estrutura do diretório do projeto:
```
.
├── Cargo.lock
├── Cargo.toml
├── src
│ ├── function_a.rs
│ └── function_b.rs
└── template.yaml
```
AWS SAM modelo:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
FunctionA:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties:
Binary: function_a
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
FunctionB:
Type: AWS::Serverless::Function
Metadata:
BuildMethod: rust-cargolambda
BuildProperties:
Binary: function_b
Properties:
CodeUri: ./
Handler: bootstrap
Runtime: provided.al2
```
Arquivo `Cargo.toml`:
```
[package]
name = "test-handler"
version = "0.1.0"
edition = "2021"
[dependencies]
lambda_runtime = "0.6.0"
serde = "1.0.136"
tokio = { version = "1", features = ["macros"] }
tracing = { version = "0.1", features = ["log"] }
tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] }
[[bin]]
name = "function_a"
path = "src/function_a.rs"
[[bin]]
name = "function_b"
path = "src/function_b.rs"
```
# Construindo funções Python Lambda com o uv AWS SAM
| |
| --- |
| Esse recurso está na versão prévia AWS SAM e está sujeito a alterações. |
Use a AWS Serverless Application Model Command Line Interface (AWS SAMCLI) com uv um rápido instalador e resolvedor de pacotes Python para criar suas funções em Python. AWS Lambda
**Topics**
+ [Pré-requisitos](#building-python-uv-prerequisites)
+ [Configurando AWS SAM para usar com funções Python Lambda e uv](#building-python-uv-configure)
+ [Exemplos](#building-python-uv-examples)
## Pré-requisitos
**Python**
*Para instalar o Python, consulte Baixar o [Python no site do Python](https://www.python.org/downloads/).*
**uv**
AWS SAMCLIRequer a instalação de [https://docs.astral.sh/uv/](https://docs.astral.sh/uv/)um instalador e resolvedor de pacotes Python extremamente rápido. Para obter instruções, consulte [Instalação](https://docs.astral.sh/uv/getting-started/installation/) na *Documentação do uv*.
**Opte pelo recurso AWS SAMCLI beta**
Como esse recurso está em versão prévia, opte por usar um dos seguintes métodos:
1. Use as variáveis de ambiente: `SAM_CLI_BETA_PYTHON_UV=1`.
1. Adicione o seguinte ao arquivo `samconfig.toml`:
```
[default.build.parameters]
beta_features = true
[default.sync.parameters]
beta_features = true
```
1. Use a opção `--beta-features` ao usar um comando do AWS SAM CLI compatível. Por exemplo:
```
$ sam build --beta-features
```
1. Escolha a opção `y` quando AWS SAM CLI solicitar que você se inscreva. Este é um exemplo:
```
$ sam build
Starting Build use cache
Build method "python-uv" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
```
## Configurando AWS SAM para usar com funções Python Lambda e uv
### Etapa 1: configurar seu AWS SAM modelo
Configure seu AWS SAM modelo com o seguinte:
+ **BuildMethod** – `python-uv`.
+ **CodeUri**— caminho para seu diretório de código de função contendo `pyproject.toml` ou`requirements.txt`.
+ **Handler** — seu manipulador de funções (por exemplo,`app.lambda_handler`).
+ **Runtime** — versão de tempo de execução do Python (por exemplo,`python3.12`).
Aqui está um exemplo de um AWS SAM modelo configurado:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
MyFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./my_function
Handler: app.lambda_handler
Runtime: python3.12
Metadata:
BuildMethod: python-uv
...
```
## Exemplos
### Exemplo do Hello World
**Neste exemplo, criamos uma amostra do aplicativo Hello World usando Python uv como gerenciador de pacotes.**
uvpode usar uma `pyproject.toml` ou `requirements.txt` para ler dependências. Se ambos forem fornecidos, `sam build` lerá `requirements.txt` as dependências.
A seguir está a estrutura do nosso aplicativo Hello World:
```
hello-python-uv
├── README.md
├── events
│ └── event.json
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── pyproject.toml
├── samconfig.toml
└── template.yaml
```
Arquivo `pyproject.toml`:
```
[project]
name = "my-function"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = [
"requests>=2.31.0",
"boto3>=1.28.0",
]
```
Em nosso AWS SAM modelo, nossa função Python é definida da seguinte forma:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.12
Architectures:
- x86_64
Metadata:
BuildMethod: python-uv
```
Em seguida, executamos `sam build` para criar nosso aplicativo e nos preparar para a implantação. O AWS SAMCLI cria um diretório `.aws-sam` e organiza nossos artefatos de construção lá. Nossas dependências de função são instaladas usando uv e armazenadas em`.aws-sam/build/HelloWorldFunction/`.
```
hello-python-uv$ sam build
Starting Build use cache
Build method "python-uv" is a beta feature.
Please confirm if you would like to proceed
You can also enable this beta feature with "sam build --beta-features". [y/N]: y
Experimental features are enabled for this session.
Visit the docs page to learn more about the AWS Beta terms https://aws.amazon.com/service-terms/.
Cache is invalid, running build and copying resources for following functions (HelloWorldFunction)
Building codeuri: /Users/.../hello-python-uv/hello_world runtime: python3.12 metadata: {'BuildMethod': 'python-uv'} architecture: x86_64 functions: HelloWorldFunction
Running PythonUvBuilder:UvBuild
Running PythonUvBuilder:CopySource
Build Succeeded
Built Artifacts : .aws-sam/build
Built Template : .aws-sam/build/template.yaml
Commands you can use next
=========================
[*] Validate SAM template: sam validate
[*] Invoke Function: sam local invoke
[*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch
[*] Deploy: sam deploy --guided
```
**nota**
O método de `python-uv` construção é configurado por função na `Metadata` seção. Cada função em seu modelo pode usar um método de construção diferente, permitindo que você misture funções uv `pip` baseadas com funções baseadas no mesmo AWS SAM modelo. Se nenhum método de construção for especificado, `pip` é usado por padrão.
# Criação de funções Lambda com tempos de execução personalizados no AWS SAM
Você pode usar o comando `sam build` para criar tempos de execução personalizados necessários para sua função do Lambda. Você declara a sua função do Lambda para usar um runtime especificando `Runtime: provided` para a função.
Para criar um runtime personalizado, declare o atributo do recurso `Metadata` com uma entrada `BuildMethod: makefile`. Você fornece um makefile personalizado, no qual declara um destino de construção do formulário `build-function-logical-id` que contém os comandos de construção para seu tempo de execução. Seu makefile é responsável por compilar o tempo de execução personalizado, se necessário, e copiar os artefatos de construção no local adequado para as etapas subsequentes do seu fluxo de trabalho. A localização do makefile é especificada pela propriedade `CodeUri` do recurso da função e deve ser nomeada `Makefile`.
## Exemplos
### Exemplo 1: Tempo de execução personalizado para uma função escrita em Rust
**nota**
Recomendamos criar funções do Lambda com Cargo Lambda. Para saber mais, consulte [Construindo funções do Rust Lambda com o Cargo Lambda AWS SAM](building-rust.md).
O AWS SAM modelo a seguir declara uma função que usa um tempo de execução personalizado para uma função Lambda escrita em Rust e `sam build` instrui a execução dos comandos para o destino de compilação. `build-HelloRustFunction`
```
Resources:
HelloRustFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: HelloRust
Handler: bootstrap.is.real.handler
Runtime: provided
MemorySize: 512
CodeUri: .
Metadata:
BuildMethod: makefile
```
O makefile a seguir contém o destino da compilação e os comandos que serão executados. Observe que a propriedade `CodeUri` está definida como `.`, portanto, o makefile deve estar localizado no diretório raiz do projeto (ou seja, o mesmo diretório do arquivo do modelo AWS SAM do aplicativo). O nome do arquivo deve ser `Makefile`.
```
build-HelloRustFunction:
cargo build --release --target x86_64-unknown-linux-musl
cp ./target/x86_64-unknown-linux-musl/release/bootstrap $(ARTIFACTS_DIR)
```
Para obter mais informações sobre como configurar seu ambiente de desenvolvimento para executar o comando `cargo build` no `makefile` anterior, consulte a postagem do blog [Rust Runtime for AWS Lambda](https://aws.amazon.com/blogs/opensource/rust-runtime-for-aws-lambda/).
### Exemplo 2: builder Makefile para Python3.12 (alternativa ao uso do criador agrupado)
Talvez você queira usar uma biblioteca ou módulo que não esteja incluído em um construtor empacotado. Este exemplo mostra um AWS SAM modelo para um tempo de execução do Python3.12 com um construtor de makefile.
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.12
Metadata:
BuildMethod: makefile
```
O makefile a seguir contém o destino da compilação e os comandos que serão executados. Observe que a propriedade `CodeUri` está definida como `hello_world`, portanto, o makefile deve estar localizado na raiz do subdiretório `hello_world` e o nome do arquivo deve ser `Makefile`.
```
build-HelloWorldFunction:
cp *.py $(ARTIFACTS_DIR)
cp requirements.txt $(ARTIFACTS_DIR)
python -m pip install -r requirements.txt -t $(ARTIFACTS_DIR)
rm -rf $(ARTIFACTS_DIR)/bin
```
# Construindo camadas Lambda em AWS SAM
Você pode usar AWS SAM para criar camadas Lambda personalizadas. As camadas do Lambda permitem que você extraia código de uma função do Lambda que pode ser reutilizado em várias funções do Lambda. Criar somente camadas do Lambda (em vez de toda a aplicação) pode trazer benefícios de algumas maneiras. Isso pode ajudar na redução do tamanho dos pacotes de implantação, na separação da lógica da função de núcleo das dependências e na permissão para compartilhar dependências em várias funções. Para obter informações sobre camadas, consulte [Camadas do AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) no *Guia do desenvolvedor do AWS Lambda *.
## Como criar uma camada Lambda no AWS SAM
**nota**
Antes de criar uma camada Lambda, você deve primeiro escrever uma camada Lambda no seu modelo. AWS SAM Para obter informações e exemplos, consulte [Aumente a eficiência usando camadas Lambda com AWS SAM](serverless-sam-cli-layers.md).
Para criar uma camada personalizada, declare-a em seu arquivo de modelo AWS Serverless Application Model (AWS SAM) e inclua uma seção de atributo de `Metadata` recurso com uma `BuildMethod` entrada. Os valores válidos para `BuildMethod` são identificadores de um [AWS Lambda runtime](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html), ou `makefile`. Inclua uma entrada `BuildArchitecture` para especificar as arquiteturas do conjunto de instruções que sua camada suporta. Os valores válidos para `BuildArchitecture` são [arquiteturas dos conjuntos de instruções Lambda](https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html).
Se você especificar `makefile`, forneça o makefile personalizado, onde você declara um destino de construção do formulário `build-layer-logical-id` que contém os comandos de construção para sua camada. Seu makefile é responsável por compilar a camada, se necessário, e copiar os artefatos de construção no local adequado para as etapas subsequentes do seu fluxo de trabalho. A localização do makefile é especificada pela propriedade `ContentUri` do recurso de camada e deve ser nomeada `Makefile`.
**nota**
Quando você cria uma camada personalizada, AWS Lambda depende das variáveis de ambiente para encontrar seu código de camada. Os tempos de execução do Lambda incluem caminhos no diretório `/opt` em que seu código de camada é copiado. A estrutura de pastas de artefatos de construção do seu projeto deve corresponder à estrutura de pastas esperada do runtime para que seu código de camada personalizado possa ser encontrado.
Por exemplo, para Python, você pode colocar seu código no subdiretório `python/`. Para NodeJS, você pode colocar seu código no subdiretório `nodejs/node_modules/`.
Para obter mais informações, consulte [Incluindo dependências de biblioteca em uma camada](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html#configuration-layers-path) no *AWS Lambda Guia do desenvolvedor*.
Veja a seguir um exemplo de seção de atributo de recurso `Metadata`.
```
Metadata:
BuildMethod: python3.12
BuildArchitecture: arm64
```
**nota**
Se você não incluir a seção do atributo do `Metadata` recurso, AWS SAM não cria a camada. Em vez disso, ele copia os artefatos de construção do local especificado na propriedade `CodeUri` do recurso de camada. Para obter mais informações, consulte a propriedade [ContentUri](sam-resource-layerversion.md#sam-layerversion-contenturi) do tipo de recurso `AWS::Serverless::LayerVersion`.
Ao incluir a seção do atributo do `Metadata` recurso, você pode usar o `sam build` comando para criar a camada, tanto como um objeto independente quanto como uma dependência de uma AWS Lambda função.
+ ****Como um objeto independente.**** Talvez você queira criar apenas o objeto de camada, por exemplo, quando estiver testando localmente uma alteração de código na camada e não precisar criar todo o aplicativo. Para criar a camada de forma independente, especifique o recurso da camada com o comando `sam build layer-logical-id`.
+ **Como uma dependência de uma função do Lambda.** Quando você inclui o ID lógico de uma camada na propriedade `Layers` de uma função do Lambda no mesmo arquivo de modelo AWS SAM , a camada é uma dependência dessa função do Lambda. Quando essa camada também inclui uma seção de atributo de recurso `Metadata` com uma entrada `BuildMethod`, você cria a camada criando o aplicativo inteiro com o comando `sam build` ou especificando o recurso da função com o comando `sam build function-logical-id`.
## Exemplos
### Exemplo de modelo 1: Criar uma camada com o ambiente de runtime Python 3.12
O AWS SAM modelo de exemplo a seguir cria uma camada em relação ao ambiente de execução do Python 3.12.
```
Resources:
MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
ContentUri: my_layer
CompatibleRuntimes:
- python3.12
Metadata:
BuildMethod: python3.12 # Required to have AWS SAM build this layer
```
### Exemplo de modelo 2: Crie uma camada usando um makefile personalizado
O AWS SAM modelo de exemplo a seguir usa um personalizado `makefile` para criar a camada.
```
Resources:
MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
ContentUri: my_layer
CompatibleRuntimes:
- python3.12
Metadata:
BuildMethod: makefile
```
O seguinte `makefile` contém o destino da compilação e os comandos que serão executados. Observe que a propriedade `ContentUri` está definida como `my_layer`, portanto, o makefile deve estar localizado na raiz do subdiretório `my_layer` e o nome do arquivo deve ser `Makefile`. Observe também que os artefatos de construção são copiados para o `python/` subdiretório para que AWS Lambda você possa encontrar o código da camada.
```
build-MyLayer:
mkdir -p "$(ARTIFACTS_DIR)/python"
cp *.py "$(ARTIFACTS_DIR)/python"
python -m pip install -r requirements.txt -t "$(ARTIFACTS_DIR)/python"
```
**nota**
Quando o `makefile` é chamado, o destino apropriado é acionado e os artefatos devem ser copiados para a variável ambiental exposta `$ARTIFACTS_DIR`. Para obter mais informações, consulte [aws-lambda-builders em GitHub](https://github.com/aws/aws-lambda-builders/blob/develop/aws_lambda_builders/workflows/custom_make/DESIGN.md).
### Exemplo de comandos sam build
Os comandos `sam build` a seguir criam camadas que incluem as seções de atributos do recurso `Metadata`.
```
# Build the 'layer-logical-id' resource independently
$ sam build layer-logical-id
# Build the 'function-logical-id' resource and layers that this function depends on
$ sam build function-logical-id
# Build the entire application, including the layers that any function depends on
$ sam build
```