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

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

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.

Este tópico explica como criar uma camada de Python e anexá-la a uma função do Lambda.

Empacotar o conteúdo da sua camada

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.13, use o runtime do Python 3.13 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.

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.

    requirements.txt

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

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

  2. Compacte o conteúdo do diretório python.

    zip -r layer.zip python/

    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.

Para criar uma camada usando seu próprio código
  1. Crie o diretório superior necessário para a camada:

    mkdir python
  2. 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.

    exemplo 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) }
  3. Compacte o conteúdo do diretório python.

    zip -r layer.zip python/

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

    python/     # Required top-level directory
    └── validator.py
  4. 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 testepara 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

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 python3.13

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 do Python que corresponde à versão do Python 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"
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.

Aplicação de amostra

Para obter mais exemplos de como usar camadas do Lambda, consulte a aplicação de amostra 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.