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