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á.
# 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
```