# Como trabalhar com camadas para funções do Lambda em Python
<a name="python-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
](#python-layers-package)
+ [

## Criar a camada no Lambda
](#publishing-layer)
+ [

## Adicionar a camada à função
](#python-layer-adding)
+ [

## Aplicação de amostra
](#python-layer-sample-app)

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

Para criar uma camada, reúna os pacotes em um arquivo .zip que atenda aos seguintes requisitos:
+ Crie a camada usando a mesma versão do Python que você planeja usar para a função do Lambda. Por exemplo, se você compilar a camada usando o Python 3.14, use o runtime do Python 3.14 para a função.
+ O arquivo .zip deve incluir um diretório de `python` no nível-raiz.
+ 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 contendo bibliotecas de Python de terceiros instaladas com `pip` (como `requests` ou `pandas`) ou seus próprios módulos e pacotes de Python.

### Dependências de terceiros
<a name="python-layers-third-party-dependencies"></a>

**Para criar uma camada usando pacotes pip**

1. Escolha um dos métodos a seguir para instalar os pacotes `pip` no diretório superior exigido (`python/`):

------
#### [ pip install ]

   Para pacotes de Python puro (como requests ou boto3):

   ```
   pip install requests -t python/
   ```

   Alguns pacotes de Python, como NumPy e Pandas, incluem componentes em C compilados. Se você estiver criando uma camada com esses pacotes no macOS ou no Windows, talvez seja necessário usar este comando para instalar uma roda compatível com Linux:

   ```
   pip install numpy --platform manylinux2014_x86_64 --only-binary=:all: -t python/
   ```

   Para obter mais informações sobre como trabalhar com pacotes de Python que contêm componentes compilados, consulte [Criar pacotes de implantação .zip com bibliotecas nativas](python-package.md#python-package-native-libraries).

------
#### [ requirements.txt ]

   O uso de um arquivo `requirements.txt` ajuda a gerenciar as versões dos pacotes e garantir instalações consistentes.

**Example requirements.txt**  

   ```
   requests==2.31.0
   boto3==1.37.34
   numpy==1.26.4
   ```

   Se o arquivo `requirements.txt` incluir apenas pacotes de Python puro (como requests ou boto3):

   ```
   pip install -r requirements.txt -t python/
   ```

   Alguns pacotes de Python, como NumPy e Pandas, incluem componentes em C compilados. Se você estiver criando uma camada com esses pacotes no macOS ou no Windows, talvez seja necessário usar este comando para instalar uma roda compatível com Linux:

   ```
   pip install -r requirements.txt --platform manylinux2014_x86_64 --only-binary=:all: -t python/
   ```

   Para obter mais informações sobre como trabalhar com pacotes de Python que contêm componentes compilados, consulte [Criar pacotes de implantação .zip com bibliotecas nativas](python-package.md#python-package-native-libraries).

------

1. Compacte o conteúdo do diretório `python`.

------
#### [ Linux/macOS ]

   ```
   zip -r layer.zip python/
   ```

------
#### [ PowerShell ]

   ```
   Compress-Archive -Path .\python -DestinationPath .\layer.zip
   ```

------

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

   ```
   python/              # Required top-level directory
   └── requests/
   └── boto3/
   └── numpy/
   └── (dependencies of the other packages)
   ```
**nota**  
Se você usar um ambiente virtual do Python (venv) para instalar pacotes, a estrutura de diretórios será diferente (por exemplo, `python/lib/python3.x/site-packages`). O Lambda pode localizar e importar os pacotes desde que seu arquivo .zip inclua o diretório `python` no nível-raiz.

### Módulos de Python personalizados
<a name="custom-python-modules"></a>

**Para criar uma camada usando seu próprio código**

1. Crie o diretório superior necessário para a camada:

   ```
   mkdir python
   ```

1. Crie os módulos de Python no diretório `python`. O exemplo de módulo a seguir valida os pedidos confirmando que eles contêm as informações necessárias.  
**Example módulo personalizado: validator.py**  

   ```
   import json
   
   def validate_order(order_data):
       """Validates an order and returns formatted data."""
       required_fields = ['product_id', 'quantity']
       
       # Check required fields
       missing_fields = [field for field in required_fields if field not in order_data]
       if missing_fields:
           raise ValueError(f"Missing required fields: {', '.join(missing_fields)}")
       
       # Validate quantity
       quantity = order_data['quantity']
       if not isinstance(quantity, int) or quantity < 1:
           raise ValueError("Quantity must be a positive integer")
       
       # Format and return the validated data
       return {
           'product_id': str(order_data['product_id']),
           'quantity': quantity,
           'shipping_priority': order_data.get('priority', 'standard')
       }
   
   def format_response(status_code, body):
       """Formats the API response."""
       return {
           'statusCode': status_code,
           'body': json.dumps(body)
       }
   ```

1. Compacte o conteúdo do diretório `python`.

------
#### [ Linux/macOS ]

   ```
   zip -r layer.zip python/
   ```

------
#### [ PowerShell ]

   ```
   Compress-Archive -Path .\python -DestinationPath .\layer.zip
   ```

------

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

   ```
   python/     # Required top-level directory
   └── validator.py
   ```

1. Na função, importe e use os módulos como você faria com qualquer pacote de Python. Exemplo:

   ```
   from validator import validate_order, format_response
   import json
   
   def lambda_handler(event, context):
       try:
           # Parse the order data from the event body
           order_data = json.loads(event.get('body', '{}'))
           
           # Validate and format the order
           validated_order = validate_order(order_data)
           
           return format_response(200, {
               'message': 'Order validated successfully',
               'order': validated_order
           })
       except ValueError as e:
           return format_response(400, {
               'error': str(e)
           })
       except Exception as e:
           return format_response(500, {
               'error': 'Internal server error'
           })
   ```

   Você pode usar os seguinte [evento de teste](testing-functions.md#invoke-with-event)para invocar a função:

   ```
   {
       "body": "{\"product_id\": \"ABC123\", \"quantity\": 2, \"priority\": \"express\"}"
   }
   ```

   Resposta esperada:

   ```
   {
     "statusCode": 200,
     "body": "{\"message\": \"Order validated successfully\", \"order\": {\"product_id\": \"ABC123\", \"quantity\": 2, \"shipping_priority\": \"express\"}}"
   }
   ```

## 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 python3.14
```

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 do Python que corresponde à versão do Python que você usou para criar a camada.

1. Escolha **Criar**.

------

## Adicionar a camada à função
<a name="python-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**.

------

## Aplicação de amostra
<a name="python-layer-sample-app"></a>

Para obter mais exemplos de como usar camadas do Lambda, consulte a aplicação de amostra [layer-python](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/layer-python) no repositório AWS Lambda Developer Guide do GitHub. Essa aplicação inclui duas camadas que contêm bibliotecas de Python. Após criar as camadas, você pode implantar e invocar as funções correspondentes para confirmar que as camadas funcionam conforme o esperado.