# Criar funções do Lambda com Python
É possível executar o código Python no AWS Lambda. O Lambda fornece [runtimes](lambda-runtimes.md) para o Python que executa o seu código para processar eventos. Seu código é executado em um ambiente que inclui o SDK for Python (Boto 3), com as credenciais de uma função do AWS Identity and Access Management (IAM) que você gerencia. Para saber mais sobre as versões do SDK incluídas nos runtimes do Python, consulte [Versões do SDK incluídas no runtime](#python-sdk-included).
O Lambda oferece suporte aos seguintes runtimes Python.
| Nome | Identificador | Sistema operacional | Data da substituição | Bloquear a criação de funções | Bloquear a atualização de funções |
| --- | --- | --- | --- | --- | --- |
| Python 3.14 | `python3.14` | Amazon Linux 2023 | 30 de junho de 2029 | 31 de julho de 2029 | 31 de agosto de 2029 |
| Python 3.13 | `python3.13` | Amazon Linux 2023 | 30 de junho de 2029 | 31 de julho de 2029 | 31 de agosto de 2029 |
| Python 3.12 | `python3.12` | Amazon Linux 2023 | 31 de outubro de 2028 | 30 de novembro de 2028 | 10 de janeiro de 2029 |
| Python 3.11 | `python3.11` | Amazon Linux 2 | 30º de junho de 2027 | 31º de julho de 2027 | 31 de agosto de 2027 |
| Python 3.10 | `python3.10` | Amazon Linux 2 | 31 de outubro de 2026 | 30 de novembro de 2026 | 15 de janeiro de 2027 |
**Para criar uma função em Python**
1. Abra o [console do lambda](https://console.aws.amazon.com/lambda).
1. Escolha a opção **Criar função**.
1. Configure as seguintes opções:
+ **Nome da função**: digite um nome para a função.
+ **Runtime**: escolha **Python 3.14**.
1. Escolha a opção **Criar função**.
O console cria uma função do Lambda com um único arquivo de origem chamado `lambda_function`. É possível editar esse arquivo e adicionar mais arquivos no editor de códigos integrado. Na seção **DEPLOY**, escolha **Implantar** para atualizar o código da função. Em seguida, para executar seu código, escolha **Criar evento de teste** na seção **TEST EVENTS**.
Sua função do Lambda é fornecida com um grupo de logs do CloudWatch Logs. O runtime envia detalhes sobre cada invocação para o CloudWatch Logs. Ele retransmite quaisquer [logs que sua função produz](python-logging.md) durante a invocação. Se a função retornar um erro, o Lambda formatará o erro e o retornará para o invocador.
**Topics**
+ [Versões do SDK incluídas no runtime](#python-sdk-included)
+ [Recursos do Python desabilitados](#python-disabled-features)
+ [Formato de resposta](#python-response-format)
+ [Desligamento normal para extensões](#python-graceful-shutdown)
+ [Definir o manipulador de função do Lambda em Python](python-handler.md)
+ [Trabalhar com arquivos .zip para funções do Lambda em Python](python-package.md)
+ [Implante funções do Lambda em Python com imagens de contêiner](python-image.md)
+ [Como trabalhar com camadas para funções do Lambda em Python](python-layers.md)
+ [Usar o objeto de contexto do Lambda para recuperar informações das funções em Python](python-context.md)
+ [Registrar em log e monitorar funções do Lambda em Python](python-logging.md)
+ [Testes da função do AWS Lambda em Python](python-testing.md)
+ [Instrumentação do código Python no AWS Lambda](python-tracing.md)
## Versões do SDK incluídas no runtime
A versão do AWS SDK incluída no runtime do Python depende da versão do runtime e da Região da AWS. Para encontrar a versão do SDK incluída no runtime que você está usando, crie uma função do Lambda com o código a seguir.
```
import boto3
import botocore
def lambda_handler(event, context):
print(f'boto3 version: {boto3.__version__}')
print(f'botocore version: {botocore.__version__}')
```
## Recursos do Python desabilitados
A tabela a seguir lista os recursos do Python que estão desabilitados nos runtimes gerenciados pelo Lambda e nas imagens base de contêineres para Python. Esses recursos devem ser habilitados quando o executável de runtime do Python for compilado e não podem ser habilitados usando um sinalizador de runtime. Para usar esses recursos no Lambda, é possível implantar sua própria compilação de runtime do Python com esses recursos habilitados, usando uma [imagem de contêiner](python-image.md#python-image-clients) ou um [runtime personalizado](runtimes-custom.md).
| Recurso do Python | Versões do Python afetadas | Status |
| --- | --- | --- |
| Compilador Just-in-Time (JIT) | Python 3.13 e posterior | O compilador JIT é experimental e não é recomendado para workloads de produção. Portanto, ele está desabilitado nos runtimes de Python do Lambda. |
| Threading livre | Python 3.13 e posterior | O threading livre (opção para desabilitar o bloqueio global do interpretador) está desabilitado nas compilações de Python do Lambda devido ao impacto na performance do código de threading único. |
## Formato de resposta
Nos runtimes do Python 3.12 e posteriores, as funções retornam caracteres Unicode como parte da resposta JSON. Os runtimes anteriores do Python retornam sequências de escape para caracteres Unicode nas respostas. Por exemplo, no Python 3.11, se você retornar uma string Unicode, como “こんにちは”, ela escapará dos caracteres Unicode e retornará “\$1u3053\$1u3093\$1u306b\$1u3061\$1u306f”. O runtime do Python 3.12 retorna o “こんにちは” original.
O uso de respostas Unicode reduz o tamanho das respostas do Lambda, facilitando o ajuste de respostas maiores para o tamanho máximo de carga útil de 6 MB para funções síncronas. No exemplo anterior, a versão com escape é de 32 bytes, em comparação com 17 bytes com a string Unicode.
Ao atualizar para o Python 3.12, ou runtimes Python posteriores, talvez seja necessário ajustar o código para levar em conta o novo formato de resposta. Se o chamador espera Unicode de escape, você deve adicionar código à função de retorno para escapar do Unicode manualmente ou ajustar o chamador para lidar com o retorno do Unicode.
## Desligamento normal para extensões
Os runtimes do Python 3.12 e versões posteriores oferecem recursos aprimorados de desligamento normal para funções com [extensões externas](lambda-extensions.md). Quando o Lambda desliga um ambiente de execução, ele envia um sinal `SIGTERM` para o runtime e, depois, um evento `SHUTDOWN` para cada extensão externa registrada. É possível capturar o sinal `SIGTERM` na função do Lambda e apagar recursos, como conexões de banco de dados que foram criadas pela função.
Para saber mais sobre o ciclo de vida do ambiente de execução, consulte [Noções básicas sobre o ciclo de vida do ambiente de execução do Lambda](lambda-runtime-environment.md). Para ver exemplos de como usar o desligamento normal com extensões, consulte o [AWS Samples GitHub repository](https://github.com/aws-samples/graceful-shutdown-with-aws-lambda).
# Definir o manipulador de função do Lambda em Python
O *manipulador* da função do Lambda é o método no código da função que processa eventos. Quando sua função é invocada, o Lambda executa o método do manipulador. A função é executada até que o manipulador retorne uma resposta, seja encerrado ou atinja o tempo limite.
Esta página descreve como trabalhar com manipuladores de função do Lambda em Python, incluindo convenções de nomenclatura, assinaturas de manipulador válidas e práticas recomendadas de codificação. Além disso, esta página apresenta um exemplo de uma função do Lambda em Python que aceita informações sobre um pedido, produz um recibo em formato de texto e armazena esse arquivo em um bucket do Amazon Simple Storage Service (Amazon S3).
**Topics**
+ [Exemplo de código em Python da função do Lambda](#python-handler-example)
+ [Convenções de nomenclatura para manipuladores](#python-handler-naming)
+ [Usar o objeto de evento do Lambda](#python-handler-event)
+ [Acesso e uso do objeto de contexto do Lambda](#python-handler-context)
+ [Assinaturas de manipulador válidas para manipuladores em Python](#python-handler-signature)
+ [Retornar um valor](#python-handler-return)
+ [Uso do AWS SDK para Python (Boto3) no manipulador](#python-handler-sdk)
+ [Acesso a variáveis de ambiente](#python-handler-env-vars)
+ [Práticas recomendadas de código para as funções do Lambda em Python](#python-handler-best-practices)
## Exemplo de código em Python da função do Lambda
O seguinte exemplo de código de uma função do Lambda em Python aceita informações sobre um pedido, produz um recibo em formato de texto e armazena esse arquivo em um bucket do Amazon S3:
**Example Função do Lambda em Python**
```
import json
import os
import logging
import boto3
# Initialize the S3 client outside of the handler
s3_client = boto3.client('s3')
# Initialize the logger
logger = logging.getLogger()
logger.setLevel("INFO")
def upload_receipt_to_s3(bucket_name, key, receipt_content):
"""Helper function to upload receipt to S3"""
try:
s3_client.put_object(
Bucket=bucket_name,
Key=key,
Body=receipt_content
)
except Exception as e:
logger.error(f"Failed to upload receipt to S3: {str(e)}")
raise
def lambda_handler(event, context):
"""
Main Lambda handler function
Parameters:
event: Dict containing the Lambda function event data
context: Lambda runtime context
Returns:
Dict containing status message
"""
try:
# Parse the input event
order_id = event['Order_id']
amount = event['Amount']
item = event['Item']
# Access environment variables
bucket_name = os.environ.get('RECEIPT_BUCKET')
if not bucket_name:
raise ValueError("Missing required environment variable RECEIPT_BUCKET")
# Create the receipt content and key destination
receipt_content = (
f"OrderID: {order_id}\n"
f"Amount: ${amount}\n"
f"Item: {item}"
)
key = f"receipts/{order_id}.txt"
# Upload the receipt to S3
upload_receipt_to_s3(bucket_name, key, receipt_content)
logger.info(f"Successfully processed order {order_id} and stored receipt in S3 bucket {bucket_name}")
return {
"statusCode": 200,
"message": "Receipt processed successfully"
}
except Exception as e:
logger.error(f"Error processing order: {str(e)}")
raise
```
Este arquivo contém as seguintes seções de código:
+ Bloco `import`: utilize este bloco para incluir as bibliotecas necessárias para a função do Lambda.
+ Inicialização global do cliente e do logger do SDK: incluir código de inicialização fora do manipulador aproveita a reutilização do [ambiente de execução](lambda-runtime-environment.md) para melhorar a performance da função. Para saber mais, consulte [Práticas recomendadas de código para as funções do Lambda em Python](#python-handler-best-practices).
+ `def upload_receipt_to_s3(bucket_name, key, receipt_content):`: função auxiliar chamada pela função `lambda_handler` principal.
+ `def lambda_handler(event, context):`: **função do manipulador principal** para seu código que contém a lógica principal da aplicação. Quando o Lambda invoca seu manipulador de funções, o [runtime do Lambda](concepts-basics.md#gettingstarted-concepts-runtime) passa dois argumentos para a função, o [objeto de evento](#python-handler-event) que contém dados para sua função processar e o [objeto de contexto](#python-handler-context) que contém informações sobre a invocação da função.
## Convenções de nomenclatura para manipuladores
O nome do manipulador da função definido no momento em que você cria uma função do Lambda é derivado:
+ do nome do arquivo no qual a função de manipulador do Lambda está localizada.
+ do nome da função do manipulador do Python.
No exemplo acima, se o nome do arquivo for `lambda_function.py`, o manipulador será especificado como `lambda_function.lambda_handler`. Esse é o nome padrão do manipulador atribuído às funções que você cria usando o console do Lambda.
Se você criar uma função no console usando um nome de arquivo ou nome de manipulador de funções diferente, deverá editar o nome do manipulador padrão.
**Para alterar o nome do manipulador de funções (console)**
1. Abra a página [Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda e escolha sua função.
1. Escolha a guia **Código**.
1. Role para baixo até o painel **Configurações de runtime** e escolha **Editar**.
1. Em **Manipulador**, insira o novo nome para seu manipulador de funções.
1. Escolha **Salvar**.
## Usar o objeto de evento do Lambda
Ao invocar sua função, o Lambda passa um argumento do [objeto de evento](concepts-basics.md#gettingstarted-concepts-event) ao manipulador da função. Objetos JSON são o formato de evento mais comum para funções do Lambda. No exemplo de código da seção anterior, a função espera uma entrada no seguinte formato:
```
{
"Order_id": "12345",
"Amount": 199.99,
"Item": "Wireless Headphones"
}
```
Se sua função for invocada por outro AWS service (Serviço da AWS), o evento de entrada também será um objeto JSON. O formato exato do objeto de evento depende do serviço que está invocando sua função. Para ver o formato do evento para um serviço específico, consulte a página apropriada no capítulo [Invocando o Lambda com eventos de outros serviços da AWS](lambda-services.md).
Se o evento de entrada estiver na forma de um objeto JSON, o runtime do Lambda converterá o objeto em um dicionário Python. Para atribuir valores no JSON de entrada às variáveis em seu código, use os métodos padrão do dicionário Python, conforme ilustrado no código de exemplo.
Você também pode passar dados para sua função como uma matriz JSON ou como qualquer outro tipo de dados JSON válido. A tabela a seguir define como o tempo de execução do Python converte esses tipos de JSON.
| Tipo de dados do JSON | Tipo de dados do Python |
| --- | --- |
| objeto | dicionário (dict) |
| array | lista (list) |
| número | número inteiro (int) ou de ponto flutuante (float) |
| string | string (str) |
| Booleano | Booliano (bool) |
| nulo | NoneType (NoneType) |
## Acesso e uso do objeto de contexto do Lambda
O objeto de contexto do Lambda contém informações sobre a invocação da função e o ambiente de execução. O Lambda passa o objeto de contexto para sua função automaticamente quando ela é invocada. Você pode usar o objeto de contexto para gerar informações sobre a invocação da sua função para fins de monitoramento.
O objeto de contexto é uma classe Python definida no [cliente da interface de runtime do Lambda](https://github.com/aws/aws-lambda-python-runtime-interface-client/blob/main/awslambdaric/lambda_context.py). Para retornar o valor de qualquer uma das propriedades do objeto de contexto, use o método correspondente no objeto de contexto. Por exemplo, o trecho de código a seguir atribui o valor da propriedade `aws_request_id` (o identificador da solicitação de invocação) a uma variável chamada `request`.
```
request = context.aws_request_id
```
Para saber mais sobre como usar o objeto de contexto do Lambda e ver uma lista completa dos métodos e propriedades disponíveis, consulte [Usar o objeto de contexto do Lambda para recuperar informações das funções em Python](python-context.md).
## Assinaturas de manipulador válidas para manipuladores em Python
Para definir sua função de manipulador em Python, a função deve receber dois argumentos. O primeiro desses argumentos é o [objeto de evento](#python-handler-event) do Lambda e o segundo é o [objeto de contexto](#python-handler-context) do Lambda. Por convenção, esses argumentos de entrada geralmente são chamados `event` e `context`, mas você pode atribuir a eles os nomes que preferir. Se você declarar sua função de manipulador com um único argumento de entrada, o Lambda gerará um erro ao tentar executar sua função. A forma mais comum de declarar uma função de manipulador em Python é a seguinte:
```
def lambda_handler(event, context):
```
Você também pode usar dicas de tipo Python na declaração da função, conforme mostrado no seguinte exemplo:
```
from typing import Dict, Any
def lambda_handler(event: Dict[str, Any], context: Any) -> Dict[str, Any]:
```
Para usar tipagem específica da AWS para eventos gerados por outros Serviços da AWS e para o objeto de contexto, adicione o pacote `aws-lambda-typing` ao pacote de implantação da sua função. Você pode instalar essa biblioteca em seu ambiente de desenvolvimento executando `pip install aws-lambda-typing`. O trecho de código a seguir mostra como usar dicas de tipo específicas da AWS. Neste exemplo, o evento esperado é um evento do Amazon S3.
```
from aws_lambda_typing.events import S3Event
from aws_lambda_typing.context import Context
from typing import Dict, Any
def lambda_handler(event: S3Event, context: Context) -> Dict[str, Any]:
```
Não é possível usar o tipo de função `async` do Python para sua função de manipulador.
## Retornar um valor
Opcionalmente, um handler pode retornar um valor, que deve ser serializável em JSON. Os tipos de retorno comuns incluem `dict`, `list`, `str`, `int`, `float` e `bool`.
O que acontece com o valor retornado depende do [tipo de invocação](lambda-invocation.md) e do [serviço](lambda-services.md) que invocou a função. Por exemplo:
+ Se você usar o tipo de invocação `RequestResponse` para [invocar uma função do Lambda de forma síncrona](invocation-sync.md), o Lambda retornará o resultado da chamada de função Python para o cliente que invoca a função do Lambda (na resposta HTTP à solicitação de invocação, serializada em JSON). Por exemplo, o console do AWS Lambda usa o tipo de invocação `RequestResponse`, assim, quando você invocar a função no console, ele exibirá o valor retornado.
+ Se o handler retornar objetos que não podem ser serializados por `json.dumps`, o runtime retornará um erro.
+ Se o handler retornar `None`, assim como funções Python sem uma instrução `return` fazem implicitamente, o runtime retornará `null`.
+ Se você usar o tipo de invocação `Event` (uma [invocação assíncrona](invocation-async.md)), o valor será descartado.
No código de exemplo, o manipulador retorna o seguinte dicionário Python:
```
{
"statusCode": 200,
"message": "Receipt processed successfully"
}
```
O runtime do Lambda serializa esse dicionário e o retorna ao cliente que invocou a função como uma string JSON.
**nota**
No Python 3.9 e em versões posteriores, o Lambda inclui o requestId da invocação na resposta de erro.
## Uso do AWS SDK para Python (Boto3) no manipulador
Muitas vezes, você usará as funções do Lambda para interagir com ou fazer atualizações em outros recursos e Serviços da AWS. A maneira mais simples de interagir com esses recursos é usar o AWS SDK para Python (Boto3). Todos os [runtimes em Python do Lambda compatíveis](lambda-runtimes.md#runtimes-supported) incluem uma versão do SDK para Python. No entanto, recomendamos fortemente que você inclua o SDK no pacote de implantação da sua função se seu código precisar usá-lo. Incluir o SDK em seu pacote de implantação oferece controle total sobre suas dependências e reduz o risco de problemas de desalinhamento de versões com outras bibliotecas. Consulte [Dependências de runtime em Python](python-package.md#python-package-dependencies) e [Compatibilidade retroativa](runtimes-update.md#runtime-update-compatibility) para saber mais.
Para usar o SDK para Python em sua função do Lambda, adicione a seguinte declaração ao bloco de importação no início do código da função:
```
import boto3
```
Use o comando `pip install` para adicionar a biblioteca `boto3` ao pacote de implantação da sua função. Para obter instruções detalhadas sobre como adicionar dependências a um pacote de implantação .zip, consulte [Criar um pacote de implantação .zip com dependências](python-package.md#python-package-create-dependencies). Para saber mais sobre como adicionar dependências às funções do Lambda implantadas como imagens de contêiner, consulte [Criação de uma imagem a partir de uma imagem base](python-image.md#python-image-create) ou [Criar uma imagem de uma imagem base alternativa](python-image.md#python-alt-create).
Ao usar `boto3` em seu código, você não precisa fornecer credenciais para inicializar um cliente. No código de exemplo, usamos a seguinte linha de código para inicializar um cliente do Amazon S3:
```
# Initialize the S3 client outside of the handler
s3_client = boto3.client('s3')
```
Com o Python, o Lambda cria automaticamente variáveis de ambiente com credenciais. O SDK `boto3` verifica essas credenciais nas variáveis de ambiente da função durante a inicialização.
## Acesso a variáveis de ambiente
No código do manipulador, você pode fazer referência a [variáveis de ambiente](configuration-envvars.md) usando o método `os.environ.get`. Neste exemplo de código, fazemps referência à variável de ambiente `RECEIPT_BUCKET` definida usando a seguinte linha de código:
```
# Access environment variables
bucket_name = os.environ.get('RECEIPT_BUCKET')
```
Não se esqueça de incluir uma declaração `import os` no bloco de importação no início do seu código.
## Práticas recomendadas de código para as funções do Lambda em Python
Adote as diretrizes da lista a seguir para usar as práticas recomendadas de codificação ao compilar suas funções do Lambda:
+ **Separe o manipulador do Lambda da lógica central.** Isso permite que você crie uma função mais fácil para teste de unidade. Por exemplo, em Python, isso poderia ser assim:
```
def lambda_handler(event, context):
foo = event['foo']
bar = event['bar']
result = my_lambda_function(foo, bar)
def my_lambda_function(foo, bar):
// MyLambdaFunction logic here
```
+ **Controle as dependências no pacote de implantação da função.** O ambiente de execução do AWS Lambda contém várias bibliotecas. Para os runtimes em Node.js e Python, os AWS SDKs estão incluídos. Para habilitar o conjunto de recursos e atualizações de segurança mais recente, o Lambda atualizará periodicamente essas bibliotecas. Essas atualizações podem introduzir alterações sutis ao comportamento de sua função do Lambda. Para ter controle total das dependências usadas por sua função, empacote todas as dependências em seu pacote de implantação.
+ **Minimize a complexidade de suas dependências.** Prefira frameworks mais simples que sejam carregados rapidamente no startup do [ambiente de execução](lambda-runtime-environment.md).
+ **Minimize o tamanho do pacote de implantação para conter somente o necessário para o runtime. ** Isso reduzirá a quantidade de tempo necessária para que seu pacote de implantação seja obtido por download e desempacotado antes da invocação.
**Aproveite a reutilização do ambiente de execução para melhorar a performance da função.** Inicialize clientes SDK e conexões de banco de dados fora do manipulador de funções e armazene em cache os ativos estáticos localmente no diretório `/tmp`. As invocações subsequentes processadas pela mesma instância da função podem reutilizar esses recursos. Isso economiza custos reduzindo o runtime da função.
Para evitar possíveis vazamentos de dados entre invocações, não use o ambiente de execução para armazenar dados do usuário, eventos ou outras informações com implicações de segurança. Se sua função depende de um estado mutável que não pode ser armazenado na memória dentro do manipulador, considere criar uma função separada ou versões separadas de uma função para cada usuário.
**Use uma diretiva de keep-alive para manter conexões persistentes.** O Lambda limpa conexões ociosas ao longo do tempo. A tentativa de reutilizar uma conexão ociosa ao invocar uma função resultará em um erro de conexão. Para manter sua conexão persistente, use a diretiva keep-alive associada ao runtime. Para obter um exemplo, consulte [Reutilizar conexões com keep-alive em Node.js](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-reusing-connections.html).
**Use [variáveis de ambiente](configuration-envvars.md) para passar parâmetros operacionais para sua função.** Por exemplo, se estiver gravando em um bucket do Amazon S3, em vez fixar no código o nome do bucket em que você está gravando, configure o nome do bucket como uma variável de ambiente.
**Evite usar invocações recursivas** em sua função do Lambda, em que a função invoca a si mesma ou inicia um processo que pode invocar a função novamente. Isso pode levar a um volume não intencional de invocações da função e a custos elevados. Se você observar um volume não intencional de invocações, defina a simultaneidade reservada da função como `0` imediatamente para limitar todas as invocações da função enquanto atualiza o código.
**Não use APIs não documentadas e não públicas** no código da função Lambda. Para os tempos de execução gerenciados pelo AWS Lambda, o Lambda aplica periodicamente atualizações funcionais e de segurança às APIs internas do Lambda. Essas atualizações internas da API podem ser incompatíveis com versões anteriores, gerando consequências não intencionais, como falhas de invocação, caso sua função tenha dependência nessas APIs não públicas. Consulte [a referência da API](https://docs.aws.amazon.com/lambda/latest/api/welcome.html) para obter uma lista de APIs disponíveis publicamente.
**Escreva um código idempotente.** Escrever um código idempotente para suas funções garante que eventos duplicados sejam tratados da mesma maneira. Seu código deve validar eventos adequadamente e lidar corretamente com eventos duplicados. Para obter mais informações, consulte [Como torno minha função do Lambda idempotente?](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-function-idempotent/).
# Trabalhar com arquivos .zip para funções do Lambda em Python
O código da sua função do AWS Lambda compreende um arquivo .py contendo o código do manipulador da função e todos os pacotes e módulos adicionais dos quais o código depende. Para implantar o código dessa função no Lambda, você usa um *pacote de implantação*. Esse pacote pode ser um arquivo .zip ou uma imagem de contêiner. Para obter mais informações sobre o uso de imagens de contêiner com Python, consulte [Implantar funções do Lambda em Python com imagens de contêiner](https://docs.aws.amazon.com/lambda/latest/dg/python-image.html).
Para criar um pacote de implantação como arquivo .zip, você pode usar um utilitário de arquivo .zip integrado da ferramenta da linha de comando ou qualquer outro utilitário de arquivo .zip, como o [7zip](https://www.7-zip.org/download.html). Os exemplos mostrados nas seções a seguir pressupõem que você esteja usando uma ferramenta `zip` da linha de comando em um ambiente Linux ou MacOS. Para usar os mesmos comandos no Windows, você pode [instalar o Subsistema Windows para Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) para obter uma versão do Ubuntu e do Bash integrada ao Windows.
Observe que o Lambda usa permissões de arquivo POSIX, então pode ser necessário [definir permissões para a pasta do pacote de implantação](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-deployment-package-errors/) antes da criação do arquivo .zip.
**Topics**
+ [Dependências de runtime em Python](#python-package-dependencies)
+ [Criar um pacote de implantação .zip sem dependências](#python-package-create-no-dependencies)
+ [Criar um pacote de implantação .zip com dependências](#python-package-create-dependencies)
+ [Caminho de pesquisa de dependências e bibliotecas incluídas no runtime](#python-package-searchpath)
+ [Usar pastas \$1\$1pycache\$1\$1](#python-package-pycache)
+ [Criar pacotes de implantação .zip com bibliotecas nativas](#python-package-native-libraries)
+ [Criar e atualizar funções do Lambda em Python usando arquivos .zip](#python-package-create-update)
## Dependências de runtime em Python
Para funções do Lambda que usam o runtime do Python, uma dependência pode ser qualquer pacote ou módulo do Python. Ao implantar a função usando um arquivo .zip, você pode adicionar essas dependências ao arquivo .zip com o código da função ou usar uma [camada do Lambda](chapter-layers.md). Uma camada é um arquivo .zip que pode conter código adicional e outro conteúdo. Para saber mais sobre como usar camadas do Lambda no Python, consulte [Como trabalhar com camadas para funções do Lambda em Python](python-layers.md).
Os runtimes do Lambda em Python incluem o AWS SDK para Python (Boto3) e suas dependências. O Lambda fornece o SDK no runtime para cenários de implantação em que você não consegue adicionar suas próprias dependências. Esses cenários incluem a criação de funções no console usando o editor de código integrado ou funções embutidas em modelos do AWS Serverless Application Model (AWS SAM) ou do CloudFormation.
O Lambda atualiza periodicamente as bibliotecas no runtime do Python para incluir as atualizações e os patches de segurança mais recentes. Se sua função usa a versão do SDK Boto3 incluída no runtime, mas o pacote de implantação inclui dependências do SDK, isso pode causar problemas de desalinhamento de versão. Por exemplo, o pacote de implantação pode incluir a dependência urllib3 do SDK. Quando o Lambda atualiza o SDK no runtime, problemas de compatibilidade entre a nova versão do runtime e a versão do urllib3 no pacote de implantação podem fazer com que a função apresente falha.
**Importante**
Para manter o controle total sobre suas dependências e evitar possíveis problemas de desalinhamento de versão, recomendamos que você adicione todas as dependências da função ao pacote de implantação, mesmo que as versões delas estejam incluídas no runtime do Lambda. Isso inclui o SDK do Boto3.
Para descobrir qual versão do SDK para Python (Boto3) está incluída no runtime que você está usando, consulte [Versões do SDK incluídas no runtime](lambda-python.md#python-sdk-included).
No [modelo de responsabilidade compartilhada da AWS](https://docs.aws.amazon.com/whitepapers/latest/aws-risk-and-compliance/shared-responsibility-model.html), você é responsável pelo gerenciamento de todas as dependências dos pacotes de implantação das suas funções. Isso inclui a aplicação de atualizações e patches de segurança. Para atualizar as dependências no pacote de implantação da função, primeiro crie um novo arquivo .zip e depois carregue esse arquivo no Lambda. Consulte [Criar um pacote de implantação .zip com dependências](#python-package-create-dependencies) e [Criar e atualizar funções do Lambda em Python usando arquivos .zip](#python-package-create-update) para obter mais informações.
## Criar um pacote de implantação .zip sem dependências
Se o código da função não tiver dependências, o arquivo .zip conterá somente o arquivo .py com o código do manipulador da função. Use seu utilitário zip preferencial para criar um arquivo .zip com o arquivo .py na raiz. Se o arquivo .py não estiver na raiz do arquivo .zip, o Lambda não poderá executar o código.
Para saber como implantar o arquivo .zip para criar uma função do Lambda ou atualizar uma já existente, consulte [Criar e atualizar funções do Lambda em Python usando arquivos .zip](#python-package-create-update).
## Criar um pacote de implantação .zip com dependências
Se o código da função depender de pacotes ou módulos adicionais, você poderá acrescentar essas dependências ao arquivo .zip com o código da função ou usar uma [camada do Lambda](python-layers.md). As instruções desta seção mostram como incluir as dependências no pacote de implantação .zip. Para que o Lambda execute seu código, o arquivo .py contendo o código do manipulador e todas as dependências da sua função devem ser instalados na raiz do arquivo .zip.
Suponha que o código da função esteja salvo em um arquivo denominado `lambda_function.py`. Os exemplos de comandos da CLI a seguir criam um arquivo .zip denominado `my_deployment_package.zip` que contém o código da função e suas dependências. Você pode instalar suas dependências diretamente em uma pasta do diretório do projeto ou usar um ambiente virtual em Python.
**Para criar o pacote de implantação (diretório do projeto)**
1. Navegue até o diretório do projeto que contém o arquivo `lambda_function.py` de código-fonte. Neste exemplo, o diretório se chama `my_function`.
```
cd my_function
```
1. Crie um diretório com o nome de package, no qual você instalará as dependências.
```
mkdir package
```
Observe que, para um pacote de implantação .zip, o Lambda espera que o código-fonte e suas dependências estejam todos na raiz do arquivo .zip. No entanto, instalar dependências diretamente no diretório do projeto pode introduzir um grande número de novos arquivos e pastas e dificultar a navegação pelo IDE. Crie um diretório `package` separado aqui para manter suas dependências separadas do código-fonte.
1. Instale as dependências no diretório `package`. O exemplo abaixo instala o SDK do Boto3 do Python Package Index usando pip. Se o código da função usar pacotes Python que você mesmo criou, salve-os no diretório `package`.
```
pip install --target ./package boto3
```
1. Crie um arquivo .zip com as bibliotecas instaladas na raiz.
```
cd package
zip -r ../my_deployment_package.zip .
```
Isso gerará um arquivo `my_deployment_package.zip` no diretório do projeto.
1. Adicione o arquivo lambda\$1function.py à raiz do arquivo .zip
```
cd ..
zip my_deployment_package.zip lambda_function.py
```
O arquivo .zip deve ter uma estrutura de diretórios simples, com o código do manipulador da função e todas as pastas de dependência instaladas na raiz, como a seguir.
```
my_deployment_package.zip
|- bin
| |-jp.py
|- boto3
| |-compat.py
| |-data
| |-docs
...
|- lambda_function.py
```
Se o arquivo .py que contém o código do manipulador da função não estiver na raiz do arquivo .zip, o Lambda não poderá executar o código.
**Para criar o pacote de implantação (ambiente virtual)**
1. Crie e ative um ambiente virtual no diretório do projeto. Neste exemplo, o diretório do projeto é denominado `my_function`.
```
~$ cd my_function
~/my_function$ python3.14 -m venv my_virtual_env
~/my_function$ source ./my_virtual_env/bin/activate
```
1. Instale as bibliotecas necessárias usando pip. O exemplo a seguir instala o SDK do Boto3
```
(my_virtual_env) ~/my_function$ pip install boto3
```
1. Use `pip show` para encontrar o local no ambiente virtual em que o pip instalou as dependências.
```
(my_virtual_env) ~/my_function$ pip show
```
A pasta na qual o pip instala as bibliotecas pode ser denominada `site-packages` ou `dist-packages`. Essa pasta pode estar localizada no diretório `lib/python3.x` ou `lib64/python3.x` (em que python3.x representa a versão do Python que você está usando).
1. Desativar o ambiente virtual
```
(my_virtual_env) ~/my_function$ deactivate
```
1. Navegue até o diretório que contém as dependências que você instalou com o pip e crie um arquivo zip no diretório do projeto com as dependências instaladas na raiz. Neste exemplo, o pip instalou as dependências no diretório `my_virtual_env/lib/python3.14/site-packages`.
```
~/my_function$ cd my_virtual_env/lib/python3.14/site-packages
~/my_function/my_virtual_env/lib/python3.14/site-packages$ zip -r ../../../../my_deployment_package.zip .
```
1. Navegue até a raiz do diretório do projeto em que o arquivo .py que contém o código do manipulador está localizado e adicione esse arquivo à raiz do pacote .zip. Neste exemplo, o arquivo do código da função é denominado `lambda_function.py`.
```
~/my_function/my_virtual_env/lib/python3.14/site-packages$ cd ../../../../
~/my_function$ zip my_deployment_package.zip lambda_function.py
```
## Caminho de pesquisa de dependências e bibliotecas incluídas no runtime
Quando você usa uma instrução `import` no código, o runtime do Python pesquisa os diretórios no caminho de pesquisa até encontrar o módulo ou pacote. Por padrão, o primeiro local que o runtime pesquisa é o diretório no qual o pacote de implantação .zip é descompactado e montado (`/var/task`). Se você incluir uma versão de uma biblioteca incluída no runtime do pacote de implantação, a sua versão terá precedência sobre a versão incluída no runtime. As dependências do pacote de implantação também têm precedência sobre as dependências das camadas.
Quando você adiciona uma dependência a uma camada, o Lambda a extrai para `/opt/python/lib/python3.x/site-packages`, em que `python3.x` representa a versão do runtime que você está usando, ou para `/opt/python`. No caminho de pesquisa, esses diretórios têm precedência sobre os diretórios que contêm as bibliotecas incluídas no runtime e as bibliotecas instaladas no pip (`/var/runtime` e `/var/lang/lib/python3.x/site-packages`). As bibliotecas em camadas da função, portanto, têm precedência sobre as versões incluídas no runtime.
**nota**
No runtime gerenciado e na imagem base do Python 3.11, o AWS SDK e suas dependências estão instalados no diretório `/var/lang/lib/python3.11/site-packages`.
Você pode ver o caminho de pesquisa completo para a função do Lambda adicionando o trecho de código a seguir.
```
import sys
search_path = sys.path
print(search_path)
```
**nota**
Como as dependências do pacote de implantação ou das camadas têm precedência sobre as bibliotecas incluídas no runtime, isso pode causar problemas de desalinhamento de versão se você incluir uma dependência do SDK, como urllib3, no pacote sem também incluir o SDK. Se você implantar sua própria versão de uma dependência do Boto3, também deverá implantar o Boto3 como uma dependência no pacote de implantação. Recomendamos que você empacote todas as dependências da função, mesmo que as versões delas estejam incluídas no runtime.
Você também pode adicionar dependências em uma pasta separada dentro do pacote .zip. Por exemplo, você pode adicionar uma versão do SDK do Boto3 a uma pasta do pacote .zip denominada `common`. Quando o pacote .zip é descompactado e montado, essa pasta é colocada dentro do diretório `/var/task`. Para usar uma dependência proveniente de uma pasta do pacote de implantação .zip no código, use uma instrução `import from`. Por exemplo, para usar uma versão do Boto3 proveniente de uma pasta denominada `common` no pacote.zip, use a instrução a seguir.
```
from common import boto3
```
## Usar pastas \$1\$1pycache\$1\$1
É recomendável não incluir pastas `__pycache__` no pacote de implantação da função. O bytecode do Python compilado em uma máquina de compilação com arquitetura ou sistema operacional diferente pode não ser compatível com o ambiente de execução do Lambda.
## Criar pacotes de implantação .zip com bibliotecas nativas
Se a função usar somente pacotes e módulos Python puros, você poderá usar o comando `pip install` para instalar as dependências em qualquer máquina de compilação local e criar o arquivo .zip. Muitas bibliotecas populares de Python, incluindo NumPy e Pandas, não são Python puro e contêm código escrito em C ou C\$1\$1. Ao adicionar bibliotecas que contêm código C/C\$1\$1 ao pacote de implantação, você deve criar seu pacote corretamente para garantir que ele seja compatível com o ambiente de execução do Lambda.
A maioria dos pacotes disponíveis no Python Package Index ([PyPI](https://pypi.org/)) está disponível como “wheels” (arquivos .whl). Um arquivo .whl é um tipo de arquivo ZIP que contém uma distribuição criada com binários pré-compilados para um sistema operacional específico e uma arquitetura de conjunto de instruções. Para tornar seu pacote de implantação compatível com o Lambda, instale o wheel para sistemas operacionais Linux e a arquitetura do conjunto de instruções da sua função.
Alguns pacotes podem estar disponíveis apenas como distribuições de origem. Para esses pacotes, você mesmo precisa compilar e construir os componentes C/C\$1\$1.
Para ver quais distribuições estão disponíveis para o pacote necessário, faça o seguinte:
1. Pesquise o nome do pacote na [página principal do Python Package Index](https://pypi.org/).
1. Escolha a versão do pacote que você deseja usar.
1. Escolha **Baixar arquivos**.
### Trabalhar com distribuições construídas (wheels)
Para baixar um wheels compatível com o Lambda, use a opção `--platform` do pip.
Se a função do Lambda usar a arquitetura do conjunto de instruções **x86\$164**, execute o comando `pip install` a seguir para instalar um wheel compatível no diretório `package`. Substitua `--python 3.x` pela versão do runtime do Python que você está usando.
```
pip install \
--platform manylinux2014_x86_64 \
--target=package \
--implementation cp \
--python-version 3.x \
--only-binary=:all: --upgrade \
```
Se sua função usar a arquitetura do conjunto de instruções **arm64**, execute o comando a seguir. Substitua `--python 3.x` pela versão do runtime do Python que você está usando.
```
pip install \
--platform manylinux2014_aarch64 \
--target=package \
--implementation cp \
--python-version 3.x \
--only-binary=:all: --upgrade \
```
### Trabalhar com distribuições de origem
Se seu pacote só estiver disponível como distribuição de origem, você mesmo precisará criar as bibliotecas C/C\$1\$1. Para tornar o pacote compatível com o ambiente de execução do Lambda, é necessário compilá-lo em um ambiente que use o mesmo sistema operacional Amazon Linux. Você pode fazer isso compilando o pacote em uma instância Linux do Amazon Elastic Compute Cloud (Amazon EC2).
Para saber como iniciar e se conectar a uma instância do Linux no Amazon EC2, consulte [Comece a usar o Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html) no *Guia do usuário do Amazon EC2*.
## Criar e atualizar funções do Lambda em Python usando arquivos .zip
Depois de criar o pacote de implantação .zip, você poderá usá-lo para criar uma função do Lambda ou atualizar uma existente. É possível implantar o pacote .zip usando o console do Lambda, a AWS Command Line Interface e a API do Lambda. Você também pode criar e atualizar funções do Lambda usando o AWS Serverless Application Model (AWS SAM) e o CloudFormation.
O tamanho máximo de um pacote de implantação .zip para o Lambda é 250 MB (descompactado). Esse limite se aplica ao tamanho combinado de todos os arquivos que você carrega, inclusive qualquer camada do Lambda.
O runtime do Lambda precisa de permissão para ler os arquivos no pacote de implantação. Na notação octal de permissões do Linux, o Lambda precisa de 644 permissões para arquivos não executáveis (rw-r--r--) e 755 permissões (rwxr-xr-x) para diretórios e arquivos executáveis.
No Linux e no MacOS, use o comando `chmod` para alterar as permissões de arquivo em arquivos e diretórios do seu pacote de implantação. Por exemplo, para dar a um arquivo não executável as permissões corretas, execute o comando a seguir.
```
chmod 644
```
Para alterar as permissões de arquivo no Windows, consulte [Set, View, Change, or Remove Permissions on an Object](https://learn.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc731667(v=ws.10)) na documentação do Microsoft Windows.
**nota**
Se você não conceder ao Lambda as permissões necessárias para acessar diretórios no seu pacote de implantação, o Lambda definirá as permissões desses diretórios como 755 (rwxr-xr-x).
### Criar e atualizar funções com arquivos .zip usando o console
Para criar uma nova função, você deve primeiro criar a função no console e depois carregar o arquivo .zip. Para atualizar uma função existente, abra a página da função e siga o mesmo procedimento para adicionar o arquivo .zip atualizado.
Se o arquivo .zip for menor que 50 MB, você poderá criar ou atualizar uma função carregando o arquivo diretamente da máquina local. Para arquivos .zip maiores que 50 MB, você deve primeiro carregar o pacote para um bucket do Amazon S3. Para obter instruções sobre como carregar um arquivo para um bucket do Amazon S3 usando o Console de gerenciamento da AWS, consulte [Conceitos básicos do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html). Para carregar arquivos usando a AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) no *Guia do usuário da AWS CLI*.
**nota**
Você não pode alterar o [tipo de pacote de implantação](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-PackageType) (.zip ou imagem de contêiner) de uma função existente. Por exemplo, você não pode converter uma função de imagem de contêiner para usar um arquivo compactado .zip. É necessário criar uma nova função.
**Para criar uma função (console)**
1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda e escolha **Criar função**.
1. Escolha **Author from scratch** (Criar do zero).
1. Em **Basic information** (Informações básicas), faça o seguinte:
1. Em **Nome da função**, insira o nome da função.
1. Em **Runtime**, selecione o runtime que você deseja usar.
1. (Opcional) Em **Arquitetura**, escolha a arquitetura do conjunto de instruções para a função. O valor da arquitetura padrão é X86\$164. Certifique-se de que o pacote de implantação .zip da função seja compatível com a arquitetura do conjunto de instruções que você escolheu.
1. (Opcional) Em **Permissões**, expanda **Alterar função de execução padrão**. Crie uma **função de execução** ou use uma existente.
1. Escolha a opção **Criar função**. O Lambda cria uma função básica “Hello world” usando o runtime escolhido.
**Você pode carregar o arquivo .zip da máquina local (console)**
1. Na [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console Lambda, escolha a função para a qual você deseja carregar o arquivo .zip.
1. Selecione a guia **Código**.
1. No painel do **Código-fonte**, escolha **Carregar de**.
1. Escolha o **arquivo .zip**.
1. Para carregar o arquivo .zip, faça o seguinte:
1. Selecione **Carregar** e, em seguida, selecione o arquivo .zip no seletor de arquivos.
1. Escolha **Open (Abrir)**.
1. Escolha **Salvar**.
**Para carregar um arquivo .zip de um bucket do Amazon S3 (console)**
1. Na [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda, escolha a função para a qual você deseja carregar um novo arquivo .zip.
1. Selecione a guia **Código**.
1. No painel do **Código-fonte**, escolha **Carregar de**.
1. Escolha **Local do Amazon S3**.
1. Cole o URL do link do Amazon S3 do arquivo .zip e escolha **Salvar**.
### Atualizar funções do arquivo .zip usando o editor de código do console
Para algumas funções com pacotes de implantação .zip, você pode usar o editor de código integrado do console do Lambda para atualizar o código da função diretamente. Para usar esse recurso, a função deve atender aos seguintes critérios:
+ A função deve usar um dos runtimes da linguagem interpretada (Python, Node.js ou Ruby)
+ O pacote de implantação da função precisa ter menos de 50 MB (sem compactação).
O código das funções com pacotes de implantação de imagens de contêiner não pode ser editado diretamente no console.
**Para atualizar o código da função usando o editor de código do console**
1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda e selecione a função.
1. Selecione a guia **Código**.
1. No painel **Código-fonte**, selecione o arquivo de código-fonte e edite-o no editor de código integrado.
1. Na seção **DEPLOY**, escolha **Implantar** para atualizar o código da função:
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
### Criar e atualizar funções com arquivos .zip usando a AWS CLI
Você pode usar a [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) para criar uma função ou atualizar uma existente usando um arquivo .zip. Use os comandos [create-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) e [update-function-code](https://docs.aws.amazon.com/cli/latest/reference/lambda/create-function.html) para implantar o pacote .zip. Se o arquivo .zip for menor que 50 MB, você poderá carregar o pacote .zip de um local do arquivo na máquina de compilação local. Para arquivos .zip maiores, você deve carregar o pacote .zip de um bucket do Amazon S3. Para obter instruções sobre como carregar um arquivo para um bucket do Amazon S3 usando a AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) no *Guia do usuário da AWS CLI*.
**nota**
Se você carregar o arquivo .zip de um bucket do Amazon S3 usando a AWS CLI, o bucket deverá estar na mesma Região da AWS que sua função.
Para criar uma função usando um arquivo .zip com a AWS CLI, você deve especificar o seguinte:
+ O nome da função (`--function-name`)
+ O runtime da função (`--runtime`)
+ O nome do recurso da Amazon (ARN) da [função de execução](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) da função (`--role`)
+ O nome do método do manipulador no código da função (`--handler`)
Você também deve especificar a local do arquivo .zip. Se o arquivo .zip estiver localizado em uma pasta da máquina de compilação local, use a opção `--zip-file` para especificar o caminho do arquivo, conforme mostrado no comando do exemplo a seguir.
```
aws lambda create-function --function-name myFunction \
--runtime python3.14 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--zip-file fileb://myFunction.zip
```
Para especificar o local do arquivo .zip em um bucket do Amazon S3, use a opção `--code` conforme mostrado no comando do exemplo a seguir. Você só precisa usar o parâmetro `S3ObjectVersion` para objetos com versionamento.
```
aws lambda create-function --function-name myFunction \
--runtime python3.14 --handler lambda_function.lambda_handler \
--role arn:aws:iam::111122223333:role/service-role/my-lambda-role \
--code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion
```
Para atualizar uma função existente usando a CLI, especifique o nome da função usando o parâmetro `--function-name`. Você também deve especificar o local do arquivo .zip que deseja usar para atualizar o código da função. Se o arquivo .zip estiver localizado em uma pasta da máquina de compilação local, use a opção `--zip-file` para especificar o caminho do arquivo, conforme mostrado no comando do exemplo a seguir.
```
aws lambda update-function-code --function-name myFunction \
--zip-file fileb://myFunction.zip
```
Para especificar o local do arquivo .zip em um bucket do Amazon S3, use as opções `--s3-bucket` e `--s3-key` conforme mostrado no comando do exemplo a seguir. Você só precisa usar o parâmetro `--s3-object-version` para objetos com versionamento.
```
aws lambda update-function-code --function-name myFunction \
--s3-bucket amzn-s3-demo-bucket --s3-key myFileName.zip --s3-object-version myObject Version
```
### Criar e atualizar funções com arquivos .zip usando a API do Lamba
Para criar e atualizar funções usando um arquivo .zip, use as seguintes operações de API:
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
+ [UpdateFunctionCode](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionCode.html)
### Criar e atualizar funções com arquivos .zip usando o AWS SAM
O AWS Serverless Application Model (AWS SAM) é um kit de ferramentas que ajuda a simplificar o processo de criação e execução de aplicações com tecnologia sem servidor na AWS. Você define os recursos para a aplicação em um modelo YAML ou JSON e usa a interface da linha de comando do AWS SAM (CLI do AWS SAM) para criar, empacotar e implantar aplicações. Quando você cria uma função do Lambda com base em um modelo do AWS SAM, o AWS SAM cria automaticamente um pacote de implantação .zip ou uma imagem de contêiner com o código da função e quaisquer dependências que você especificar. Para saber mais sobre como usar o AWS SAM para criar e implantar funções do Lambda, consulte [Conceitos básicos do AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-getting-started.html) no *Guia do desenvolvedor do AWS Serverless Application Model*.
Você também pode usar o AWS SAM para criar uma função do Lambda usando um arquivo .zip existente. Para criar uma função do Lambda usando o AWS SAM, salve o arquivo .zip em um bucket do Amazon S3 ou em uma pasta local na máquina de compilação. Para obter instruções sobre como carregar um arquivo para um bucket do Amazon S3 usando a AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) no *Guia do usuário da AWS CLI*.
No modelo do AWS SAM, o recurso `AWS::Serverless::Function` especifica a função do Lambda. Nesse recurso, defina as seguintes propriedades para criar uma função usando um arquivo .zip:
+ `PackageType`: definir como `Zip`
+ `CodeUri`: definir como o URI do Amazon S3 do código da função, o caminho para a pasta local ou o objeto [FunctionCode](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-property-function-functioncode.html)
+ `Runtime`: definir como o runtime escolhido
Com o AWS SAM, se o arquivo .zip for maior que 50 MB, você não precisará carregá-lo primeiro em um bucket do Amazon S3. O AWS SAM poderá carregar pacotes .zip com o tamanho máximo permitido de 250 MB (descompactados) de um local da máquina de compilação local.
Para saber mais sobre a implantação de funções usando o arquivo .zip no AWS SAM, consulte [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html) no *Guia do desenvolvedor do AWS SAM*.
### Criar e atualizar funções com arquivos .zip usando o CloudFormation
Você pode usar o CloudFormation para criar uma função do Lambda usando um arquivo .zip. Para criar uma função do Lambda de um arquivo.zip, primeiro carregue o arquivo em um bucket do Amazon S3. Para obter instruções sobre como carregar um arquivo para um bucket do Amazon S3 usando a AWS CLI, consulte [Mover objetos](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-objects-move) no *Guia do usuário da AWS CLI. *
Para os runtimes do Node.js e do Python, você também pode fornecer código-fonte embutido no modelo CloudFormation. Em seguida, o CloudFormation cria um arquivo .zip que contém o código quando você cria a função.
**Usar um arquivo .zip existente**
No modelo do CloudFormation, o recurso `AWS::Lambda::Function` especifica a função do Lambda. Nesse recurso, defina as seguintes propriedades para criar uma função usando um arquivo .zip:
+ `PackageType`: definir como `Zip`
+ `Code`: inserir o nome do bucket do Amazon S3 e o nome do arquivo .zip nos campos `S3Bucket` e `S3Key`
+ `Runtime`: definir como o runtime escolhido
**Criar um arquivo .zip com base no código embutido**
Você pode declarar funções simples escritas em Python ou Node.js embutidas em um modelo do CloudFormation. Como o código está incorporado em YAML ou JSON, você não pode adicionar nenhuma dependência externa ao pacote de implantação. Isso significa que a função precisa usar a versão do AWS SDK que está incluída no runtime. Os requisitos do modelo, como a necessidade de evitar certos caracteres, também dificultam o uso dos recursos de verificação de sintaxe e preenchimento de código do IDE. Isso significa que seu modelo pode exigir testes adicionais. Em função dessas limitações, declarar funções embutidas é mais adequado para códigos muito simples que não mudam com frequência.
Para criar um arquivo .zip com base no código embutido para runtimes do Node.js e do Python, defina as seguintes propriedades no recurso `AWS::Lambda::Function` do modelo:
+ `PackageType`: definir como `Zip`
+ `Code`: digitar o código da função no campo `ZipFile`
+ `Runtime`: definir como o runtime escolhido
O arquivo .zip que o CloudFormation gera não pode exceder 4 MB. Para saber mais sobre a implantação de funções usando o arquivo .zip no CloudFormation, consulte [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html) no *Guia do desenvolvedor do CloudFormation*.
# Implante funções do Lambda em Python com imagens de contêiner
Existem três maneiras de criar uma imagem de contêiner para uma função do Lambda em Python:
+ [Usar uma imagem base da AWS para Python](#python-image-instructions)
As [imagens base da AWS](images-create.md#runtimes-images-lp) são pré-carregadas com um runtime de linguagem, um cliente de interface de runtime para gerenciar a interação entre o Lambda e o código da sua função e um emulador de interface de runtime para testes locais.
+ [Usar uma imagem base somente para sistema operacional da AWS](images-create.md#runtimes-images-provided)
[As imagens base somente para sistema operacional da AWS](https://gallery.ecr.aws/lambda/provided) contêm uma distribuição do Amazon Linux e o [emulador de interface de runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/). Essas imagens são comumente usadas para criar imagens de contêiner para linguagens compiladas, como [Go](go-image.md#go-image-provided) e [Rust](lambda-rust.md) e para uma linguagem ou versão de linguagem para a qual o Lambda não fornece uma imagem base, como Node.js 19. Também é possível usar imagens base somente para sistema operacional para implementar um [runtime personalizado](runtimes-custom.md). Para tornar a imagem compatível com o Lambda, você deve incluir [o cliente de interface de runtime do Python](#python-image-clients) na imagem.
+ [Usar uma imagem base que não é da AWS](#python-image-clients)
Também é possível usar uma imagem base alternativa de outro registro de contêiner, como Alpine Linux ou Debian. Também é possível usar uma imagem personalizada criada por sua organização. Para tornar a imagem compatível com o Lambda, você deve incluir [o cliente de interface de runtime do Python](#python-image-clients) na imagem.
**dica**
Para reduzir o tempo necessário para que as funções do contêiner do Lambda se tornem ativas, consulte [Use multi-stage builds](https://docs.docker.com/build/building/multi-stage/) na documentação do Docker. Para criar imagens de contêiner eficientes, siga as [Melhores práticas para gravar Dockerfiles](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/).
Esta página explica como criar, testar e implantar imagens de contêiner para o Lambda.
**Topics**
+ [Imagens base da AWS para Python](#python-image-base)
+ [Usar uma imagem base da AWS para Python](#python-image-instructions)
+ [Usar uma imagem base alternativa com o cliente da interface de runtime](#python-image-clients)
## Imagens base da AWS para Python
A AWS fornece as seguintes imagens base para Python:
| Tags | Runtime | Sistema operacional | Dockerfile | Desaprovação |
| --- | --- | --- | --- | --- |
| 3.14 | Python 3.14 | Amazon Linux 2023 | [Dockerfile para Python 3.14 no GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.14/Dockerfile.python3.14) | 30 de junho de 2029 |
| 3.13 | Python 3.13 | Amazon Linux 2023 | [Dockerfile para Python 3.13 no GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.13/Dockerfile.python3.13) | 30 de junho de 2029 |
| 3.12 | Python 3.12 | Amazon Linux 2023 | [Dockerfile para Python 3.12 no GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.12/Dockerfile.python3.12) | 31 de outubro de 2028 |
| 3.11 | Python 3.11 | Amazon Linux 2 | [Dockerfile para Python 3.11 no GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.11/Dockerfile.python3.11) | 30º de junho de 2027 |
| 3.10 | Python 3.10 | Amazon Linux 2 | [Dockerfile para Python 3.10 no GitHub](https://github.com/aws/aws-lambda-base-images/blob/python3.10/Dockerfile.python3.10) | 31 de outubro de 2026 |
Repositório do Amazon ECR: [gallery.ecr.aws/lambda/python](https://gallery.ecr.aws/lambda/python)
As imagens base do Python 3.12 e posteriores são baseadas na [imagem de contêiner mínimo do Amazon Linux 2023](https://docs.aws.amazon.com/linux/al2023/ug/minimal-container.html). As imagens base do Python 3.8-3.11 são baseadas na imagem do Amazon Linux 2. As imagens baseadas no AL2023 oferecem várias vantagens em relação ao Amazon Linux 2, incluindo uma área de implantação menor e versões atualizadas de bibliotecas, como `glibc`.
As imagens baseadas no AL2023 usam o `microdnf` (com link simbólico `dnf`) como o gerenciador de pacotes, em vez do `yum`, que é o gerenciador de pacotes padrão no Amazon Linux 2. O `microdnf` é uma implementação autônoma do `dnf`. Para obter uma lista dos pacotes incluídos nas imagens baseadas no AL2023, consulte as colunas **Contêiner mínimo** em [Comparar pacotes instalados em imagens de contêiner do Amazon Linux 2023](https://docs.aws.amazon.com/linux/al2023/ug/al2023-container-image-types.html). Para obter mais informações sobre as diferenças entre o AL2023 e o Amazon Linux 2, consulte [Introdução ao runtime do Amazon Linux 2023 para AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/) no blog AWS Compute.
**nota**
Para executar imagens baseadas no AL2023 localmente, inclusive com o AWS Serverless Application Model (AWS SAM), você deve usar o Docker versão 20.10.10 ou posterior.
### Caminho de pesquisa de dependência nas imagens base
Quando você usa uma instrução `import` no código, o runtime do Python pesquisa os diretórios no caminho de pesquisa até encontrar o módulo ou pacote. Por padrão, o runtime pesquisa primeiro o diretório `{LAMBDA_TASK_ROOT}`. Se você incluir uma versão de uma biblioteca incluída no runtime em sua imagem, sua versão terá precedência sobre a versão incluída no runtime.
Outras etapas no caminho de pesquisa dependem da versão da imagem base do Lambda para Python que você está usando:
+ **Python 3.11 e posteriores**: as bibliotecas incluídas no runtime e as bibliotecas instaladas no pip são instaladas no diretório `/var/lang/lib/python3.11/site-packages`. Esse diretório tem precedência sobre `/var/runtime` no caminho de pesquisa. É possível substituir o SDK usando o pip para instalar uma versão mais recente. É possível usar o pip para verificar se o SDK incluído no runtime e suas dependências são compatíveis com qualquer pacote que você instalar.
+ **Python 3.8-3.10**: as bibliotecas incluídas no runtime são instaladas no diretório `/var/runtime`. As bibliotecas instaladas pelo pip são instaladas no diretório `/var/lang/lib/python3.x/site-packages`. O diretório `/var/runtime` tem precedência sobre `/var/lang/lib/python3.x/site-packages` no caminho de pesquisa.
É possível ver o caminho de pesquisa completo para a função do Lambda adicionando o trecho de código a seguir.
```
import sys
search_path = sys.path
print(search_path)
```
## Usar uma imagem base da AWS para Python
### Pré-requisitos
Para executar as etapas desta seção, você deve ter o seguinte:
+ [AWS CLI versão 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versão mínima 25.0.0)
+ O plug-in [buildx](https://github.com/docker/buildx/blob/master/README.md) do Docker.
+ Python
### Criação de uma imagem a partir de uma imagem base
**Para criar uma imagem de contêiner com base em uma imagem base da AWS para Python**
1. Crie um diretório para o projeto e depois mude para esse diretório.
```
mkdir example
cd example
```
1. Crie um novo arquivo chamado `lambda_function.py`. É possível adicionar o exemplo de código de função a seguir ao arquivo para testes ou usar o seu próprio código.
**Example Função do Python**
```
import sys
def handler(event, context):
return 'Hello from AWS Lambda using Python' + sys.version + '!'
```
1. Crie um novo arquivo chamado `requirements.txt`. Caso esteja usando o exemplo de código de função da etapa anterior, você poderá deixar o arquivo em branco porque não há dependências. Caso contrário, liste cada biblioteca necessária. Por exemplo, veja como `requirements.txt` deverá ficar se as funções usarem o AWS SDK para Python (Boto3):
**Example requirements.txt**
```
boto3
```
1. Crie um novo Dockerfile com a seguinte configuração:
+ Defina a propriedade `FROM` como o [URI da imagem base](https://gallery.ecr.aws/lambda/python/).
+ Use o comando COPY para copiar o código da função e as dependências do runtime para `{LAMBDA_TASK_ROOT}`, uma [variável de ambiente definida pelo Lambda](configuration-envvars.md#configuration-envvars-runtime).
+ Defina o argumento `CMD` como o manipulador de funções do Lambda.
Observe que o Dockerfile de exemplo não inclui uma [instrução USER](https://docs.docker.com/reference/dockerfile/#user). Quando você implanta uma imagem de contêiner no Lambda, o Lambda define automaticamente um usuário padrão do Linux com permissões de privilégio mínimo. Isso é diferente do comportamento padrão do Docker, que adota o usuário `root` como padrão quando nenhuma instrução `USER` é fornecida.
**Example Dockerfile**
```
FROM public.ecr.aws/lambda/python:3.12
# Copy requirements.txt
COPY requirements.txt ${LAMBDA_TASK_ROOT}
# Install the specified packages
RUN pip install -r requirements.txt
# Copy function code
COPY lambda_function.py ${LAMBDA_TASK_ROOT}
# Set the CMD to your handler (could also be done as a parameter override outside of the Dockerfile)
CMD [ "lambda_function.handler" ]
```
1. Crie a imagem do Docker com o comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). O exemplo a seguir nomeia a imagem como `docker-image` e atribui a ela a [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Para tornar sua imagem compatível com o Lambda, é necessário usar a opção `--provenance=false`.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**nota**
O comando especifica a opção `--platform linux/amd64` para garantir que seu contêiner seja compatível com o ambiente de execução do Lambda, independentemente da arquitetura da sua máquina de compilação. Se você pretende criar uma função do Lambda usando a arquitetura do conjunto de instruções ARM64, certifique-se de alterar o comando para usar a opção `--platform linux/arm64` em vez disso.
### (Opcional) Teste a imagem localmente
1. Inicie a imagem do Docker com o comando **docker run**. Neste exemplo, `docker-image` é o nome da imagem e `test` é a tag.
```
docker run --platform linux/amd64 -p 9000:8080 docker-image:test
```
Esse comando executa a imagem como um contêiner e cria um endpoint local em `localhost:9000/2015-03-31/functions/function/invocations`.
**nota**
Se você criou a imagem do Docker para a arquitetura do conjunto de instruções ARM64, certifique-se de usar a opção `--platform linux/arm64`, em vez de `--platform linux/amd64`.
1. Em uma nova janela de terminal, publique um evento no endpoint local.
------
#### [ Linux/macOS ]
No Linux e no MacOS, execute o seguinte comando `curl`:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Esse comando invoca a função com um evento vazio e retorna uma resposta. Caso esteja usando seu próprio código de função em vez do código de função de exemplo, você talvez queira invocar a função com uma carga útil JSON. Exemplo:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
No PowerShell, execute o seguinte comando `Invoke-WebRequest`:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Esse comando invoca a função com um evento vazio e retorna uma resposta. Caso esteja usando seu próprio código de função em vez do código de função de exemplo, você talvez queira invocar a função com uma carga útil JSON. Exemplo:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Obtenha o ID do contêiner.
```
docker ps
```
1. Use o comando [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) para parar o contêiner. Nesse comando, substitua `3766c4ab331c` pelo ID do contêiner da etapa anterior.
```
docker kill 3766c4ab331c
```
### Implantação da imagem
**Para enviar a imagem ao Amazon ECR e criar a função do Lambda**
1. Execute o comando [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html) para autenticar a CLI do Docker no seu registro do Amazon ECR.
+ Defina o valor `--region` para a Região da AWS onde você deseja criar o repositório do Amazon ECR.
+ Substituir `111122223333` por seu ID da Conta da AWS.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. Crie um repositório no Amazon ECR usando o comando [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**nota**
O repositório do Amazon ECR deve estar na mesma Região da AWS que a função do Lambda.
Se tiver êxito, você verá uma resposta como esta:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Copie o `repositoryUri` da saída na etapa anterior.
1. Execute o comando [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) para aplicar uma tag na sua imagem local em seu repositório do Amazon ECR como a versão mais recente. Neste comando:
+ `docker-image:test` é o nome e a [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) da sua imagem do Docker. Esse é o nome e a tag da imagem que você especificou no comando `docker build`.
+ Substitua `` pelo `repositoryUri` que você copiou. Certifique-se de incluir `:latest` no final do URI.
```
docker tag docker-image:test :latest
```
Exemplo:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Execute o comando [docker push](https://docs.docker.com/engine/reference/commandline/push/) para implantar a imagem local no repositório do Amazon ECR. Certifique-se de incluir `:latest` no final do URI do repositório.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Crie um perfil de execução](lambda-intro-execution-role.md#permissions-executionrole-api) para a função, caso ainda não tenha um. Você precisará do nome do recurso da Amazon (ARN) do perfil na próxima etapa.
1. Criar a função do Lambda. Em `ImageUri`, especifique o URI do repositório anterior. Certifique-se de incluir `:latest` no final do URI.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**nota**
É possível criar uma função usando uma imagem em uma conta da AWS diferente desde que a imagem esteja na mesma região da função do Lambda. Para obter mais informações, consulte [Permissões entre contas do Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Invoque a função.
```
aws lambda invoke --function-name hello-world response.json
```
Você obterá uma resposta parecida com esta:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Para ver a saída da função, verifique o arquivo `response.json`.
Para atualizar o código da função, você deve criar a imagem novamente, fazer upload da nova imagem no repositório do Amazon ECR e, em seguida, usar o comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) para implantar a imagem na função do Lambda.
O Lambda resolve a tag de imagem em um resumo de imagem específico. Isso significa que, se você apontar a tag de imagem que foi usada para implantar a função em uma nova imagem no Amazon ECR, o Lambda não atualizará automaticamente a função para usar a nova imagem.
Para implantar a nova imagem na mesma função do Lambda, você deverá usar o comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html), mesmo que a tag da imagem no Amazon ECR permaneça a mesma. No exemplo a seguir, a opção `--publish` cria uma nova versão da função usando a imagem de contêiner atualizada.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
## Usar uma imagem base alternativa com o cliente da interface de runtime
Se você usar uma [imagem base somente para sistema operacional](images-create.md#runtimes-images-provided) ou uma imagem base alternativa, deverá incluir o cliente de interface de runtime na imagem. O cliente de interface de runtime estende [API de runtime](runtimes-api.md), que gerencia a interação entre o Lambda e o código da sua função.
Instale o [cliente de interface de runtime para Python](https://pypi.org/project/awslambdaric) usando o gerenciador de pacotes pip:
```
pip install awslambdaric
```
Também é possível baixar o [cliente de interface de runtime Python](https://github.com/aws/aws-lambda-python-runtime-interface-client/) no GitHub.
O exemplo a seguir demonstra como criar uma imagem de contêiner para Python usando uma imagem base que não é da AWS. O exemplo de Dockerfile usa uma imagem base oficial do Python. O Dockerfile inclui o cliente de interface de runtime para Python.
### Pré-requisitos
Para executar as etapas desta seção, você deve ter o seguinte:
+ [AWS CLI versão 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Docker](https://docs.docker.com/get-docker) (versão mínima 25.0.0)
+ O plug-in [buildx](https://github.com/docker/buildx/blob/master/README.md) do Docker.
+ Python
### Criar uma imagem de uma imagem base alternativa
**Para criar uma imagem de contêiner de uma imagem base que não é da AWS**
1. Crie um diretório para o projeto e depois mude para esse diretório.
```
mkdir example
cd example
```
1. Crie um novo arquivo chamado `lambda_function.py`. É possível adicionar o exemplo de código de função a seguir ao arquivo para testes ou usar o seu próprio código.
**Example Função do Python**
```
import sys
def handler(event, context):
return 'Hello from AWS Lambda using Python' + sys.version + '!'
```
1. Crie um novo arquivo chamado `requirements.txt`. Caso esteja usando o exemplo de código de função da etapa anterior, você poderá deixar o arquivo em branco porque não há dependências. Caso contrário, liste cada biblioteca necessária. Por exemplo, veja como `requirements.txt` deverá ficar se as funções usarem o AWS SDK para Python (Boto3):
**Example requirements.txt**
```
boto3
```
1. Crie um novo Dockerfile. O Dockerfile a seguir usa uma imagem base oficial do Python em vez de uma [imagem base da AWS](images-create.md#runtimes-images-lp). O Dockerfile inclui o [cliente de interface de runtime](https://pypi.org/project/awslambdaric), o que torna a imagem compatível com o Lambda. O exemplo de Dockerfile a seguir usa uma [compilação em várias etapas](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#use-multi-stage-builds).
+ Defina a propriedade `FROM` como a imagem básica.
+ Defina o `ENTRYPOINT` como o módulo em que você deseja que o contêiner do Docker seja executado quando for iniciado. Nesse caso, o módulo é o cliente de interface de runtime.
+ Defina o `CMD` como o manipulador de funções do Lambda.
Observe que o Dockerfile de exemplo não inclui uma [instrução USER](https://docs.docker.com/reference/dockerfile/#user). Quando você implanta uma imagem de contêiner no Lambda, o Lambda define automaticamente um usuário padrão do Linux com permissões de privilégio mínimo. Isso é diferente do comportamento padrão do Docker, que adota o usuário `root` como padrão quando nenhuma instrução `USER` é fornecida.
**Example Dockerfile**
```
# Define custom function directory
ARG FUNCTION_DIR="/function"
FROM python:3.12 AS build-image
# Include global arg in this stage of the build
ARG FUNCTION_DIR
# Copy function code
RUN mkdir -p ${FUNCTION_DIR}
COPY . ${FUNCTION_DIR}
# Install the function's dependencies
RUN pip install \
--target ${FUNCTION_DIR} \
awslambdaric
# Use a slim version of the base Python image to reduce the final image size
FROM python:3.12-slim
# Include global arg in this stage of the build
ARG FUNCTION_DIR
# Set working directory to function root directory
WORKDIR ${FUNCTION_DIR}
# Copy in the built dependencies
COPY --from=build-image ${FUNCTION_DIR} ${FUNCTION_DIR}
# Set runtime interface client as default command for the container runtime
ENTRYPOINT [ "/usr/local/bin/python", "-m", "awslambdaric" ]
# Pass the name of the function handler as an argument to the runtime
CMD [ "lambda_function.handler" ]
```
1. Crie a imagem do Docker com o comando [docker build](https://docs.docker.com/engine/reference/commandline/build/). O exemplo a seguir nomeia a imagem como `docker-image` e atribui a ela a [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) `test`. Para tornar sua imagem compatível com o Lambda, é necessário usar a opção `--provenance=false`.
```
docker buildx build --platform linux/amd64 --provenance=false -t docker-image:test .
```
**nota**
O comando especifica a opção `--platform linux/amd64` para garantir que seu contêiner seja compatível com o ambiente de execução do Lambda, independentemente da arquitetura da sua máquina de compilação. Se você pretende criar uma função do Lambda usando a arquitetura do conjunto de instruções ARM64, certifique-se de alterar o comando para usar a opção `--platform linux/arm64` em vez disso.
### (Opcional) Teste a imagem localmente
Use o [emulador de interface de runtime](https://github.com/aws/aws-lambda-runtime-interface-emulator/) para testar a imagem localmente. É possível [compilar o emulador em sua imagem](https://github.com/aws/aws-lambda-runtime-interface-emulator/?tab=readme-ov-file#build-rie-into-your-base-image) ou usar o procedimento a seguir instalá-lo na sua máquina local.
**Para instalar o emulador de interface de runtime na sua máquina local**
1. No diretório do projeto, execute o comando a seguir para baixar o emulador de interface de runtime (arquitetura x86-64) do GitHub e instalá-lo na sua máquina local.
------
#### [ Linux/macOS ]
```
mkdir -p ~/.aws-lambda-rie && \
curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
chmod +x ~/.aws-lambda-rie/aws-lambda-rie
```
Para instalar o emulador arm64, substitua o URL do repositório do GitHub no comando anterior pelo seguinte:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
#### [ PowerShell ]
```
$dirPath = "$HOME\.aws-lambda-rie"
if (-not (Test-Path $dirPath)) {
New-Item -Path $dirPath -ItemType Directory
}
$downloadLink = "https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie"
$destinationPath = "$HOME\.aws-lambda-rie\aws-lambda-rie"
Invoke-WebRequest -Uri $downloadLink -OutFile $destinationPath
```
Para instalar o emulador de arm64, substitua `$downloadLink` pelo seguinte:
```
https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie-arm64
```
------
1. Inicie a imagem do Docker com o comando **docker run**. Observe o seguinte:
+ `docker-image` é o nome da imagem e `test` é a tag.
+ `/usr/local/bin/python -m awslambdaric lambda_function.handler` é o `ENTRYPOINT` seguido pelo `CMD` do Dockerfile.
------
#### [ Linux/macOS ]
```
docker run --platform linux/amd64 -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
--entrypoint /aws-lambda/aws-lambda-rie \
docker-image:test \
/usr/local/bin/python -m awslambdaric lambda_function.handler
```
------
#### [ PowerShell ]
```
docker run --platform linux/amd64 -d -v "$HOME\.aws-lambda-rie:/aws-lambda" -p 9000:8080 `
--entrypoint /aws-lambda/aws-lambda-rie `
docker-image:test `
/usr/local/bin/python -m awslambdaric lambda_function.handler
```
------
Esse comando executa a imagem como um contêiner e cria um endpoint local em `localhost:9000/2015-03-31/functions/function/invocations`.
**nota**
Se você criou a imagem do Docker para a arquitetura do conjunto de instruções ARM64, certifique-se de usar a opção `--platform linux/arm64`, em vez de `--platform linux/amd64`.
1. Publique um evento no endpoint local.
------
#### [ Linux/macOS ]
No Linux e no MacOS, execute o seguinte comando `curl`:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'
```
Esse comando invoca a função com um evento vazio e retorna uma resposta. Caso esteja usando seu próprio código de função em vez do código de função de exemplo, você talvez queira invocar a função com uma carga útil JSON. Exemplo:
```
curl "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{"payload":"hello world!"}'
```
------
#### [ PowerShell ]
No PowerShell, execute o seguinte comando `Invoke-WebRequest`:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{}' -ContentType "application/json"
```
Esse comando invoca a função com um evento vazio e retorna uma resposta. Caso esteja usando seu próprio código de função em vez do código de função de exemplo, você talvez queira invocar a função com uma carga útil JSON. Exemplo:
```
Invoke-WebRequest -Uri "http://localhost:9000/2015-03-31/functions/function/invocations" -Method Post -Body '{"payload":"hello world!"}' -ContentType "application/json"
```
------
1. Obtenha o ID do contêiner.
```
docker ps
```
1. Use o comando [docker kill](https://docs.docker.com/engine/reference/commandline/kill/) para parar o contêiner. Nesse comando, substitua `3766c4ab331c` pelo ID do contêiner da etapa anterior.
```
docker kill 3766c4ab331c
```
### Implantação da imagem
**Para enviar a imagem ao Amazon ECR e criar a função do Lambda**
1. Execute o comando [get-login-password](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/get-login-password.html) para autenticar a CLI do Docker no seu registro do Amazon ECR.
+ Defina o valor `--region` para a Região da AWS onde você deseja criar o repositório do Amazon ECR.
+ Substituir `111122223333` por seu ID da Conta da AWS.
```
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-east-1.amazonaws.com
```
1. Crie um repositório no Amazon ECR usando o comando [create-repository](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ecr/create-repository.html).
```
aws ecr create-repository --repository-name hello-world --region us-east-1 --image-scanning-configuration scanOnPush=true --image-tag-mutability MUTABLE
```
**nota**
O repositório do Amazon ECR deve estar na mesma Região da AWS que a função do Lambda.
Se tiver êxito, você verá uma resposta como esta:
```
{
"repository": {
"repositoryArn": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world",
"registryId": "111122223333",
"repositoryName": "hello-world",
"repositoryUri": "111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world",
"createdAt": "2023-03-09T10:39:01+00:00",
"imageTagMutability": "MUTABLE",
"imageScanningConfiguration": {
"scanOnPush": true
},
"encryptionConfiguration": {
"encryptionType": "AES256"
}
}
}
```
1. Copie o `repositoryUri` da saída na etapa anterior.
1. Execute o comando [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) para aplicar uma tag na sua imagem local em seu repositório do Amazon ECR como a versão mais recente. Neste comando:
+ `docker-image:test` é o nome e a [tag](https://docs.docker.com/engine/reference/commandline/build/#tag) da sua imagem do Docker. Esse é o nome e a tag da imagem que você especificou no comando `docker build`.
+ Substitua `` pelo `repositoryUri` que você copiou. Certifique-se de incluir `:latest` no final do URI.
```
docker tag docker-image:test :latest
```
Exemplo:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. Execute o comando [docker push](https://docs.docker.com/engine/reference/commandline/push/) para implantar a imagem local no repositório do Amazon ECR. Certifique-se de incluir `:latest` no final do URI do repositório.
```
docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
1. [Crie um perfil de execução](lambda-intro-execution-role.md#permissions-executionrole-api) para a função, caso ainda não tenha um. Você precisará do nome do recurso da Amazon (ARN) do perfil na próxima etapa.
1. Criar a função do Lambda. Em `ImageUri`, especifique o URI do repositório anterior. Certifique-se de incluir `:latest` no final do URI.
```
aws lambda create-function \
--function-name hello-world \
--package-type Image \
--code ImageUri=111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--role arn:aws:iam::111122223333:role/lambda-ex
```
**nota**
É possível criar uma função usando uma imagem em uma conta da AWS diferente desde que a imagem esteja na mesma região da função do Lambda. Para obter mais informações, consulte [Permissões entre contas do Amazon ECR](images-create.md#configuration-images-xaccount-permissions).
1. Invoque a função.
```
aws lambda invoke --function-name hello-world response.json
```
Você obterá uma resposta parecida com esta:
```
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}
```
1. Para ver a saída da função, verifique o arquivo `response.json`.
Para atualizar o código da função, você deve criar a imagem novamente, fazer upload da nova imagem no repositório do Amazon ECR e, em seguida, usar o comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) para implantar a imagem na função do Lambda.
O Lambda resolve a tag de imagem em um resumo de imagem específico. Isso significa que, se você apontar a tag de imagem que foi usada para implantar a função em uma nova imagem no Amazon ECR, o Lambda não atualizará automaticamente a função para usar a nova imagem.
Para implantar a nova imagem na mesma função do Lambda, você deverá usar o comando [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html), mesmo que a tag da imagem no Amazon ECR permaneça a mesma. No exemplo a seguir, a opção `--publish` cria uma nova versão da função usando a imagem de contêiner atualizada.
```
aws lambda update-function-code \
--function-name hello-world \
--image-uri 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest \
--publish
```
Para obter um exemplo de como criar uma imagem Python a partir de uma imagem base Alpine, consulte [Container image support for Lambda](https://aws.amazon.com/blogs/aws/new-for-aws-lambda-container-image-support/) no AWS Blog.
# Como trabalhar com camadas para funções do Lambda em Python
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
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
**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
**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
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
------
#### [ 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
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.
# Usar o objeto de contexto do Lambda para recuperar informações das funções em Python
Quando o Lambda executa a função, ele transmite um objeto de contexto para o [handler](python-handler.md). Esse objeto fornece métodos e propriedades que fornecem informações sobre a invocação, a função e o ambiente de execução. Para obter mais informações sobre como o objeto de contexto é passado para o manipulador de funções, consulte [Definir o manipulador de função do Lambda em Python](python-handler.md).
**Métodos de contexto**
+ `get_remaining_time_in_millis`: retorna o número de milissegundos restantes antes do tempo limite da execução.
**Propriedades de contexto**
+ `function_name`: o nome da função do Lambda.
+ `function_version`: a [versão](configuration-versions.md) da função.
+ `invoked_function_arn`: o nome do recurso da Amazon (ARN) usado para invocar a função. Indica se o invocador especificou um alias ou número de versão.
+ `memory_limit_in_mb`: a quantidade de memória alocada para a função.
+ `aws_request_id`: o identificador da solicitação de invocação.
+ `log_group_name`: o grupo de logs da função.
+ `log_stream_name`: a transmissão de log para a instância da função.
+ `identity`: (aplicativos móveis) informações sobre a identidade do Amazon Cognito que autorizou a solicitação.
+ `cognito_identity_id`: a identidade autenticada do Amazon Cognito.
+ `cognito_identity_pool_id`: o grupo de identidades do Amazon Cognito que autorizou a invocação.
+ `client_context`: (aplicativos móveis) contexto do cliente fornecido ao Lambda pela aplicação cliente.
+ `client.installation_id`
+ `client.app_title`
+ `client.app_version_name`
+ `client.app_version_code`
+ `client.app_package_name`
+ `custom`: um `dict` de valores personalizados definidos pela aplicação cliente para dispositivos móveis.
+ `env`: um `dict` de informações do ambiente fornecidas pelo AWS SDK.
O Powertools para Lambda (Python) fornece uma definição de interface para o objeto de contexto do Lambda. Você pode usar a definição da interface para dicas de tipo ou para inspecionar ainda mais a estrutura do objeto de contexto do Lambda. Para a definição da interface, consulte [lambda\$1context.py](https://github.com/aws-powertools/powertools-lambda-python/blob/develop/aws_lambda_powertools/utilities/typing/lambda_context.py) no repositório *powertools-lambda-python* no GitHub.
O exemplo a seguir mostra uma função do handler que registra informações de contexto.
**Example handler.py**
```
import time
def lambda_handler(event, context):
print("Lambda function ARN:", context.invoked_function_arn)
print("CloudWatch log stream name:", context.log_stream_name)
print("CloudWatch log group name:", context.log_group_name)
print("Lambda Request ID:", context.aws_request_id)
print("Lambda function memory limits in MB:", context.memory_limit_in_mb)
# We have added a 1 second delay so you can see the time remaining in get_remaining_time_in_millis.
time.sleep(1)
print("Lambda time remaining in MS:", context.get_remaining_time_in_millis())
```
Além das opções listadas acima, você também pode usar o AWS X-Ray SDK para [Instrumentação do código Python no AWS Lambda](python-tracing.md) para identificar caminhos de código críticos, rastrear a performance e capturar os dados para análise.
# Registrar em log e monitorar funções do Lambda em Python
O AWS Lambda monitora automaticamente as funções do Lambda e envia entradas de logs para o Amazon CloudWatch. Sua função do Lambda vem com um grupo de logs do CloudWatch Logs e uma transmissão de logs para cada instância de sua função. O ambiente de runtime do Lambda envia detalhes sobre cada invocação e outras saídas do código da função para o fluxo de logs. Para obter mais informações sobre o CloudWatch Logs, consulte [Enviar logs de função do Lambda para o CloudWatch Logs](monitoring-cloudwatchlogs.md).
Para gerar logs do seu código de função, use o módulo integrado [https://docs.python.org/3/library/logging.html](https://docs.python.org/3/library/logging.html). Para entradas mais detalhadas, você pode usar qualquer biblioteca de registro em log que grava em `stdout` ou `stderr`.
## Imprimir para o log
Para enviar uma saída básica para os logs, use um método `print` em sua função. O exemplo a seguir registra em log os valores do fluxo e do grupo de logs do CloudWatch Logs e o objeto do evento.
Se a sua função gera logs usando instruções Python `print`, o Lambda só poderá enviar saídas de log para o CloudWatch Logs em formato de texto simples. Para capturar logs em JSON estruturado, você precisa usar uma biblioteca de logs compatível. Consulte [Usar controles avançados de registro em log do Lambda com Python](#python-logging-advanced) para obter mais informações.
**Example lambda\$1function.py**
```
import os
def lambda_handler(event, context):
print('## ENVIRONMENT VARIABLES')
print(os.environ['AWS_LAMBDA_LOG_GROUP_NAME'])
print(os.environ['AWS_LAMBDA_LOG_STREAM_NAME'])
print('## EVENT')
print(event)
```
**Example saída do log**
```
START RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Version: $LATEST
## ENVIRONMENT VARIABLES
/aws/lambda/my-function
2025/08/31/[$LATEST]3893xmpl7fac4485b47bb75b671a283c
## EVENT
{'key': 'value'}
END RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95
REPORT RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Duration: 15.74 ms Billed Duration: 147 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 130.49 ms
XRAY TraceId: 1-5e34a614-10bdxmplf1fb44f07bc535a1 SegmentId: 07f5xmpl2d1f6f85 Sampled: true
```
O runtime do Python registra as linhas `START`, `END` e `REPORT` para cada invocação. A linha `REPORT` inclui os seguintes dados:
**RELATAR campos de dados de linha**
+ **RequestId**: o ID de solicitação exclusivo para a invocação.
+ **Duração**: a quantidade de tempo que o método de manipulador da função gastou processando o evento.
+ **Duração faturada**: a quantia de tempo faturada para a invocação.
+ **Tamanho da memória**: a quantidade de memória alocada para a função.
+ **Memória máxima utilizada**: a quantidade de memória utilizada pela função. Quando as invocações compartilham um ambiente de execução, o Lambda relata a memória máxima usada em todas as invocações. Esse comportamento pode resultar em um valor relatado maior do que o esperado.
+ **Duração inicial**: para a primeira solicitação atendida, a quantidade de tempo que o runtime levou para carregar a função e executar o código fora do método do handler.
+ **XRAY TraceId**: para solicitações rastreadas, o [ID de rastreamento do AWS X-Ray](services-xray.md).
+ **SegmentId**: para solicitações rastreadas, o ID do segmento do X-Ray.
+ **Amostragem**: para solicitações rastreadas, o resultado da amostragem.
## Usar uma biblioteca de registro em log
Para logs mais detalhados, use o módulo [registro em log](https://docs.python.org/3/library/logging.html) na biblioteca padrão ou em qualquer biblioteca de registro em log de terceiros que grava em `stdout` ou `stderr`.
Para runtimes do Python compatíveis, você pode escolher se os registros criados usando o módulo `logging` padrão são capturados em texto simples ou JSON. Para saber mais, consulte [Usar controles avançados de registro em log do Lambda com Python](#python-logging-advanced).
Atualmente, o formato padrão de log para todos os runtimes do Python é texto simples. O exemplo a seguir mostra como as saídas de log criadas usando o módulo `logging` padrão são capturadas em texto simples no CloudWatch Logs.
```
import os
import logging
logger = logging.getLogger()
logger.setLevel("INFO")
def lambda_handler(event, context):
logger.info('## ENVIRONMENT VARIABLES')
logger.info(os.environ['AWS_LAMBDA_LOG_GROUP_NAME'])
logger.info(os.environ['AWS_LAMBDA_LOG_STREAM_NAME'])
logger.info('## EVENT')
logger.info(event)
```
A saída de `logger` inclui o nível do log, o timestamp e o ID da solicitação.
```
START RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Version: $LATEST
[INFO] 2025-08-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## ENVIRONMENT VARIABLES
[INFO] 2025-08-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 /aws/lambda/my-function
[INFO] 2025-08-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 2025/01/31/[$LATEST]1bbe51xmplb34a2788dbaa7433b0aa4d
[INFO] 2025-08-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## EVENT
[INFO] 2025-08-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 {'key': 'value'}
END RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125
REPORT RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Duration: 2.75 ms Billed Duration: 117 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 113.51 ms
XRAY TraceId: 1-5e34a66a-474xmpl7c2534a87870b4370 SegmentId: 073cxmpl3e442861 Sampled: true
```
**nota**
Quando o formato de log da função é definido como texto sem formatação, a configuração padrão de nível de log para runtimes do Python é WARN. Isso significa que o Lambda só envia saídas de log de nível WARN e inferior para o CloudWatch Logs. Para alterar o nível de log padrão, use o método `logging` `setLevel()` do Python conforme mostrado neste código de exemplo. Se você definir o formato do log da função como JSON, recomendamos que você configure o nível de log da função usando os controles de registro em log avançados do Lambda e não definindo o nível de log no código. Para saber mais, consulte [Usar a filtragem em nível de log com Python](#python-logging-levels)
## Usar controles avançados de registro em log do Lambda com Python
Para dar mais controle sobre como os logs das funções são capturados, processados e consumidos, você pode configurar as seguintes opções de registro em log para runtimes do Python compatíveis com o Lambda:
+ **Formato do log**: selecione entre texto simples e formato JSON estruturado para os logs da sua função.
+ **Nível de log**: para logs no formato JSON, escolha o nível de detalhe dos logs enviados pelo Lambda para o Amazon CloudWatch, como ERROR, DEBUG ou INFO.
+ **Grupo de logs**: escolha o grupo de logs do CloudWatch para o qual sua função envia logs.
Para obter mais informações sobre essas opções de registro em log e instruções sobre como configurar a função para usá-las, consulte [Configurar controles avançados de registro em log para funções do Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced).
Para saber mais sobre como usar as opções de formato de log e nível de log com as funções do Lambda para Python, consulte as orientações nas seções a seguir.
### Usar logs JSON estruturados com Python
Se você selecionar JSON para o formato de log da sua função, o Lambda enviará a saída de logs da biblioteca de logs padrão do Python para o CloudWatch como JSON estruturado. Cada objeto de log JSON contém pelo menos quatro pares de valores-chave com as seguintes chaves:
+ `"timestamp"`: o horário em que a mensagem de log foi gerada.
+ `"level"`: o nível de log atribuído à mensagem.
+ `"message"`: o conteúdo da mensagem de log.
+ `"requestId"`: o ID de solicitação exclusivo para invocar a função.
A biblioteca `logging` do Python também pode adicionar pares de valores de chave, como `"logger"`, para esse objeto JSON.
Os exemplos nas seções a seguir mostram como as saídas de log geradas usando a biblioteca `logging` do Python são capturadas no CloudWatch Logs quando você configura o formato de log da função como JSON.
Se você usar o método `print` para produzir saídas básicas de log, conforme descrito em [Imprimir para o log](#python-logging-output), o Lambda capturará essas saídas como texto simples, mesmo se o formato de log da função for configurado como JSON.
#### Saídas de log JSON padrão usando a biblioteca de logs do Python
O exemplo de trecho de código e saída de log a seguir mostra como as saídas de log padrão geradas usando a biblioteca `logging` do Python são capturadas no CloudWatch Logs quando o formato de log da função é configurado como JSON.
**Example Código de log do Python**
```
import logging
logger = logging.getLogger()
def lambda_handler(event, context):
logger.info("Inside the handler function")
```
**Example Registro em log JSON**
```
{
"timestamp":"2025-10-27T19:17:45.586Z",
"level":"INFO",
"message":"Inside the handler function",
"logger": "root",
"requestId":"79b4f56e-95b1-4643-9700-2807f4e68189"
}
```
#### Registrar parâmetros extras em log JSON
Quando o formato de log da sua função está definido como JSON, você também pode registrar parâmetros adicionais em log com a biblioteca `logging` do Python padrão usando a palavra-chave `extra` para passar um dicionário do Python para a saída do log.
**Example Código de log do Python**
```
import logging
def lambda_handler(event, context):
logging.info(
"extra parameters example",
extra={"a":"b", "b": [3]},
)
```
**Example Registro em log JSON**
```
{
"timestamp": "2025-11-02T15:26:28Z",
"level": "INFO",
"message": "extra parameters example",
"logger": "root",
"requestId": "3dbd5759-65f6-45f8-8d7d-5bdc79a3bd01",
"a": "b",
"b": [
3
]
}
```
#### Exceções de log em JSON
O trecho de código a seguir mostra como as exceções do Python são capturadas na saída de log da função quando o formato de log é configurado como JSON. Observe que as saídas de log geradas usando `logging.exception` são atribuídas ao nível de log ERROR.
**Example Código de log do Python**
```
import logging
def lambda_handler(event, context):
try:
raise Exception("exception")
except:
logging.exception("msg")
```
**Example Registro em log JSON**
```
{
"timestamp": "2025-11-02T16:18:57Z",
"level": "ERROR",
"message": "msg",
"logger": "root",
"stackTrace": [
" File \"/var/task/lambda_function.py\", line 15, in lambda_handler\n raise Exception(\"exception\")\n"
],
"errorType": "Exception",
"errorMessage": "exception",
"requestId": "3f9d155c-0f09-46b7-bdf1-e91dab220855",
"location": "/var/task/lambda_function.py:lambda_handler:17"
}
```
#### Logs JSON estruturados com outras ferramentas de registro em log
Se o código já usa outra biblioteca de logs, como o Powertools para AWS Lambda, para produzir logs JSON estruturados, você não precisará fazer nenhuma alteração. O AWS Lambda não codifica duas vezes nenhum log que já esteja codificado em JSON. Mesmo que a função seja configurada para usar logs em formato JSON, suas saídas de log serão exibidas no CloudWatch com a estrutura JSON que você definiu.
O exemplo a seguir mostra como as saídas de log geradas usando o pacote Powertools para AWS Lambda são capturadas no CloudWatch Logs. O formato da saída de log é o mesmo, independentemente se a configuração de log da função for definida como JSON ou TEXT. Para obter mais informações sobre como usar o Powertools para AWS Lambda, consulte [Uso do Powertools para AWS Lambda (Python) e do AWS SAM para registro em log estruturado](#python-logging-sam) e [Uso do Powertools para AWS Lambda (Python) e do AWS CDK para registro em log estruturado](#python-logging-powertools-cdk).
**Example Trecho de código de log em Python (usando o Powertools para AWS Lambda)**
```
from aws_lambda_powertools import Logger
logger = Logger()
def lambda_handler(event, context):
logger.info("Inside the handler function")
```
**Example Registro em log JSON (usando o Powertools para AWS Lambda)**
```
{
"level": "INFO",
"location": "lambda_handler:7",
"message": "Inside the handler function",
"timestamp": "2025-10-31 22:38:21,010+0000",
"service": "service_undefined",
"xray_trace_id": "1-654181dc-65c15d6b0fecbdd1531ecb30"
}
```
### Usar a filtragem em nível de log com Python
Ao configurar a filtragem em nível de log, você pode optar por enviar somente logs de um determinado nível, ou inferior, para o CloudWatch Logs. Para saber como configurar a filtragem em nível de log para a função, consulte [Filtragem em nível de log](monitoring-cloudwatchlogs-log-level.md).
Para o AWS Lambda filtrar os logs de aplicação de acordo com o nível de log, a função precisa usar logs em formato JSON. Isso pode ser feito de duas maneiras:
+ Crie saídas de log usando a biblioteca `logging` padrão do Python e configure a função para usar logs em formato JSON. Dessa forma, o AWS Lambda filtra as saídas de log usando o par de valores-chave “nível” no objeto JSON descrito em [Usar logs JSON estruturados com Python](#python-logging-JSON). Para saber como configurar o formato de log da função, consulte [Configurar controles avançados de registro em log para funções do Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced).
+ Use outro método ou biblioteca de logs para criar logs JSON estruturados no código, de modo que incluam um par de valores-chave de “nível” para definir o nível da saída de log. Por exemplo, você pode usar o Powertools para AWS Lambda para gerar saídas de log JSON estruturado do seu código.
Também é possível usar uma instrução de impressão para gerar um objeto JSON que contenha um identificador de nível de log. A instrução de impressão a seguir produz uma saída em formato JSON em que o nível do leg é definido como INFO. O AWS Lambda enviará o objeto JSON para o CloudWatch Logs se o nível de log da função estiver definido como INFO, DEBUG ou TRACE.
```
print('{"msg":"My log message", "level":"info"}')
```
Para que o Lambda filtre os logs da função, você também precisa incluir um par de valores-chave `"timestamp"` na saída do log JSON. A hora deve ser especificada em um formato [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) válido de carimbo de data/hora. Se você não fornecer um carimbo de data/hora válido, o Lambda atribuirá ao log o nível INFO e adicionará um carimbo de data/hora.
## Visualização de logs no console do Lambda
É possível usar o console do Lambda para exibir a saída do log depois de invocar uma função do Lambda.
Se seu código puder ser testado no editor de **Código** incorporado, você encontrará logs nos **resultados de execução**. Ao usar o recurso de teste do console para invocar uma função, você encontrará **Saída de log** na seção **Detalhes**.
## Visualização de logs no console do CloudWatch
É possível usar o console do Amazon CloudWatch para exibir logs de todas as invocações da função do Lambda.
**Para visualizar logs no console do CloudWatch**
1. No console do Amazon CloudWatch, abra a [página Log groups](https://console.aws.amazon.com/cloudwatch/home?#logs:) (Grupos de log).
1. Escolha o grupo de logs de sua função (**/aws/lambda/*nome-de-sua-função***).
1. Escolha um stream de logs.
Cada fluxo de log corresponde a uma [instância da sua função](lambda-runtime-environment.md). Um fluxo de logs é exibido quando você atualiza sua função do Lambda e quando mais instâncias são criadas para lidar com invocações simultâneas. Para localizar logs de uma invocação específica, recomendamos intrumentar sua função com AWS X-Ray. O X-Ray registra detalhes sobre a solicitação e o stream de logs no rastreamento.
## Visualização de logs com a AWS CLI
O AWS CLI é uma ferramenta de código aberto que permite interagir com os serviços do AWS usando comandos no shell da linha de comando. Para concluir as etapas desta seção, você deve ter a [versão 2 da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
É possível usar a [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) para recuperar logs de uma invocação usando a opção de comando `--log-type`. A resposta contém um campo `LogResult` com até 4 KB de logs codificados em base64 obtidos da invocação.
**Example recuperar um ID de log**
O exemplo a seguir mostra como recuperar um *ID de log* do campo `LogResult` para uma função chamada `my-function`.
```
aws lambda invoke --function-name my-function out --log-type Tail
```
A seguinte saída deverá ser mostrada:
```
{
"StatusCode": 200,
"LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}
```
**Example decodificar os logs**
No mesmo prompt de comando, use o utilitário `base64` para decodificar os logs. O exemplo a seguir mostra como recuperar logs codificados em base64 de `my-function`.
```
aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode
```
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*.
A seguinte saída deverá ser mostrada:
```
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed Duration: 80 ms Memory Size: 128 MB Max Memory Used: 73 MB
```
O utilitário `base64` está disponível no Linux, macOS e [Ubuntu no Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Os usuários do macOS precisam usar `base64 -D`.
**Example get-logs.sh script**
No mesmo prompt de comando, use o script a seguir para fazer download dos últimos cinco eventos de log. O script usa `sed` para remover as aspas do arquivo de saída e fica inativo por 15 segundos para que os logs tenham tempo de ficar disponíveis. A saída inclui a resposta do Lambda, e a saída do comando `get-log-events`.
Copie o conteúdo do exemplo de código a seguir e salve no diretório de seu projeto do Lambda como `get-logs.sh`.
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*.
```
#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5
```
**Example macOS e Linux (somente)**
No mesmo prompt de comando, os usuários do macOS e do Linux podem precisar executar o comando a seguir para garantir que o script seja executável.
```
chmod -R 755 get-logs.sh
```
**Example recuperar os últimos cinco eventos de log**
No mesmo prompt de comando, execute o script a seguir para obter os últimos cinco eventos de log.
```
./get-logs.sh
```
A seguinte saída deverá ser mostrada:
```
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
"ingestionTime": 1559763003309
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}
```
## Excluir logs
Os grupos de logs não são excluídos automaticamente excluídos quando você exclui uma função. Para evitar armazenar logs indefinidamente, exclua o grupo de logs ou[configurar um período de retenção](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention)após o qual os logs são excluídos automaticamente.
## Usar outras ferramentas e bibliotecas de registro em log
O [Powertools para AWS Lambda (Python)](https://docs.aws.amazon.com/powertools/python/) é um kit de ferramentas para desenvolvedores para implementar práticas recomendadas da tecnologia sem servidor e aumentar a velocidade do desenvolvedor. O [utilitário Logger](https://docs.aws.amazon.com/powertools/python/latest/core/logger/) fornece um registrador otimizado para Lambda que inclui informações adicionais sobre o contexto da função em todas as suas funções com saída estruturada como JSON. Use esse utilitário para fazer o seguinte:
+ Capturar campos-chave do contexto do Lambda, inicialização a frio e estruturas registrando em log a saída como JSON
+ Registrar em log eventos de invocação do Lambda quando instruído (desativado por padrão)
+ Imprimir todos os logs somente para uma porcentagem das invocações por meio da amostragem de logs (desativado por padrão)
+ Anexar chaves adicionais ao log estruturado a qualquer momento
+ Use um formatador de log personalizado (Bring Your Own Formatter) para gerar logs em uma estrutura compatível com o RFC de logs da sua organização
## Uso do Powertools para AWS Lambda (Python) e do AWS SAM para registro em log estruturado
Siga as etapas abaixo para baixar, construir e implantar um exemplo de aplicação Python Hello World com os módulos integrados do [Powertools for Python](https://docs.aws.amazon.com/powertools/python/latest/) com o AWS SAM. Esta aplicação implementa um backend de API básico e usa o Powertools para emitir logs, métricas e rastreamentos. Consiste em um endpoint do Amazon API Gateway e uma função do Lambda. Quando você envia uma solicitação GET ao endpoint do API Gateway, a função do Lambda invoca, envia logs e métricas usando o formato de métricas incorporadas ao CloudWatch e envia rastreamentos ao AWS X-Ray. A função retorna uma mensagem `hello world`.
**Pré-requisitos**
Para executar as etapas desta seção, você deve ter o seguinte:
+ Python 3.9
+ [AWS CLI versão 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS SAM CLI versão 1.75 ou posterior](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Se você tiver uma versão mais antiga da CLI do AWS SAM, consulte [Atualizando a CLI do AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade).
**Implantar uma aplicação de exemplo do AWS SAM**
1. Inicialize a aplicação usando o modelo Python do Hello World.
```
sam init --app-template hello-world-powertools-python --name sam-app --package-type Zip --runtime python3.9 --no-tracing
```
1. Crie a aplicação.
```
cd sam-app && sam build
```
1. Implante o aplicativo.
```
sam deploy --guided
```
1. Siga as instruções na tela. Para aceitar as opções padrão fornecidas na experiência interativa, pressione `Enter`.
**nota**
Em **HelloWorldFunction pode não ter autorização definida, tudo bem?**, certifique-se de inserir `y`.
1. Obtenha o URL da aplicação implantada:
```
aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text
```
1. Invoque o endpoint da API:
```
curl GET
```
Se tiver êxito, você verá esta resposta:
```
{"message":"hello world"}
```
1. Para obter os logs da função, execute [sam logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html). Para obter mais informações, consulte [Trabalhar com logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) no *Guia do desenvolvedor do AWS Serverless Application Model*.
```
sam logs --stack-name sam-app
```
O resultado de saída do log se parece com:
```
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:50.371000 INIT_START Runtime Version: python:3.9.v16 Runtime Version ARN: arn:aws:lambda:us-east-1::runtime:07a48df201798d627f2b950f03bb227aab4a655a1d019c3296406f95937e2525
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.112000 START RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Version: $LATEST
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.114000 {
"level": "INFO",
"location": "hello:23",
"message": "Hello world API - HTTP 200",
"timestamp": "2025-02-03 14:59:51,113+0000",
"service": "PowertoolsHelloWorld",
"cold_start": true,
"function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"function_memory_size": "128",
"function_arn": "arn:aws:lambda:us-east-1:111122223333:function:sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"function_request_id": "d455cfc4-7704-46df-901b-2a5cce9405be",
"correlation_id": "e73f8aef-5e07-436e-a30b-63e4b23f0047",
"xray_trace_id": "1-63dd2166-434a12c22e1307ff2114f299"
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 {
"_aws": {
"Timestamp": 1675436391126,
"CloudWatchMetrics": [
{
"Namespace": "Powertools",
"Dimensions": [
[
"function_name",
"service"
]
],
"Metrics": [
{
"Name": "ColdStart",
"Unit": "Count"
}
]
}
]
},
"function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"service": "PowertoolsHelloWorld",
"ColdStart": [
1.0
]
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 {
"_aws": {
"Timestamp": 1675436391126,
"CloudWatchMetrics": [
{
"Namespace": "Powertools",
"Dimensions": [
[
"service"
]
],
"Metrics": [
{
"Name": "HelloWorldInvocations",
"Unit": "Count"
}
]
}
]
},
"service": "PowertoolsHelloWorld",
"HelloWorldInvocations": [
1.0
]
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 END RequestId: d455cfc4-7704-46df-901b-2a5cce9405be
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 REPORT RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Duration: 16.33 ms Billed Duration: 756 ms Memory Size: 128 MB Max Memory Used: 64 MB Init Duration: 739.46 ms
XRAY TraceId: 1-63dd2166-434a12c22e1307ff2114f299 SegmentId: 3c5d18d735a1ced0 Sampled: true
```
1. Este é um endpoint de API pública que é acessado pela Internet. Recomendamos excluir o endpoint após o teste.
```
sam delete
```
### Gerenciar a retenção de logs
Os grupos de logs não são excluídos automaticamente excluídos quando você exclui uma função. Para evitar armazenar logs por tempo indeterminado, exclua o grupo de logs ou configure um período de retenção após o qual o CloudWatch excluirá os logs automaticamente. Para configurar a retenção de logs, adicione o seguinte ao seu modelo do AWS SAM:
```
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
# Omitting other properties
LogGroup:
Type: AWS::Logs::LogGroup
Properties:
LogGroupName: !Sub "/aws/lambda/${HelloWorldFunction}"
RetentionInDays: 7
```
## Uso do Powertools para AWS Lambda (Python) e do AWS CDK para registro em log estruturado
Siga as etapas abaixo para baixar, criar e implantar um exemplo de aplicação Python do Hello World com os módulos integrados do [Powertools para AWS Lambda Python](https://docs.aws.amazon.com/powertools/python/latest/) usando o AWS CDK. Esta aplicação implementa um backend de API básico e usa o Powertools para emitir logs, métricas e rastreamentos. Consiste em um endpoint do Amazon API Gateway e uma função do Lambda. Quando você envia uma solicitação GET ao endpoint do API Gateway, a função do Lambda invoca, envia logs e métricas usando o formato de métricas incorporadas ao CloudWatch e envia rastreamentos ao AWS X-Ray. A função retorna uma mensagem de hello world.
**Pré-requisitos**
Para executar as etapas desta seção, você deve ter o seguinte:
+ Python 3.9
+ [AWS CLI versão 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS CDK versão 2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_prerequisites)
+ [AWS SAM CLI versão 1.75 ou posterior](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Se você tiver uma versão mais antiga da CLI do AWS SAM, consulte [Atualizando a CLI do AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade).
**Implantar uma aplicação de exemplo do AWS CDK**
1. Crie um diretório de projeto para sua aplicação.
```
mkdir hello-world
cd hello-world
```
1. Inicialize a aplicação.
```
cdk init app --language python
```
1. Instale as dependências do Python.
```
pip install -r requirements.txt
```
1. Crie um diretório **lambda\$1function** na pasta raiz.
```
mkdir lambda_function
cd lambda_function
```
1. Crie um arquivo **app.py** e adicione o código a seguir ao arquivo. Este é o código da função do Lambda.
```
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools import Logger
from aws_lambda_powertools import Tracer
from aws_lambda_powertools import Metrics
from aws_lambda_powertools.metrics import MetricUnit
app = APIGatewayRestResolver()
tracer = Tracer()
logger = Logger()
metrics = Metrics(namespace="PowertoolsSample")
@app.get("/hello")
@tracer.capture_method
def hello():
# adding custom metrics
# See: https://docs.aws.amazon.com/powertools/python/latest//latest/core/metrics/
metrics.add_metric(name="HelloWorldInvocations", unit=MetricUnit.Count, value=1)
# structured log
# See: https://docs.aws.amazon.com/powertools/python/latest//latest/core/logger/
logger.info("Hello world API - HTTP 200")
return {"message": "hello world"}
# Enrich logging with contextual information from Lambda
@logger.inject_lambda_context(correlation_id_path=correlation_paths.API_GATEWAY_REST)
# Adding tracer
# See: https://docs.aws.amazon.com/powertools/python/latest//latest/core/tracer/
@tracer.capture_lambda_handler
# ensures metrics are flushed upon request completion/failure and capturing ColdStart metric
@metrics.log_metrics(capture_cold_start_metric=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context)
```
1. Abra o diretório **hello\$1world**. Você verá um arquivo chamado **hello-world-stack.py**.
```
cd ..
cd hello_world
```
1. Abra o **hello\$1world\$1stack.py** e adicione o código a seguir ao arquivo. Ele contém o [construtor do Lambda](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_lambda.html), que cria a função do Lambda, configura variáveis de ambiente para o Powertools e define a retenção de logs para uma semana, e o [construtor do ApiGatewayv1](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_apigateway.html), que cria a API REST.
```
from aws_cdk import (
Stack,
aws_apigateway as apigwv1,
aws_lambda as lambda_,
CfnOutput,
Duration
)
from constructs import Construct
class HelloWorldStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Powertools Lambda Layer
powertools_layer = lambda_.LayerVersion.from_layer_version_arn(
self,
id="lambda-powertools",
# Using AWS Lambda Powertools via Lambda Layer
# This imports the Powertools layer which provides observability features for Lambda functions
# For available versions, see: https://docs.aws.amazon.com/powertools/python/latest/#lambda-layer
)
function = lambda_.Function(self,
'sample-app-lambda',
runtime=lambda_.Runtime.PYTHON_3_9,
layers=[powertools_layer],
code = lambda_.Code.from_asset("./lambda_function/"),
handler="app.lambda_handler",
memory_size=128,
timeout=Duration.seconds(3),
architecture=lambda_.Architecture.X86_64,
environment={
"POWERTOOLS_SERVICE_NAME": "PowertoolsHelloWorld",
"POWERTOOLS_METRICS_NAMESPACE": "PowertoolsSample",
"LOG_LEVEL": "INFO"
}
)
apigw = apigwv1.RestApi(self, "PowertoolsAPI", deploy_options=apigwv1.StageOptions(stage_name="dev"))
hello_api = apigw.root.add_resource("hello")
hello_api.add_method("GET", apigwv1.LambdaIntegration(function, proxy=True))
CfnOutput(self, "apiUrl", value=f"{apigw.url}hello")
```
1. Implante o aplicativo.
```
cd ..
cdk deploy
```
1. Obtenha o URL da aplicação implantada:
```
aws cloudformation describe-stacks --stack-name HelloWorldStack --query 'Stacks[0].Outputs[?OutputKey==`apiUrl`].OutputValue' --output text
```
1. Invoque o endpoint da API:
```
curl GET
```
Se tiver êxito, você verá esta resposta:
```
{"message":"hello world"}
```
1. Para obter os logs da função, execute [sam logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html). Para obter mais informações, consulte [Trabalhar com logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) no *Guia do desenvolvedor do AWS Serverless Application Model*.
```
sam logs --stack-name HelloWorldStack
```
O resultado de saída do log se parece com:
```
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:50.371000 INIT_START Runtime Version: python:3.9.v16 Runtime Version ARN: arn:aws:lambda:us-east-1::runtime:07a48df201798d627f2b950f03bb227aab4a655a1d019c3296406f95937e2525
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.112000 START RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Version: $LATEST
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.114000 {
"level": "INFO",
"location": "hello:23",
"message": "Hello world API - HTTP 200",
"timestamp": "2025-02-03 14:59:51,113+0000",
"service": "PowertoolsHelloWorld",
"cold_start": true,
"function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"function_memory_size": "128",
"function_arn": "arn:aws:lambda:us-east-1:111122223333:function:sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"function_request_id": "d455cfc4-7704-46df-901b-2a5cce9405be",
"correlation_id": "e73f8aef-5e07-436e-a30b-63e4b23f0047",
"xray_trace_id": "1-63dd2166-434a12c22e1307ff2114f299"
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 {
"_aws": {
"Timestamp": 1675436391126,
"CloudWatchMetrics": [
{
"Namespace": "Powertools",
"Dimensions": [
[
"function_name",
"service"
]
],
"Metrics": [
{
"Name": "ColdStart",
"Unit": "Count"
}
]
}
]
},
"function_name": "sam-app-HelloWorldFunction-YBg8yfYtOc9j",
"service": "PowertoolsHelloWorld",
"ColdStart": [
1.0
]
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.126000 {
"_aws": {
"Timestamp": 1675436391126,
"CloudWatchMetrics": [
{
"Namespace": "Powertools",
"Dimensions": [
[
"service"
]
],
"Metrics": [
{
"Name": "HelloWorldInvocations",
"Unit": "Count"
}
]
}
]
},
"service": "PowertoolsHelloWorld",
"HelloWorldInvocations": [
1.0
]
}
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 END RequestId: d455cfc4-7704-46df-901b-2a5cce9405be
2025/02/03/[$LATEST]ea9a64ec87294bf6bbc9026c05a01e04 2025-02-03T14:59:51.128000 REPORT RequestId: d455cfc4-7704-46df-901b-2a5cce9405be Duration: 16.33 ms Billed Duration: 756 ms Memory Size: 128 MB Max Memory Used: 64 MB Init Duration: 739.46 ms
XRAY TraceId: 1-63dd2166-434a12c22e1307ff2114f299 SegmentId: 3c5d18d735a1ced0 Sampled: true
```
1. Este é um endpoint de API pública que é acessado pela Internet. Recomendamos excluir o endpoint após o teste.
```
cdk destroy
```
# Testes da função do AWS Lambda em Python
**nota**
Consulte o capítulo [Testar funções](testing-guide.md) para obter uma introdução completa às técnicas e melhores práticas para testar soluções com tecnologia sem servidor.
Os testes de funções com tecnologia sem servidor usam tipos e técnicas de teste tradicionais, mas você também deve considerar testar aplicações com tecnologia sem servidor como um todo. Os testes baseados em nuvem fornecerão a medida **mais precisa** da qualidade das suas funções e aplicações com tecnologia sem servidor.
Uma arquitetura de aplicações com tecnologia sem servidor inclui serviços gerenciados que fornecem funcionalidade de aplicações críticas por meio de chamadas de API. Por esse motivo, seu ciclo de desenvolvimento deve incluir testes automatizados que verifiquem a funcionalidade quando sua função e seus serviços interagem.
Se você não criar testes baseados em nuvem, poderá encontrar problemas devido às diferenças entre o ambiente local e o ambiente implantado. Seu processo de integração contínua deve executar testes em comparação com um conjunto de recursos provisionados na nuvem antes de promover seu código para o próximo ambiente de implantação, como GQ, Preparação ou Produção.
Continue lendo este breve guia para aprender sobre estratégias de testes para aplicações com tecnologia sem servidor ou acesse o [repositório de exemplos de testes com tecnologia sem servidor](https://github.com/aws-samples/serverless-test-samples) para conhecer exemplos práticos, específicos da linguagem e do runtime escolhidos.
![\[illustration showing the relationship between types of tests\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/test-type-illustration2.png)
Para testes com tecnologia sem servidor, você ainda escreverá testes *unitários*, de *integração* e de *ponta a ponta*.
+ **Testes unitários**: testes executados em comparação com um bloco de código isolado. Por exemplo, verificar a lógica de negócios para calcular a taxa de entrega de acordo com um item e um destino determinado.
+ **Testes de integração**: testes envolvendo dois ou mais componentes ou serviços que interagem, normalmente em um ambiente de nuvem. Por exemplo, a verificação de eventos de processos de uma função em uma fila.
+ **Testes de ponta a ponta**: testes que verificam o comportamento em toda a aplicação. Por exemplo, garantir que a infraestrutura seja configurada corretamente e que os eventos fluam entre os serviços conforme o esperado para registrar o pedido de um cliente.
## Testar suas aplicações com tecnologia sem servidor
Geralmente, você usará uma combinação de abordagens para testar o código da aplicação com tecnologia sem servidor, incluindo testes na nuvem, testes com simulações e, ocasionalmente, testes com emuladores.
### Testes na nuvem
Os testes na nuvem são valiosos para todas as fases dos testes, incluindo testes unitários, testes de integração e testes de ponta a ponta. Você executa testes com o código implantado na nuvem e interagindo com serviços baseados na nuvem. Essa abordagem fornece a medida **mais precisa** da qualidade do código.
Uma maneira conveniente de depurar a função do Lambda na nuvem é com o uso de um evento de teste no console. Um *evento de teste* é uma entrada JSON para sua função. Se a função não necessitar de entrada, o evento poderá ser um documento JSON vazio `({})`. O console fornece eventos de exemplo para uma variedade de integrações de serviços. Depois de criar um evento no console, você pode compartilhá-lo com sua equipe para tornar os testes mais fáceis e consistentes.
**nota**
[Testar uma função no console](testing-functions.md) é uma maneira rápida de começar a usar, mas automatizar os ciclos de teste garante a qualidade da aplicação e a velocidade de desenvolvimento.
### Ferramentas de teste
Existem ferramentas e técnicas para acelerar os loops de feedback de desenvolvimento. Por exemplo, o [AWS SAM Accelerate](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/accelerate.html) e o [modo de observação do AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy-watch) diminuem o tempo necessário para atualizar os ambientes de nuvem.
[Moto](https://pypi.org/project/moto/) é uma biblioteca Python para simular serviços e recursos da AWS para que você possa testar suas funções com pouca ou nenhuma modificação usando decoradores para interceptar e simular respostas.
O recurso de validação do [Powertools para AWS Lambda (Python)](https://docs.powertools.aws.dev/lambda-python/latest/utilities/validation/) fornece decoradores para que você possa validar eventos de entrada e respostas de saída das suas funções do Python.
Para obter mais informações, leia a publicação do blog [Testes de unidade do Lambda com Python e simulação dos serviços da AWS](https://aws.amazon.com/blogs/devops/unit-testing-aws-lambda-with-python-and-mock-aws-services/).
Para reduzir a latência envolvida com as iterações de implantação na nuvem, consulte [AWS Serverless Application Model (AWS SAM) Accelerate](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/using-sam-cli-sync.html) e o [modo de exibição do AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/v2/guide/cli.html#cli-deploy-watch). Essas ferramentas monitoram sua infraestrutura e codificam alterações. Elas reagem a essas alterações criando e implantando atualizações incrementais automaticamente em seu ambiente de nuvem.
Exemplos que usam essas ferramentas estão disponíveis no repositório de código de [exemplos de testes Python](https://github.com/aws-samples/serverless-test-samples/tree/main/python-test-samples).
# Instrumentação do código Python no AWS Lambda
O Lambda se integra ao AWS X-Ray para ajudar você a rastrear, depurar e otimizar aplicações do Lambda. É possível usar o X-Ray para rastrear uma solicitação enquanto ela atravessa recursos na aplicação, o que pode incluir funções Lambda e outros produtos da AWS.
Para enviar dados de rastreamento ao X-Ray, é possível usar uma das três bibliotecas SDK:
+ [AWS Distro for OpenTelemetry (ADOT)](https://aws.amazon.com/otel): uma distribuição segura, pronta para produção e com suporte na AWS do SDK OpenTelemetry (OTel).
+ [AWS X-Ray SDK for Python](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html) – um SDK para geração e envio de dados de rastreamento ao X-Ray.
+ [Powertools para AWS Lambda (Python)](https://docs.aws.amazon.com/powertools/python/latest/): um kit de ferramentas para desenvolvedores para implementar práticas recomendadas da tecnologia sem servidor e aumentar a velocidade do desenvolvedor.
Cada um dos SDKs oferece maneiras de enviar dados de telemetria ao serviço do X-Ray. Em seguida, é possível usar o X-Ray para visualizar, filtrar e obter insights sobre as métricas de performance da aplicação para identificar problemas e oportunidades de otimização.
**Importante**
Os SDKs do X-Ray e do Powertools para AWS Lambda fazem parte de uma solução de instrumentação totalmente integrada oferecida pela AWS. As camadas do Lambda para ADOT fazem parte de um padrão em todo o setor para instrumentação de rastreamento que coleta mais dados em geral, mas pode não ser adequado para todos os casos de uso. É possível implementar o rastreamento de ponta a ponta no X-Ray usando ambas as soluções. Para saber mais sobre como escolher entre elas, consulte [Como escolher entre os SDKs do AWS Distro para OpenTelemetry e do X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/xray-instrumenting-your-app.html#xray-instrumenting-choosing).
**Topics**
+ [Uso do Powertools para AWS Lambda (Python) e do AWS SAM para rastreamento](#python-tracing-sam)
+ [Uso do Powertools para AWS Lambda (Python) e do AWS CDK para rastreamento](#python-logging-cdk)
+ [Usar o ADOT para instrumentar funções Python](#python-adot)
+ [Usar o SDK do X-Ray para instrumentar suas funções Python](#python-xray-sdk)
+ [Ativar o rastreamento com o console do Lambda](#python-tracing-console)
+ [Ativar o rastreamento com a API do Lambda](#python-tracing-api)
+ [Ativar o rastreamento com o CloudFormation](#python-tracing-cloudformation)
+ [Interpretar um rastreamento do X-Ray](#python-tracing-interpretation)
+ [Armazenar dependências de runtime em uma camada (SDK do X-Ray)](#python-tracing-layers)
## Uso do Powertools para AWS Lambda (Python) e do AWS SAM para rastreamento
Siga as etapas abaixo para baixar, criar e implantar um exemplo de aplicação Python do Hello World com os módulos integrados do [Powertools para AWS Lambda Python](https://docs.powertools.aws.dev/lambda-python) usando o AWS SAM. Esta aplicação implementa um backend de API básico e usa o Powertools para emitir logs, métricas e rastreamentos. Consiste em um endpoint do Amazon API Gateway e uma função do Lambda. Quando você envia uma solicitação GET ao endpoint do API Gateway, a função do Lambda invoca, envia logs e métricas usando o formato de métricas incorporadas ao CloudWatch e envia rastreamentos ao AWS X-Ray. A função retorna uma mensagem de hello world.
**Pré-requisitos**
Para executar as etapas desta seção, você deve ter o seguinte:
+ Python 3.11
+ [AWS CLI versão 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS SAM CLI versão 1.75 ou posterior](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Se você tiver uma versão mais antiga da CLI do AWS SAM, consulte [Atualizando a CLI do AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade).
**Implantar uma aplicação de exemplo do AWS SAM**
1. Inicialize a aplicação usando o modelo Python do Hello World.
```
sam init --app-template hello-world-powertools-python --name sam-app --package-type Zip --runtime python3.11 --no-tracing
```
1. Crie a aplicação.
```
cd sam-app && sam build
```
1. Implante o aplicativo.
```
sam deploy --guided
```
1. Siga as instruções na tela. Para aceitar as opções padrão fornecidas na experiência interativa, pressione `Enter`.
**nota**
Em **HelloWorldFunction pode não ter autorização definida, tudo bem?**, certifique-se de inserir `y`.
1. Obtenha o URL da aplicação implantada:
```
aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text
```
1. Invoque o endpoint da API:
```
curl -X GET
```
Se tiver êxito, você verá esta resposta:
```
{"message":"hello world"}
```
1. Para obter os rastreamentos da função, execute [sam traces](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html).
```
sam traces
```
A saída de rastreamento se parece com:
```
New XRay Service Graph
Start time: 2023-02-03 14:59:50+00:00
End time: 2023-02-03 14:59:50+00:00
Reference Id: 0 - (Root) AWS::Lambda - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [1]
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.924
Reference Id: 1 - AWS::Lambda::Function - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: []
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.016
Reference Id: 2 - client - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [0]
Summary_statistics:
- total requests: 0
- ok count(2XX): 0
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0
XRay Event [revision 1] at (2023-02-03T14:59:50.204000) with id (1-63dd2166-434a12c22e1307ff2114f299) and duration (0.924s)
- 0.924s - sam-app-HelloWorldFunction-YBg8yfYtOc9j [HTTP: 200]
- 0.016s - sam-app-HelloWorldFunction-YBg8yfYtOc9j
- 0.739s - Initialization
- 0.016s - Invocation
- 0.013s - ## lambda_handler
- 0.000s - ## app.hello
- 0.000s - Overhead
```
1. Este é um endpoint de API pública que é acessado pela Internet. Recomendamos excluir o endpoint após o teste.
```
sam delete
```
O X-Ray não rastreia todas as solicitações para sua aplicação. O X-Ray aplica um algoritmo de amostragem para garantir que o rastreamento seja eficiente, enquanto ainda fornece uma amostra representativa das solicitações. A taxa de amostragem é uma solicitação por segundo e 5% de solicitações adicionais. Você não pode configurar a taxa de amostragem do X-Ray para suas funções.
## Uso do Powertools para AWS Lambda (Python) e do AWS CDK para rastreamento
Siga as etapas abaixo para baixar, criar e implantar um exemplo de aplicação Python do Hello World com os módulos integrados do [Powertools para AWS Lambda Python](https://docs.powertools.aws.dev/lambda-python) usando o AWS CDK. Esta aplicação implementa um backend de API básico e usa o Powertools para emitir logs, métricas e rastreamentos. Consiste em um endpoint do Amazon API Gateway e uma função do Lambda. Quando você envia uma solicitação GET ao endpoint do API Gateway, a função do Lambda invoca, envia logs e métricas usando o formato de métricas incorporadas ao CloudWatch e envia rastreamentos ao AWS X-Ray. A função retorna uma mensagem de hello world.
**Pré-requisitos**
Para executar as etapas desta seção, você deve ter o seguinte:
+ Python 3.11
+ [AWS CLI versão 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS CDK versão 2](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html#getting_started_prerequisites)
+ [AWS SAM CLI versão 1.75 ou posterior](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Se você tiver uma versão mais antiga da CLI do AWS SAM, consulte [Atualizando a CLI do AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade).
**Implantar uma aplicação de exemplo do AWS CDK**
1. Crie um diretório de projeto para sua aplicação.
```
mkdir hello-world
cd hello-world
```
1. Inicialize a aplicação.
```
cdk init app --language python
```
1. Instale as dependências do Python.
```
pip install -r requirements.txt
```
1. Crie um diretório **lambda\$1function** na pasta raiz.
```
mkdir lambda_function
cd lambda_function
```
1. Crie um arquivo **app.py** e adicione o código a seguir ao arquivo. Este é o código da função do Lambda.
```
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.utilities.typing import LambdaContext
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools import Logger
from aws_lambda_powertools import Tracer
from aws_lambda_powertools import Metrics
from aws_lambda_powertools.metrics import MetricUnit
app = APIGatewayRestResolver()
tracer = Tracer()
logger = Logger()
metrics = Metrics(namespace="PowertoolsSample")
@app.get("/hello")
@tracer.capture_method
def hello():
# adding custom metrics
# See: https://docs.powertools.aws.dev/lambda-python/latest/core/metrics/
metrics.add_metric(name="HelloWorldInvocations", unit=MetricUnit.Count, value=1)
# structured log
# See: https://docs.powertools.aws.dev/lambda-python/latest/core/logger/
logger.info("Hello world API - HTTP 200")
return {"message": "hello world"}
# Enrich logging with contextual information from Lambda
@logger.inject_lambda_context(correlation_id_path=correlation_paths.API_GATEWAY_REST)
# Adding tracer
# See: https://docs.powertools.aws.dev/lambda-python/latest/core/tracer/
@tracer.capture_lambda_handler
# ensures metrics are flushed upon request completion/failure and capturing ColdStart metric
@metrics.log_metrics(capture_cold_start_metric=True)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context)
```
1. Abra o diretório **hello\$1world**. Você verá um arquivo chamado **hello-world-stack.py**.
```
cd ..
cd hello_world
```
1. Abra o **hello\$1world\$1stack.py** e adicione o código a seguir ao arquivo. Ele contém o [construtor do Lambda](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_lambda.html), que cria a função do Lambda, configura variáveis de ambiente para o Powertools e define a retenção de logs para uma semana, e o [construtor do ApiGatewayv1](https://docs.aws.amazon.com/cdk/api/v1/python/aws_cdk.aws_apigateway.html), que cria a API REST.
```
from aws_cdk import (
Stack,
aws_apigateway as apigwv1,
aws_lambda as lambda_,
CfnOutput,
Duration
)
from constructs import Construct
class HelloWorldStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Powertools Lambda Layer
powertools_layer = lambda_.LayerVersion.from_layer_version_arn(
self,
id="lambda-powertools",
# At the moment we wrote this example, the aws_lambda_python_alpha CDK constructor is in Alpha, o we use layer to make the example simpler
# See https://docs.aws.amazon.com/cdk/api/v2/python/aws_cdk.aws_lambda_python_alpha/README.html
# Check all Powertools layers versions here: https://docs.powertools.aws.dev/lambda-python/latest/#lambda-layer
layer_version_arn=f"arn:aws:lambda:{self.region}:017000801446:layer:AWSLambdaPowertoolsPythonV2:21"
)
function = lambda_.Function(self,
'sample-app-lambda',
runtime=lambda_.Runtime.PYTHON_3_11,
layers=[powertools_layer],
code = lambda_.Code.from_asset("./lambda_function/"),
handler="app.lambda_handler",
memory_size=128,
timeout=Duration.seconds(3),
architecture=lambda_.Architecture.X86_64,
environment={
"POWERTOOLS_SERVICE_NAME": "PowertoolsHelloWorld",
"POWERTOOLS_METRICS_NAMESPACE": "PowertoolsSample",
"LOG_LEVEL": "INFO"
}
)
apigw = apigwv1.RestApi(self, "PowertoolsAPI", deploy_options=apigwv1.StageOptions(stage_name="dev"))
hello_api = apigw.root.add_resource("hello")
hello_api.add_method("GET", apigwv1.LambdaIntegration(function, proxy=True))
CfnOutput(self, "apiUrl", value=f"{apigw.url}hello")
```
1. Implante o aplicativo.
```
cd ..
cdk deploy
```
1. Obtenha o URL da aplicação implantada:
```
aws cloudformation describe-stacks --stack-name HelloWorldStack --query 'Stacks[0].Outputs[?OutputKey==`apiUrl`].OutputValue' --output text
```
1. Invoque o endpoint da API:
```
curl -X GET
```
Se tiver êxito, você verá esta resposta:
```
{"message":"hello world"}
```
1. Para obter os rastreamentos da função, execute [sam traces](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-traces.html).
```
sam traces
```
A saída dos rastreamentos se parece com:
```
New XRay Service Graph
Start time: 2023-02-03 14:59:50+00:00
End time: 2023-02-03 14:59:50+00:00
Reference Id: 0 - (Root) AWS::Lambda - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [1]
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.924
Reference Id: 1 - AWS::Lambda::Function - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: []
Summary_statistics:
- total requests: 1
- ok count(2XX): 1
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0.016
Reference Id: 2 - client - sam-app-HelloWorldFunction-YBg8yfYtOc9j - Edges: [0]
Summary_statistics:
- total requests: 0
- ok count(2XX): 0
- error count(4XX): 0
- fault count(5XX): 0
- total response time: 0
XRay Event [revision 1] at (2023-02-03T14:59:50.204000) with id (1-63dd2166-434a12c22e1307ff2114f299) and duration (0.924s)
- 0.924s - sam-app-HelloWorldFunction-YBg8yfYtOc9j [HTTP: 200]
- 0.016s - sam-app-HelloWorldFunction-YBg8yfYtOc9j
- 0.739s - Initialization
- 0.016s - Invocation
- 0.013s - ## lambda_handler
- 0.000s - ## app.hello
- 0.000s - Overhead
```
1. Este é um endpoint de API pública que é acessado pela Internet. Recomendamos excluir o endpoint após o teste.
```
cdk destroy
```
## Usar o ADOT para instrumentar funções Python
O ADOT fornece [camadas](chapter-layers.md) do Lambda totalmente gerenciadas que empacotam tudo o que você precisa para coletar dados de telemetria usando o SDK do OTel. Ao consumir essa camada, é possível instrumentar suas funções Lambda sem precisar modificar nenhum código de função. Você também pode configurar sua camada para fazer a inicialização personalizada do OTel. Para obter mais informações, consulte [Custom configuration for the ADOT Collector on Lambda](https://aws-otel.github.io/docs/getting-started/lambda#custom-configuration-for-the-adot-collector-on-lambda) (Configuração personalizada para o ADOT Collector no Lambda) na documentação do ADOT.
Para runtimes Python, você pode adicionar a **camada do Lambda gerenciada pela AWS para ADOT Python** a fim de instrumentar suas funções automaticamente. Essa camada funciona nas arquiteturas arm64 e x86\$164. Para obter instruções detalhadas sobre como adicionar essa camada, consulte [Suporte do AWS Distro for OpenTelemetry Lambda para Python](https://aws-otel.github.io/docs/getting-started/lambda/lambda-python).
## Usar o SDK do X-Ray para instrumentar suas funções Python
Para registrar detalhes sobre as chamadas feitas pela sua função do Lambda para outros recursos na sua aplicação, você também pode usar o AWS X-Ray SDK for Python. Para obter o SDK, adicione o pacote `aws-xray-sdk` às dependências do aplicativo.
**Example [requirements.txt](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-python/function/requirements.txt)**
```
jsonpickle==1.3
aws-xray-sdk==2.4.3
```
No seu código de função, você pode instrumentar clientes AWS SDK aplicando patch à biblioteca `boto3` com o módulo `aws_xray_sdk.core`.
**Example [função: rastrear um cliente AWS SDK](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-python/function/lambda_function.py)**
```
import boto3
from aws_xray_sdk.core import xray_recorder
from aws_xray_sdk.core import patch_all
logger = logging.getLogger()
logger.setLevel(logging.INFO)
patch_all()
client = boto3.client('lambda')
client.get_account_settings()
def lambda_handler(event, context):
logger.info('## ENVIRONMENT VARIABLES\r' + jsonpickle.encode(dict(**os.environ)))
...
```
Depois de adicionar as dependências corretas e fazer as devidas mudanças de código, ative o rastreamento na configuração da sua função usando o console do Lambda ou a API.
## Ativar o rastreamento com o console do Lambda
Para alternar o rastreamento ativo na sua função do Lambda usando o console, siga as etapas abaixo:
**Para ativar o rastreamento ativo**
1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda.
1. Escolha uma função.
1. Escolha **Configuration** (Configuração) e depois **Monitoring and operations tools** (Ferramentas de monitoramento e operações).
1. Em **Ferramentas de monitoramento adicionais**, selecione **Editar**.
1. Em **CloudWatch Application Signals e AWS X-Ray**, escolha **Habilitar** para **Rastreamentos do serviço Lambda**.
1. Escolha **Salvar**.
## Ativar o rastreamento com a API do Lambda
Configure o rastreamento na sua função do Lambda com a AWS CLI ou o AWS SDK, usando as seguintes operações de API:
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)
O exemplo de comando da AWS CLI a seguir habilita o rastreamento ativo em uma função chamada **my-function**.
```
aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active
```
O modo de rastreamento faz parte da configuração específica da versão quando você publica uma versão da função. Não é possível alterar o modo de rastreamento em uma versão publicada.
## Ativar o rastreamento com o CloudFormation
Para ativar o rastreamento ativo em um recurso `AWS::Lambda::Function` em um modelo do CloudFormation, use a propriedade `TracingConfig`.
**Example [function-inline.yml](https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/templates/function-inline.yml): configuração de rastreamento**
```
Resources:
function:
Type: [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
Properties:
TracingConfig:
Mode: Active
...
```
Para um recurso do AWS Serverless Application Model (AWS SAM) `AWS::Serverless::Function`, use a propriedade `Tracing`.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml): configuração de rastreamento**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
Tracing: Active
...
```
## Interpretar um rastreamento do X-Ray
Sua função precisa de permissão para carregar dados de rastreamento no X-Ray. Quando você ativa o rastreamento ativo no console do Lambda, o Lambda adiciona as permissões necessárias à [função de execução](lambda-intro-execution-role.md) da função. Caso contrário, adicione a política [AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess) à função de execução.
Após configurar o rastreamento ativo, você pode observar solicitações específicas por meio da aplicação. O [grafo de serviço do X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html#xray-concepts-servicegraph) exibe informações sobre sua aplicação e todos os componentes. O exemplo a seguir mostra uma aplicação com duas funções. A função principal processa eventos e, às vezes, retorna erros. A segunda função de cima para baixo processa erros que aparecem no primeiro grupo de logs e usa o AWS SDK para chamar o X-Ray, o Amazon Simple Storage Service (Amazon S3) e o Amazon CloudWatch Logs.
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/sample-errorprocessor-servicemap.png)
O X-Ray não rastreia todas as solicitações para sua aplicação. O X-Ray aplica um algoritmo de amostragem para garantir que o rastreamento seja eficiente, enquanto ainda fornece uma amostra representativa das solicitações. A taxa de amostragem é uma solicitação por segundo e 5% de solicitações adicionais. Você não pode configurar a taxa de amostragem do X-Ray para suas funções.
No X-Ray, um *rastreamento* registra informações sobre uma solicitação que é processada por um ou mais *serviços*. O Lambda registra dois segmentos por rastreamento, o que cria dois nós no gráfico de serviços. A imagem a seguir destaca esses dois nós:
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/xray-servicemap-function.png)
O primeiro nó à esquerda representa o serviço do Lambda, que recebe a solicitação de invocação. O segundo nó representa a sua função do Lambda específica. O exemplo a seguir mostra um rastreamento com esses dois segmentos. Ambos têm o nome **my-function**, mas um tem a origem `AWS::Lambda` e o outro, a origem `AWS::Lambda::Function`. Se o segmento `AWS::Lambda` mostrar um erro, o serviço Lambda teve um problema. Se o segmento `AWS::Lambda::Function` mostrar um erro, sua função teve um problema.
![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)
Este exemplo expande o segmento `AWS::Lambda::Function` para mostrar seus três subsegmentos.
**nota**
A AWS atualmente está implementando alterações no serviço Lambda. Devido a essas alterações, você pode ver pequenas diferenças entre a estrutura e o conteúdo das mensagens de log do sistema e os segmentos de rastreamento emitidos por diferentes funções do Lambda na sua Conta da AWS.
O exemplo de rastreamento mostrado aqui ilustra o segmento de função no estilo antigo. As diferenças entre os segmentos no estilo antigo e no estilo novo são descritas nos próximos parágrafos.
Essas alterações serão implementadas durante as próximas semanas, e todas as funções em todas as Regiões da AWS, exceto nas regiões China e GovCloud, passarão a usar o novo formato de mensagens de log e segmentos de rastreamento.
O segmento de função no estilo antigo contém os seguintes subsegmentos:
+ **Inicialização**: representa o tempo gasto carregando a função e executando o [código de inicialização](foundation-progmodel.md). Esse subsegmento aparece somente para o primeiro evento que cada instância da função processa.
+ **Invocação**: representa o tempo gasto na execução do código do manipulador.
+ **Sobrecarga**: representa o tempo gasto pelo runtime do Lambda preparando-se para lidar com o próximo evento.
O segmento de função no estilo novo não contém um subsegmento `Invocation`. Em vez disso, os subsegmentos dos clientes são anexados diretamente ao segmento da função. Para obter mais informações sobre a estrutura dos segmentos de função no estilo antigo e no estilo novo, consulte [Noções básicas sobre rastreamentos do X-Ray](services-xray.md#services-xray-traces).
Você também pode instrumentar clientes HTTP, registrar consultas SQL e criar subsegmentos personalizados com anotações e metadados. Para obter mais informações, consulte [AWS X-Ray SDK for Python](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html) no *Guia do desenvolvedor do AWS X-Ray*.
**Preços**
Você pode usar o rastreamento do X-Ray gratuitamente todos os meses até determinado limite como parte do nível gratuito da AWS. Além do limite, o X-Ray cobra por armazenamento e recuperação de rastreamento. Para obter mais informações, consulte [Preços do AWS X-Ray](https://aws.amazon.com/xray/pricing/).
## Armazenar dependências de runtime em uma camada (SDK do X-Ray)
Se você usar o X-Ray SDK para instrumentar os clientes do AWS SDK com seu código de função, seu pacote de implantação poderá se tornar bastante grande. Para evitar o upload de dependências de runtime todas as vezes que você atualizar seu código de função, empacote o SDK do X-Ray em uma [camada do Lambda](chapter-layers.md).
O exemplo a seguir mostra um recurso `AWS::Serverless::LayerVersion` que armazena o AWS X-Ray SDK for Python.
**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-python/template.yml): camada de dependências**
```
Resources:
function:
Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
Properties:
CodeUri: function/.
Tracing: Active
Layers:
- !Ref libs
...
libs:
Type: [AWS::Serverless::LayerVersion](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-layerversion.html)
Properties:
LayerName: blank-python-lib
Description: Dependencies for the blank-python sample app.
ContentUri: package/.
CompatibleRuntimes:
- python3.11
```
Com essa configuração, você atualizará a camada de biblioteca somente se alterar as dependências de runtime. Já que o pacote de implantação de função inclui apenas o seu código, isso pode ajudar a reduzir o tempo de upload.
A criação de uma camada de dependências requer alterações de compilação para gerar o arquivo da camada antes da implantação. Para obter um exemplo funcional, consulte o aplicativo de exemplo [blank-python](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-python).