Imagens base da AWS para Python Usar uma imagem base da AWS Usar uma imagem base que não é da AWS

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

As imagens base da AWS 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

As imagens base somente para sistema operacional da AWS contêm uma distribuição do Amazon Linux e o emulador de interface de runtime. Essas imagens são comumente usadas para criar imagens de contêiner para linguagens compiladas, como Go e Rust e para uma linguagem ou versão de linguagem para a qual o Lambda não fornece uma imagem base, como Node.js 19. Você também pode usar imagens base somente para sistema operacional para implementar um runtime personalizado. Para tornar a imagem compatível com o Lambda, você deve incluir o cliente de interface de runtime do Python na imagem.
Usar uma imagem base que não é da AWS

Você também pode usar uma imagem base alternativa de outro registro de contêiner, como Alpine Linux ou Debian. Você também pode 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 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 na documentação do Docker. Para criar imagens de contêiner eficientes, siga as Melhores práticas para gravar Dockerfiles.

Esta página explica como criar, testar e implantar imagens de contêiner para o Lambda.

Tópicos

Imagens base da AWS para Python
Usar uma imagem base da AWS para Python
Usar uma imagem base alternativa com o cliente da interface de runtime

Imagens base da AWS para Python

A AWS fornece as seguintes imagens base para Python:

Tags	Runtime	Sistema operacional	Dockerfile	Desaprovação
3.12	Python 3.12	Amazon Linux 2023	Dockerfile para Python 3.12 no GitHub	Não programado
3.11	Python 3.11	Amazon Linux 2	Dockerfile para Python 3.11 no GitHub	Não programado
3.10	Python 3.10	Amazon Linux 2	Dockerfile para Python 3.10 no GitHub	Não programado
3.9	Python 3.9	Amazon Linux 2	Dockerfile para Python 3.9 no GitHub	Não programado

Repositório do Amazon ECR: 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. 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. 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 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. Você pode substituir o SDK usando o pip para instalar uma versão mais recente. Você pode 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.

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)

Usar uma imagem base da AWS para Python

Para executar as etapas desta seção, você deve ter o seguinte:

AWS CLI versão 2
Docker (versão mínima 20.10.10 para Python 3.12 e imagens base posteriores)
Python

Para criar uma imagem de contêiner com base em uma imagem base da AWS para Python

Crie um diretório para o projeto e depois mude para esse diretório.
```
mkdir example
cd example
```
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.
exemplo Função do Python
```
import sys
def handler(event, context):
    return 'Hello from AWS Lambda using Python' + sys.version + '!'
```
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 sua função usar oAWS SDK for Python (Boto3):
exemplo requirements.txt
```
boto3
```
Crie um novo Dockerfile com a seguinte configuração:
- Defina a propriedade FROM como o URI da imagem base.
- 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.
- 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. 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.
exemplo 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" ]
```
Crie a imagem do Docker com o comando docker build. O exemplo a seguir nomeia a imagem como docker-image e atribui a ela a tag test.
```
docker build --platform linux/amd64 -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.

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.
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"
```
Obtenha o ID do contêiner.
```
docker ps
```
Use o comando docker kill para parar o contêiner. Nesse comando, substitua 3766c4ab331c pelo ID do contêiner da etapa anterior.
```
docker kill 3766c4ab331c
```

Para enviar a imagem ao Amazon ECR e criar a função do Lambda

Execute o comando get-login-password 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
```

Crie um repositório no Amazon ECR usando o comando create-repository.


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"
        }
    }
}

