# Empacotar seu conteúdo de camada
<a name="packaging-layers"></a>

Uma camada do Lambda é um arquivo .zip que pode conter código ou dados adicionais. As camadas geralmente contêm dependências de biblioteca, um [runtime personalizado](runtimes-custom.md) ou arquivos de configuração. 

Esta seção explica como empacotar adequadamente o conteúdo da camada. Para obter mais informações conceituais sobre camadas e por que você pode considerar usá-las, consulte [Gerenciar dependências do Lambda com camadas](chapter-layers.md).

A primeira etapa para criar uma camada é agrupar todo o conteúdo da camada em um arquivo .zip. Devido às funções do Lambda serem executadas no [Amazon Linux](https://docs.aws.amazon.com/linux/al2023/ug/what-is-amazon-linux.html), seu conteúdo da camada deve ser capaz de compilar e criar em um ambiente Linux.

Para garantir que o conteúdo da camada funcione bem em um ambiente do Linux, recomendamos criar o conteúdo da camada usando uma ferramenta como o [Docker](https://docs.docker.com/get-docker).

**Topics**
+ [

## Caminhos da camada para cada runtime do Lambda
](#packaging-layers-paths)

## Caminhos da camada para cada runtime do Lambda
<a name="packaging-layers-paths"></a>

Quando você adiciona uma camada a uma função, o Lambda carrega o conteúdo da camada no diretório `/opt` desse ambiente de execução. Para cada runtime do Lambda, a variável `PATH` já inclui caminhos de pasta específica no diretório `/opt`. Para garantir que o Lambda colete o conteúdo da camada, o arquivo .zip da camada deve ter suas dependências em um dos seguintes caminhos de pasta:

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/packaging-layers.html)

Os exemplos a seguir mostram como você pode estruturar as pastas no seu arquivo .zip da camada.

------
#### [ Node.js ]

**Example estrutura de arquivos do AWS X-Ray SDK for Node.js**  

```
xray-sdk.zip
└ nodejs/node_modules/aws-xray-sdk
```

------
#### [ Python ]

**Example**  

```
python/              # Required top-level directory
└── requests/
└── boto3/
└── numpy/
└── (dependencies of the other packages)
```

------
#### [ Ruby ]

**Example estrutura de arquivos da gem JSON**  

```
json.zip
└ ruby/gems/3.4.0/
               | build_info
               | cache
               | doc
               | extensions
               | gems
               | └ json-2.1.0
               └ specifications
                 └ json-2.1.0.gemspec
```

------
#### [ Java ]

**Example estrutura de arquivos do arquivo JAR do Jackson**  

```
layer_content.zip
└ java
    └ lib
        └ jackson-core-2.17.0.jar
        └ <other potential dependencies>
        └ ...
```

------
#### [ All ]

**Example estrutura de arquivos da biblioteca jq**  

```
jq.zip
└ bin/jq
```

------

Para obter instruções específicas da linguagem sobre como empacotar, criar e adicionar uma camada, consulte as páginas a seguir:
+ **Node.js**: [Trabalho com camadas para funções do Lambda com Node.js](nodejs-layers.md)
+ **Python**: [Como trabalhar com camadas para funções do Lambda em Python](python-layers.md)
+ **Ruby**: [Como trabalhar com camadas em Ruby para funções do Lambda](ruby-layers.md)
+ **Java**: [Como trabalhar com camadas para funções do Lambda em Java](java-layers.md)

Recomendamos **não** usar camadas para gerenciar dependências de funções do Lambda escritas em Go e Rust. Isso ocorre porque as funções do Lambda escritas nessas linguagens são compiladas em um único executável que você fornece ao Lambda ao implantar sua função. Esse executável contém seu código de função compilado, junto com todas as suas dependências. O uso de camadas não apenas complica esse processo, mas também aumenta os tempos de inicialização a frio, pois suas funções precisam carregar manualmente assemblies extras na memória durante a fase inicial.

Para usar dependências externas com funções do Lambda em Go e Rust, inclua-as diretamente em seu pacote de implantação.