Compilação padrão com AWS SAM - AWS Serverless Application Model
Criando um arquivo .zipCriar uma imagem de contêinerAs variáveis de ambiente do contêinerAcelere os tempos de compilação criando seu projeto na pasta de origem.ExemplosFunções de construção fora do AWS SAM

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:

  • 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 tempo de execução do Lambda para sua função.

  • Image – Uma imagem de contêiner inclui o sistema operacional de base, o tempo de execução, as extensões do , 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 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 do Docker 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, por exemplo DockerHub, você pode usar a --build-image opção e fornecer o URI de uma imagem de contêiner alternativa. Veja a seguir dois exemplos de comandos para criar aplicativos usando imagens de contêiner do DockerHub repositório:

# Build a Node.js 20 application using a container image pulled from DockerHub
sam build --use-container --build-image amazon/aws-sam-cli-build-image-nodejs20.x

# Build a function resource using the Python 3.12 container image pulled from DockerHub
sam build --use-container --build-image Function1=amazon/aws-sam-cli-build-image-python3.12

Para obter uma lista de URIs com os quais você pode usar--build-image, veja Repositórios de imagens para AWS SAM qual contém DockerHub URIs para vários tempos de execução compatíveis.

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.

Veja a seguir um exemplo de seção Metadata de atributo de recurso:

    Metadata:
      Dockerfile: Dockerfile
      DockerContext: ./hello_world
      DockerTag: v1

Para baixar um aplicativo de amostra configurado com o tipo de Image pacote, consulte Tutorial: implante um aplicativo Hello World com AWS SAM o Tutorial: Implantando um aplicativo Hello World. No prompt perguntando qual tipo de pacote você deseja instalar, escolhaImage.

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 pulled from DockerHub
sam build --use-container --build-image amazon/aws-sam-cli-build-image-nodejs20.x

# Build a function resource using the Python 3.12 container image pulled from DockerHub
sam build --use-container --build-image Function1=amazon/aws-sam-cli-build-image-python3.12 

# 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

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 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 usosam build, configure o seguinte em seu AWS SAM modelo:

  1. Adicione a propriedade de SkipBuild: True metadados à função do.

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

  1. AWS SAM ignorará as funções configuradas comSkipBuild: True.

  2. AWS SAM criará todos os outros recursos da função e os armazenará em cache no diretório de .aws-sam compilação.

  3. 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