# Como trabalhar com camadas para funções do Lambda em Java
<a name="java-layers"></a>

Use [camadas do Lambda](chapter-layers.md) 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](runtimes-custom.md) 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.

1. Criar a camada no Lambda.

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

**Topics**
+ [Empacotar o conteúdo da sua camada](#java-layers-package)
+ [Criar a camada no Lambda](#publishing-layer)
+ [Adicionar a camada à função](#java-layer-adding)

## Empacotar o conteúdo da sua camada
<a name="java-layers-package"></a>

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 25, o comando `mvn -v` deverá listar o Java 25 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](packaging-layers.md#packaging-layers-paths).
+ Os pacotes da camada devem ser compatíveis com o Linux. As funções do Lambda são executadas no Amazon Linux.

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](https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind) para processamento JSON. A seção `<build>` usa [maven-dependency-plugin](https://mvnrepository.com/artifact/org.apache.maven.plugins/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](https://maven.apache.org/plugins/maven-shade-plugin/).  
**Example 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>
   ```

1. Crie o projeto. Esse comando cria todos os arquivos JAR de dependência no diretório `target/lib/`.

   ```
   mvn clean package
   ```

1. Crie a estrutura de diretório necessária para sua camada:

   ```
   mkdir -p java/lib
   ```

1. Copie os arquivos JAR de dependências para o diretório `java/lib`:

   ```
   cp target/lib/*.jar java/lib/
   ```

1. 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
<a name="publishing-layer"></a>

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](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) para criar a camada do Lambda:

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

O parâmetro [runtimes compatíveis](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) é 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](https://console.aws.amazon.com/lambda/home#/layers) (Camadas) do console do Lambda.

1. Escolha **Criar camada**.

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

1. (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.

1. Escolha **Criar**.

------

## Adicionar a camada à função
<a name="java-layer-adding"></a>

------
#### [ AWS CLI ]

Para anexar a camada à função, execute o comando da AWS CLI [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) . 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](chapter-layers.md#lambda-layer-versions).

```
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](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) 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](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda.

1. Escolha a função.

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

1. Em **Escolher uma camada**, selecione **Camadas personalizadas** e depois escolha a camada.
**nota**  
Se você não adicionou um [runtime compatível](https://docs.aws.amazon.com/lambda/latest/api/API_PublishLayerVersion.html#lambda-PublishLayerVersion-request-CompatibleRuntimes) ao criar a camada, ela não estará listada aqui. Em vez disso, você pode especificar o ARN da camada.

1. Escolha **Adicionar**.

------