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 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:

Para obter informações sobre os tipos de pacotes do Lambda, consulte Pacotes de implantação do Lambda no Guia do desenvolvedor do AWS Lambda .

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 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 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:

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. No prompt perguntando qual tipo de pacote você deseja instalar, escolhaImage.

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

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 aplicativos 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 parent_python_packages abaixo BuildProperties no atributo de Metadata recurso da sua função Lambda.

O exemplo a seguir preserva a estrutura do app pacote quando você sam build executa:

Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: hello-world/
      Handler: app.main.handler
      Runtime: python3.12
      Architectures:
        - x86_64
    Metadata:
      BuildProperties:
        parent_python_packages: 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, comofrom .utils import logger.

Funções de construção fora do AWS SAM

Por padrão, quando você executasam build, AWS SAM cria todos os seus recursos de função. Outras opções incluem:

Crie alguns recursos funcionais fora do AWS SAM

Para AWS SAM pular uma função durante o usosam build, configure o seguinte em seu AWS SAM modelo:

Aqui está um exemplo, TestFunction configurado para ser ignorado. Seus recursos construídos estão localizados embuilt-resources/TestFunction.zip.

TestFunction:
  Type: AWS::Serverless::Function
  Properties:
    CodeUri: built-resources/TestFunction.zip
    Handler: TimeHandler::handleRequest
    Runtime: java11
  Metadata:
    SkipBuild: True

Agora, ao executarsam build, AWS SAM fará o seguinte: