Como trabalhar com camadas para funções do Lambda em Java - AWS Lambda

Como trabalhar com camadas para funções do Lambda em Java

Use camadas do Lambda para empacotar o código e as dependências que você quiser reutilizar em várias funções. As camadas geralmente contêm dependências de biblioteca, um runtime personalizado ou arquivos de configuração. A criação de uma camada envolve três etapas gerais:

  1. Empacotar o conteúdo da sua camada. Isso significa criar um arquivo .zip contendo as dependências que você deseja usar em suas funções.

  2. Criar a camada no Lambda.

  3. Adicionar a camada às suas funções.

Empacotar o conteúdo da sua camada

Para criar uma camada, reúna os pacotes em um arquivo .zip que atenda aos seguintes requisitos:

  • Certifique-se de que a versão Java à qual o Maven ou Gradle se refere seja a mesma versão Java da função que você pretende implantar. Por exemplo, para uma função em Java 21, o comando mvn -v deverá listar o Java 21 na saída.

  • Suas dependências devem ser armazenadas no diretório java/lib, na raiz do arquivo .zip. Para obter mais informações, consulte Caminhos da camada para cada runtime do Lambda.

  • Os pacotes da camada devem ser compatíveis com o Linux. As funções do Lambda são executadas no Amazon Linux.

  • Se a sua camada incluir binários nativos ou arquivos executáveis, estes deverão ter como destino a mesma arquitetura (x86_64 ou arm64) que a sua função.

Você pode criar camadas que contenham bibliotecas Java de terceiros ou seus próprios módulos e pacotes Java. O procedimento a seguir utiliza o Maven. Também é possível utilizar o Gradle para empacotar o conteúdo da camada.

Para criar uma camada com dependências do Maven
  1. Crie um projeto Apache Maven com um arquivo pom.xml que defina suas dependências.

    O exemplo abaixo inclui Jackson Databind para processamento JSON. A seção <build> usa maven-dependency-plugin para criar arquivos JAR distintos para cada dependência, em vez de os agrupar em um único uber-jar. Se quiser criar um uber-jar, use maven-shade-plugin.

    exemplo pom.xml
    <dependencies> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.17.0</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.13.0</version> <configuration> <source>21</source> <target>21</target> <release>21</release> </configuration> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-dependency-plugin</artifactId> <version>3.6.1</version> <executions> <execution> <id>copy-dependencies</id> <phase>package</phase> <goals> <goal>copy-dependencies</goal> </goals> <configuration> <outputDirectory>${project.build.directory}/lib</outputDirectory> </configuration> </execution> </executions> </plugin> </plugins> </build>
  2. Crie o projeto. Esse comando cria todos os arquivos JAR de dependência no diretório target/lib/.

    mvn clean package
  3. Crie a estrutura de diretório necessária para sua camada:

    mkdir -p java/lib
  4. Copie os arquivos JAR de dependências para o diretório java/lib:

    cp target/lib/*.jar java/lib/
  5. Crie um arquivo .zip do conteúdo da camada:

    Linux/macOS
    zip -r layer.zip java/
    PowerShell
    Compress-Archive -Path .\java -DestinationPath .\layer.zip

    A estrutura de diretórios do arquivo zip deve ser assim:

    java/              
    └── lib/
        ├── jackson-databind-2.17.0.jar
        ├── jackson-core-2.17.0.jar
        └── jackson-annotations-2.17.0.jar
    nota

    Garanta que o arquivo .zip inclua o diretório java no nível raiz com lib dentro dele. Essa estrutura garante que o Lambda consiga localizar e importar suas bibliotecas. Cada dependência é mantida como um arquivo JAR distinto, em vez de serem agrupadas em um uber-jar.

Criar a camada no Lambda

Você pode publicar a camada usando a AWS CLI ou o console do Lambda.

AWS CLI

Execute o comando da AWS CLI publish-layer-version para criar a camada do Lambda:

aws lambda publish-layer-version --layer-name my-layer --zip-file fileb://layer.zip --compatible-runtimes java21

O parâmetro runtimes compatíveis é opcional. Quando especificado, o Lambda usa esse parâmetro para filtrar camadas no console do Lambda.

Console
Para criar uma camada (console)
  1. Abra a página Layers (Camadas) do console do Lambda.

  2. Escolha Criar camada.

  3. Escolha Carregar um arquivo .zip e depois carregue o arquivo .zip que você criou anteriormente.

  4. (Opcional) Para ver quais são os runtimes compatíveis, escolha o runtime Java que corresponde à versão do Java que você usou para criar a camada.

  5. Escolha Criar.

Adicionar a camada à função

AWS CLI

Para anexar a camada à função, execute o comando da AWS CLI update-function-configuration . Para o parâmetro --layers use o ARN da camada. O ARN deve especificar a versão (por exemplo, arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1). Para obter mais informações, consulte Camadas e versões da camada.

aws lambda update-function-configuration --function-name my-function --cli-binary-format raw-in-base64-out --layers "arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1"

A opção cli-binary-format será necessária se você estiver usando a AWS CLI versão 2. Para que essa seja a configuração padrão, execute aws configure set cli-binary-format raw-in-base64-out. Para obter mais informações, consulte A AWS CLI comporta opções de linha de comando globais no Guia do usuário da AWS Command Line Interface versão 2.

Console
Para adicionar uma camada a uma função
  1. Abra a página Funções do console do Lambda.

  2. Escolha a função.

  3. Role a tela para baixo até a seção Camadas e depois escolha Adicionar uma camada.

  4. Em Escolher uma camada, selecione Camadas personalizadas e depois escolha a camada.

    nota

    Se você não adicionou um runtime compatível ao criar a camada, ela não estará listada aqui. Em vez disso, você pode especificar o ARN da camada.

  5. Escolha Adicionar.