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