Copie o repositoryUri da saída na etapa anterior.
Execute o comando docker 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 da sua imagem do Docker. Esse é o nome e a tag da imagem que você especificou no comando docker build.
- Substitua <ECRrepositoryUri> pelo repositoryUri que você copiou. Certifique-se de incluir :latest no final do URI.
```
docker tag docker-image:test <ECRrepositoryUri>:latest
```
Exemplo:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
Execute o comando docker 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
```
Crie um perfil de execução 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.
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 ter mais informações, consulte Permissões entre contas do Amazon ECR.

Invoque a função.


aws lambda invoke --function-name hello-world response.json

Você obterá uma resposta parecida com esta:


{
  "ExecutedVersion": "$LATEST", 
  "StatusCode": 200
}

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 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, 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 ou uma imagem base alternativa, deverá incluir o cliente de interface de runtime na imagem. O cliente de interface de runtime estende Usar a API de runtime do Lambda para runtimes personalizados, 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 usando o gerenciador de pacotes pip:


pip install awslambdaric

Você também pode baixar o cliente de interface de runtime Python 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.

Para executar as etapas desta seção, você deve ter o seguinte:

Para criar uma imagem de contêiner de uma imagem base que não é da AWS

Crie um diretório para o projeto e depois mude para esse diretório.
```
mkdir example
cd example
```
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.
exemplo Função do Python
```
import sys
def handler(event, context):
    return 'Hello from AWS Lambda using Python' + sys.version + '!'
```
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 sua função usar oAWS SDK for Python (Boto3):
exemplo requirements.txt
```
boto3
```
Crie um novo Dockerfile. O Dockerfile a seguir usa uma imagem base oficial do Python em vez de uma imagem base da AWS. O Dockerfile inclui o cliente de interface de runtime, o que torna a imagem compatível com o Lambda. O exemplo de Dockerfile a seguir usa uma compilação em várias etapas.
- 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. 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.
exemplo 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" ]
```
Crie a imagem do Docker com o comando docker build. O exemplo a seguir nomeia a imagem como docker-image e atribui a ela a tag test.
```
docker build --platform linux/amd64 -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.

Use o emulador de interface de runtime para testar a imagem localmente. Você pode compilar o emulador em sua imagem 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

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.

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.
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"
```
Obtenha o ID do contêiner.
```
docker ps
```
Use o comando docker kill para parar o contêiner. Nesse comando, substitua 3766c4ab331c pelo ID do contêiner da etapa anterior.
```
docker kill 3766c4ab331c
```

Para enviar a imagem ao Amazon ECR e criar a função do Lambda

Execute o comando get-login-password 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
```

Crie um repositório no Amazon ECR usando o comando create-repository.


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"
        }
    }
}

Copie o repositoryUri da saída na etapa anterior.
Execute o comando docker 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 da sua imagem do Docker. Esse é o nome e a tag da imagem que você especificou no comando docker build.
- Substitua <ECRrepositoryUri> pelo repositoryUri que você copiou. Certifique-se de incluir :latest no final do URI.
```
docker tag docker-image:test <ECRrepositoryUri>:latest
```
Exemplo:
```
docker tag docker-image:test 111122223333.dkr.ecr.us-east-1.amazonaws.com/hello-world:latest
```
Execute o comando docker 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
```
Crie um perfil de execução 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.
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 ter mais informações, consulte Permissões entre contas do Amazon ECR.

Invoque a função.


aws lambda invoke --function-name hello-world response.json

Você obterá uma resposta parecida com esta:


{
  "ExecutedVersion": "$LATEST", 
  "StatusCode": 200
}

Para ver a saída da função, verifique o arquivo response.json.


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 no AWS Blog.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Implantar arquivos .zip

Camadas

Implante funções do Lambda em Python com imagens de contêiner

dica

Tópicos

Imagens base da AWS para Python

nota

Caminho de pesquisa de dependência nas imagens base

Usar uma imagem base da AWS para Python

Para criar uma imagem de contêiner com base em uma imagem base da AWS para Python

exemplo Função do Python

exemplo requirements.txt

exemplo Dockerfile

nota

nota

Para enviar a imagem ao Amazon ECR e criar a função do Lambda

nota

nota

Usar uma imagem base alternativa com o cliente da interface de runtime

Para criar uma imagem de contêiner de uma imagem base que não é da AWS

exemplo Função do Python

exemplo requirements.txt

exemplo Dockerfile

nota

Para instalar o emulador de interface de runtime na sua máquina local

nota

Para enviar a imagem ao Amazon ECR e criar a função do Lambda

nota

nota