# Configurar funções do AWS Lambda Aprenda a configurar as principais funcionalidades e opções para a função do Lambda usando a API ou o console do Lambda. **[.Arquivos .zip](configuration-function-zip.md) ** Crie um pacote de implantação da função do Lambda quando quiser incluir dependências, camadas de runtime personalizadas ou qualquer arquivo além do código da função. O pacote de implantação é um arquivo .zip que contém o seu código da função e suas dependências. **[Imagens de contêiner](images-create.md) ** Use imagens de contêiner para empacotar seu código de função e dependências quando precisar de mais controle sobre o processo de criação ou se sua função exigir configurações personalizadas de runtime. É possível criar, testar e implantar funções do Lambda como imagens de contêiner usando ferramentas como a CLI do Docker. **[Memória](configuration-memory.md)** Saiba como e quando aumentar memória para uma função. **[Armazenamento efêmero](configuration-ephemeral-storage.md) ** Saiba como e quando aumentar a capacidade do armazenamento temporário da função. **[Timeout (Tempo limite](configuration-timeout.md) ** Saiba como e quando aumentar o valor do tempo limite da função. **[Configuração durável](durable-configuration.md) ** Permita que suas funções do Lambda sejam executadas por longos períodos (até um ano) enquanto mantém o estado entre as invocações. Configure tempos limite de execução, retenção de estado e comportamento de versionamento para fluxos de trabalho de longa duração e com estado. As funções duráveis permitem que você crie processos complexos de várias etapas que podem pausar, retomar e lidar automaticamente com interrupções. ** [ Variáveis de ambiente](configuration-envvars.md)** É possível tornar o código da função portátil e manter os segredos externos ao código ao armazená-los na configuração da função usando variáveis ​​de ambiente. **[Redes de saída](configuration-vpc.md) ** É possível usar a função do Lambda com recursos da AWS em uma Amazon VPC. Conectar a função a uma VPC permite acessar recursos em uma sub-rede privada, como bancos de dados relacionais e caches. ** [Redes de entrada](configuration-vpc-endpoints.md)** É possível usar um endpoint da VPC de interface para invocar as funções do Lambda sem passar pela Internet pública. **[Sistema de arquivos](configuration-filesystem.md)** É possível usar a função do Lambda para montar um Amazon EFS em um diretório local. Um sistema de arquivos permite que o código da função acesse e modifique recursos compartilhados com segurança e alta simultaneidade. **[Aliases](configuration-aliases.md)** É possível configurar seus clientes para invocar uma versão específica da função do Lambda ao usar um alias, em vez de atualizar o cliente. **[Versões](configuration-versions.md)** Ao publicar uma versão da função, é possível armazenar o código e a configuração como um recurso separado que não pode ser alterado. **[Tags](configuration-tags.md)** Use tags para habilitar o controle de acesso por atributo (ABAC) para organizar as funções do Lambda e para filtrar e gerar relatórios sobre as funções usando os serviços AWS Cost Explorer ou AWS Billing e Cost Management. **[Streaming de respostas](configuration-response-streaming.md)** É possível configurar seus URLs de função do Lambda para fazer o streaming de cargas de resposta de volta aos clientes. O streaming de respostas pode beneficiar aplicações sensíveis à latência ao melhorar a performance do tempo até o primeiro byte (TTFB). Isso ocorre porque é possível enviar respostas parciais de volta ao cliente assim que elas se tornarem disponíveis. Além disso, é possível usar o streaming de respostas para construir funções que retornem cargas maiores. **[Endpoint de metadados](configuration-metadata-endpoint.md)** Utilize o endpoint de metadados do Lambda para identificar em qual Zona de Disponibilidade sua função do Lambda está sendo executada, permitindo que você otimize a latência ao direcionar a chamada para recursos na mesma Zona de Disponibilidade e implemente padrões de resiliência que levem em conta as Zonas de Disponibilidade. # Implantar funções do Lambda como arquivos .zip Quando você cria uma função do Lambda, você empacota o código da função em umpacote de implantação. O Lambda é compatível com dois tipos de pacotes de implantação: imagens de contêiner e arquivos .zip. O fluxo de trabalho para criar uma função depende do tipo de pacote de implantação. Para criar uma função definida como uma imagem de contêiner, consulte [Criar uma função do Lambda usando uma imagem de contêiner](images-create.md). É possível usar o console do Lambda e a API do Lambda para criar uma função definida com um arquivo de arquivo.zip. Também é possível carregar um arquivo.zip atualizado para alterar o código da função. **nota** Não é possível 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. **Topics** + [ ## Como criar a função ](#configuration-function-create) + [ ## Usando o editor de código do console ](#configuration-functions-console-update) + [ ## Atualizar código de função ](#configuration-function-update) + [ ## Como alterar o runtime ](#configuration-function-runtime) + [ ## Alterar a arquitetura ](#configuration-function-arch) + [ ## Usar a API do Lambda ](#configuration-function-api) + [ ## Baixar o código da sua função ](#configuration-function-download) + [ ## CloudFormation ](#configuration-function-cloudformation) + [ # Criptografia dos pacotes de implantação .zip do Lambda ](encrypt-zip-package.md) ## Como criar a função Ao criar uma função definida com um arquivo de arquivo .zip, você escolhe um modelo de código, a versão de idioma e a função de execução da função. Você adiciona o código da função depois do Lambda cria a função. **Para criar a função** 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. 1. Escolha a opção **Criar função**. 1. Selecione **Começar do zero** ou **Usar um esquema** para criar a função. 1. Em **Basic information** (Informações básicas), faça o seguinte: 1. Em **Function name (Nome da função)**, insira o nome da função. Os nomes das funções têm um limite de 64 caracteres de comprimento. 1. Para o **Runtime**, escolha a versão do idioma a ser usada para sua função. 1. (Opcional) Em **Architecture** (Arquitetura), escolha a arquitetura do conjunto de instruções a ser usado para sua função. O valor da arquitetura padrão é X86\$164. Ao criar o pacote de implantação para sua função, verifique se ela é compatível com esta [arquitetura de conjunto de instruções](foundation-arch.md). 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. (Opcional) Expanda **Advanced settings (Configurações avançadas)**. É possível escolher uma **configuração de assinatura de código** para a função. Também é possível configurar um (Amazon VPC) para que a função acesse. 1. Escolha a opção **Criar função**. O Lambda cria a nova função. Agora é possível usar o console do para adicionar o código da função e configurar outros parâmetros e recursos da função. Para obter instruções sobre implantação de código, consulte a página do manipulador de runtime que a função usa. ------ #### [ Node.js ] [Implantar funções do Lambda em Node.js com arquivos .zip](nodejs-package.md) ------ #### [ Python ] [Trabalhar com arquivos .zip para funções do Lambda em Python](python-package.md) ------ #### [ Ruby ] [Implantar funções do Lambda em Ruby com arquivos .zip](ruby-package.md) ------ #### [ Java ] [Implantar funções do Lambda em Java com arquivos .zip ou JAR](java-package.md) ------ #### [ Go ] [Implantar funções do Lambda em Go com arquivos .zip](golang-package.md) ------ #### [ C\$1 ] [Criar e implantar funções do Lambda em C\$1 com arquivos .zip](csharp-package.md) ------ #### [ PowerShell ] [Implantar funções do Lambda para PowerShell com arquivos .zip](powershell-package.md) ------ ## Usando o editor de código do console O console cria uma função do Lambda com um único arquivo de origem. Para linguagens de desenvolvimento de scripts, você pode editar esse arquivo e adicionar mais arquivos usando o editor de códigos integrado. Para salvar suas alterações, selecione **Salvar**. Em seguida, para executar seu código, escolha **Teste**. Quando você salva seu código de função, o console do Lambda cria um pacote de implantação de arquivos .zip. Quando desenvolver o código de função fora do console (usando um IDE), você precisará [criar um pacote de implantação](nodejs-package.md) para carregar o código na função do Lambda. ## Atualizar código de função Para linguagens de desenvolvimento de scripts (Node.js, Python, e Ruby), você pode editar o código de sua função no editor de código incorporado. Se o tamanho do código for superior a 3 MB, se você precisar adicionar bibliotecas ou para linguagens incompatíveis com o editor (Java, Go, C\$1), é necessário fazer upload do código da função como um arquivo.zip. Se o arquivo .zip for menor que 50 MB, você poderá fazer upload do arquivo .zip da sua máquina local. Se o arquivo for maior que 50 MB, faça upload do arquivo para a função desde um bucket do Amazon S3. **Para carregar código de função como um arquivo.zip** 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. 1. Escolha a função a ser atualizada e escolha a guia **Código**. 1. Em **Fonte de código)**, escolha **Fazer upload de**. 1. Escolha **.zip file** (Arquivo .zip) e, em seguida, escolha **Upload** (Fazer upload). 1. No seletor de arquivos, selecione a nova versão da imagem e escolha **Open** (Abrir) e, em seguida, **Save** (Salvar). 1. (Alternativa à etapa 4) Escolha **Localização do Amazon S3**. 1. Na caixa de texto, insira o URL do link do S3 do arquivamento de arquivo .zip e, depois, escolha **Salvar**. ## Como alterar o runtime Se você atualizar a configuração da função para usar um novo runtime, talvez seja necessário atualizar o código da função para ser compatível com o novo runtime. Ao atualizar a configuração da função para usar um runtime diferente, você **deverá** fornecer um novo código de função compatível com o runtime e a arquitetura. Para obter instruções de como criar um pacote de implantação para o código da função, consulte a página do manipulador para o runtime usado pela função. As imagens de base do Node.js 20, Python 3.12, Java 21, .NET 8, Ruby 3.3 e posteriores são baseadas na imagem de contêiner mínimo do Amazon Linux 2023. Imagens base anteriores usam o Amazon Linux 2. O AL2023 oferece 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`. Para obter mais informações, consulte [Introducing the Amazon Linux 2023 runtime for AWS Lambda](https://aws.amazon.com/blogs/compute/introducing-the-amazon-linux-2023-runtime-for-aws-lambda/) no Blog AWS Compute. **Para alterar o runtime** 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. 1. Escolha a função a ser atualizada e escolha a guia **Código**. 1. Role para baixo até a seção **Configurações de runtime** abaixo do editor de código. 1. Escolha **Editar**. 1. Em **Runtime**, selecione o identificador de runtime. 1. Em **Handler** (Manipulador), especifique o manipulador de sua função. 1. Em **Architecture** (Arquitetura), escolha a arquitetura do conjunto de instruções a ser usado para sua função. 1. Escolha **Salvar**. ## Alterar a arquitetura Antes de alterar a arquitetura do conjunto de instruções, é necessário garantir que o código da função seja compatível com a arquitetura de destino. Se você usa Node.js, Python ou Ruby e edita o código da sua função no editor integrado, o código existente poderá ser executado sem modificação. No entanto, se você fornecer seu código de função usando um pacote de implantação de arquivo.zip, deverá preparar um novo arquivo .zip compilado e criado corretamente para o runtime de destino e a arquitetura do conjunto de instruções. Para obter instruções, consulte a página do manipulador do runtime da sua função. **Para alterar a arquitetura do conjunto de instruções** 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. 1. Escolha a função a ser atualizada e escolha a guia **Código**. 1. Em **Configurações de runtime**, escolha **Editar**. 1. Em **Architecture** (Arquitetura), escolha a arquitetura do conjunto de instruções a ser usado para sua função. 1. Escolha **Salvar**. ## Usar a API do Lambda Para criar e configurar uma função que usa 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) + [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html) ## Baixar o código da sua função É possível baixar a versão atual não publicada (`$LATEST`) do código da sua função em .zip por meio do console do Lambda. Para fazer isso, primeiro verifique se você tem as seguintes permissões do IAM: + `iam:GetPolicy` + `iam:GetPolicyVersion` + `iam:GetRole` + `iam:GetRolePolicy` + `iam:ListAttachedRolePolicies` + `iam:ListRolePolicies` + `iam:ListRoles` **Para baixar o código da função em .zip** 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. 1. Escolha a função para a qual você deseja baixar o código da função em .zip. 1. Na **Visão geral da função**, escolha o botão **Download** e escolha **Baixar código da função em .zip**. 1. Como alternativa, selecione **Baixar arquivo AWS SAM** para gerar e baixar um modelo SAM com base na configuração da sua função. Também é possível escolher **Baixar ambos** para baixar tanto o arquivo .zip quanto o modelo SAM. ## CloudFormation É possível usar CloudFormation Como criar uma função do Lambda que usa um arquivo .zip. No seu modelo do CloudFormation, o recurso `AWS::Lambda::Function` especifica a função do Lambda. Para obter descrições das propriedades no recurso `AWS::Lambda::Function`, consulte [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html) no *Manual do usuário do AWS CloudFormation*. No recurso `AWS::Lambda::Function`, defina as seguintes propriedades para criar uma função definida como um arquivo .zip: + AWS::Lambda::Function + PackageType: definido como `Zip`. + Código — Insira o nome do bucket do Amazon S3 e o nome do arquivo.zip na caixa`S3Bucket`e`S3Key`campos. Para Node.js ou Python, você pode fornecer código-fonte inline da sua função do Lambda. + Runtime: defina o valor do runtime. + Arquitetura: defina o valor da arquitetura como `arm64` para usar o processador AWS Graviton2. Por padrão, o valor da arquitetura é `x86_64`. # Criptografia dos pacotes de implantação .zip do Lambda O Lambda sempre fornece criptografia do lado do servidor em repouso para pacotes de implantação .zip e detalhes da configuração da função com uma AWS KMS key. Por padrão, o Lambda usa um [Chave pertencente à AWS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk). Se esse comportamento padrão for adequado ao fluxo de trabalho, você não precisará configurar mais nada. A AWS não cobra pelo uso dessa chave. Se você preferir, pode fornecer uma AWS KMS chave gerenciada pelo cliente. É possível fazer isso para ter controle sobre a alternância da chave KMS ou para atender aos requisitos de sua organização para gerenciar chaves KMS. Quando você usa uma chave gerenciada pelo cliente, somente os usuários em sua conta com acesso à chave do KMS podem visualizar ou gerenciar o código ou a configuração da função. As chaves gerenciadas pelo cliente incorrem em cobranças do AWS KMS padrão. Para obter mais informações, consulte [Preços do AWS Key Management Service](https://aws.amazon.com/kms/pricing/). ## Criar uma chave gerenciada pelo cliente É possível criar uma chave simétrica gerenciada pelo cliente usando o Console de gerenciamento da AWS ou as APIs do AWS KMS. **Para criar uma chave simétrica gerenciada pelo cliente** Siga as etapas para [Criar chaves simétricas do KMS](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) no *Guia do desenvolvedor do AWS Key Management Service*. ### Permissões **Política de chave** As [políticas de chaves](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) controlam o acesso à chave gerenciada pelo cliente. Cada chave gerenciada pelo cliente deve ter exatamente uma política de chave, que contém declarações que determinam quem pode usar a chave e como pode usá-la. Para obter mais informações, consulte [Como alterar uma política de chaves](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-modifying.html#key-policy-modifying-how-to) no *Guia do desenvolvedor do AWS Key Management Service*. Quando você usa uma chave gerenciada pelo cliente para criptografar um pacote de implantação .zip, o Lambda não adiciona uma [concessão](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) à chave. Em vez disso, sua política de chave do AWS KMS deve permitir que o Lambda chame as seguintes operações de API do AWS KMS em seu nome: + [kms:GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) + [kms:Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) O exemplo de política de chave a seguir permite que todas as funções do Lambda na conta 111122223333 chamem as operações do AWS KMS necessárias para a chave gerenciada pelo cliente especificada: **Example Política de chave do AWS KMS** **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "lambda.amazonaws.com" }, "Action": [ "kms:GenerateDataKey", "kms:Decrypt" ], "Resource": "arn:aws:kms:us-east-1:111122223333:key/key-id", "Condition": { "StringLike": { "kms:EncryptionContext:aws:lambda:FunctionArn": "arn:aws:lambda:us-east-1:111122223333:function:*" } } } ] } ``` Para obter mais informações sobre [solução de problemas de acesso à chave](https://docs.aws.amazon.com/kms/latest/developerguide/policy-evaluation.html#example-no-iam), consulte o *Guia do Desenvolvedor do AWS Key Management Service*. **Permissões de entidade principal** Quando você usa uma chave gerenciada pelo cliente para criptografar um pacote de implantação .zip, somente as [entidades principais](https://docs.aws.amazon.com/IAM/latest/UserGuide/intro-structure.html) com acesso a essa chave podem acessar o pacote de implantação .zip. Por exemplo, as entidades principais que não têm acesso à chave gerenciada pelo cliente não podem baixar o pacote .zip usando o URL pré-assinado do S3 que está incluído na resposta [GetFunction](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html). Uma `AccessDeniedException` é retornada na seção `Code` da resposta. **Example AWS KMS AccessDeniedException** ``` { "Code": { "RepositoryType": "S3", "Error": { "ErrorCode": "AccessDeniedException", "Message": "KMS access is denied. Check your KMS permissions. KMS Exception: AccessDeniedException KMS Message: User: arn:aws:sts::111122223333:assumed-role/LambdaTestRole/session is not authorized to perform: kms:Decrypt on resource: arn:aws:kms:us-east-1:111122223333:key/key-id with an explicit deny in a resource-based policy" }, "SourceKMSKeyArn": "arn:aws:kms:us-east-1:111122223333:key/key-id" }, ... ``` Para obter mais informações sobre permissões para chaves do AWS KMS, consulte [Autenticação e controle de acesso do AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/control-access.html). ## Uso de uma chave gerenciada pelo cliente para seu pacote de implantação .zip Use os seguintes parâmetros de API para configurar as chaves gerenciadas pelo cliente para pacotes de implantação .zip: + [SourceKMSKeyArn](https://docs.aws.amazon.com/lambda/latest/api/API_FunctionCode.html#lambda-Type-FunctionCode-SourceKMSKeyArn): criptografa o pacote de implantação de origem .zip (o arquivo que você carrega). + [KMSKeyArn](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#lambda-CreateFunction-request-KMSKeyArn): criptografa [variáveis de ambiente](configuration-envvars-encryption.md) e snapshots do [Lambda SnapStart](snapstart.md). Quando `SourceKMSKeyArn` e `KMSKeyArn` são especificados, o Lambda usa a chave `KMSKeyArn` para criptografar a versão descompactada do pacote que o Lambda usa para invocar a função. Quando `SourceKMSKeyArn` é especificado, mas `KMSKeyArn` não é, o Lambda usa uma [Chave gerenciada pela AWS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk) para criptografar a versão descompactada do pacote. ------ #### [ Lambda console ] **Para adicionar criptografia de chave gerenciada pelo cliente ao criar 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 opção **Criar função**. 1. Escolha **Author from scratch** (Criar do zero) ou **Container image** (Imagem de contêiner). 1. Em **Basic information** (Informações básicas), faça o seguinte: 1. Em **Function name (Nome da função)**, insira o nome da função. 1. Em **Runtime**, escolha a versão da linguagem a ser usada para sua função. 1. Expanda **Configurações avançadas** e selecione **Habilitar a criptografia com uma chave do AWS KMS gerenciada pelo cliente**. 1. Escolha uma chave gerenciada pelo cliente. 1. Escolha a opção **Criar função**. Para remover a criptografia de chave gerenciada pelo cliente ou usar uma chave diferente, carregue o pacote de implantação .zip novamente. **Para adicionar criptografia de chave gerenciada pelo cliente a uma função existente** 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. 1. Escolha o nome de uma função. 1. No painel do **Código-fonte**, escolha **Carregar de**. 1. Escolha o **arquivo .zip** ou o **local do Amazon S3**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/upload-zip.png) 1. Faça upload do arquivo ou insira o local do Amazon S3. 1. Escolha **Habilitar a criptografia com uma chave do AWS KMS gerenciada pelo cliente**. 1. Escolha uma chave gerenciada pelo cliente. 1. Escolha **Salvar**. ------ #### [ AWS CLI ] **Para adicionar criptografia de chave gerenciada pelo cliente ao criar uma função** No seguinte exemplo de [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html): + `--code`: especifica o caminho local para o pacote de implantação .zip (`ZipFile`) e a chave gerenciada pelo cliente para criptografá-lo (`SourceKMSKeyArn`). + `--kms-key-arn`: especifica a chave gerenciada pelo cliente para criptografar as variáveis de ambiente e a versão descompactada do pacote de implantação. ``` aws lambda create-function \ --function-name myFunction \ --runtime nodejs24.x \ --handler index.handler \ --role arn:aws:iam::111122223333:role/service-role/my-lambda-role \ --code ZipFile=fileb://myFunction.zip,SourceKMSKeyArn=arn:aws:kms:us-east-1:111122223333:key/key-id \ --kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key2-id ``` No seguinte exemplo de [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html): + `--code`: especifica a localização do arquivo.zip em um bucket do Amazon S3 (`S3Bucket`, `S3Key`, `S3ObjectVersion`) e a chave gerenciada pelo cliente para criptografá-lo (`SourceKMSKeyArn`). + `--kms-key-arn`: especifica a chave gerenciada pelo cliente para criptografar as variáveis de ambiente e a versão descompactada do pacote de implantação. ``` aws lambda create-function \ --function-name myFunction \ --runtime nodejs24.x --handler index.handler \ --role arn:aws:iam::111122223333:role/service-role/my-lambda-role \ --code S3Bucket=amzn-s3-demo-bucket,S3Key=myFileName.zip,S3ObjectVersion=myObjectVersion,SourceKMSKeyArn=arn:aws:kms:us-east-1:111122223333:key/key-id \ --kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key2-id ``` **Para adicionar criptografia de chave gerenciada pelo cliente a uma função existente** No seguinte exemplo de [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html): + `--zip-file`: especifica o caminho local para o pacote de implantação .zip. + `--source-kms-key-arn`: especifica a chave gerenciada pelo cliente para criptografar a versão compactada do pacote de implantação. O Lambda usa uma chave que pertence à AWS para criptografar o pacote descompactado para invocações de funções. Se você quiser usar uma chave gerenciada pelo cliente para criptografar a versão descompactada do pacote, execute o comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) com a opção `--kms-key-arn`. ``` aws lambda update-function-code \ --function-name myFunction \ --zip-file fileb://myFunction.zip \ --source-kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key-id ``` No seguinte exemplo de [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html): + `--s3-bucket`: especifica o local do arquivo .zip em um bucket do Amazon S3. + `--s3-key`: especifica a chave do Amazon S3 do pacote de implantação. + `--s3-object-version`: para objetos com controle de versão, a versão do objeto do pacote de implantação a ser usada. + `--source-kms-key-arn`: especifica a chave gerenciada pelo cliente para criptografar a versão compactada do pacote de implantação. O Lambda usa uma chave que pertence à AWS para criptografar o pacote descompactado para invocações de funções. Se você quiser usar uma chave gerenciada pelo cliente para criptografar a versão descompactada do pacote, execute o comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) com a opção `--kms-key-arn`. ``` aws lambda update-function-code \ --function-name myFunction \ --s3-bucket amzn-s3-demo-bucket \ --s3-key myFileName.zip \ --s3-object-version myObject Version --source-kms-key-arn arn:aws:kms:us-east-1:111122223333:key/key-id ``` **Para remover a criptografia de chave gerenciada pelo cliente de uma função existente** No exemplo de [update-function-code](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html) a seguir, `--zip-file` especifica o caminho local para o pacote de implantação .zip. Quando você executa esse comando sem a opção `--source-kms-key-arn`, o Lambda usa uma chave que pertence à AWS para criptografar a versão compactada do pacote de implantação. ``` aws lambda update-function-code \ --function-name myFunction \ --zip-file fileb://myFunction.zip ``` ------ # Criar uma função do Lambda usando uma imagem de contêiner O código da função do AWS Lambda consiste em scripts ou programas compilados e as dependências deles. Você usa um*pacote de implantação*para implantar seu código de função no Lambda. O Lambda é compatível com dois tipos de pacotes de implantação: imagens de contêiner e arquivos .zip. Existem três maneiras de criar uma imagem de contêiner para uma função do Lambda: + [Usar uma imagem base da AWS para Lambda](#runtimes-images-lp) As [imagens base da AWS](#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](#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 um [cliente de interface de runtime](#images-ric) para sua linguagem na imagem. + [Usar uma imagem base que não é da AWS](#images-types) 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 um [cliente de interface de runtime](#images-ric) para sua linguagem 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/). Para criar uma função do Lambda de uma imagem de contêiner, crie sua imagem localmente e carregue-a em um repositório do Amazon Elastic Container Registry (Amazon ECR). Se estiver usando uma imagem de contêiner fornecida por um vendedor do [AWS Marketplace](https://docs.aws.amazon.com/marketplace/latest/userguide/container-based-products.html), primeiro você precisará clonar a imagem para o repositório privado do Amazon ECR. Em seguida, especifique o URI do repositório quando criar a função. O repositório do Amazon ECR deve estar na mesma Região da AWS que a função do Lambda. É 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](#configuration-images-xaccount-permissions). **nota** O Lambda não é compatível com endpoints FIPS do Amazon ECR para imagens de contêineres. Se o URI do seu repositório incluir `ecr-fips`, você está usando um endpoint FIPS. Exemplo: `111122223333.dkr.ecr-fips.us-east-1.amazonaws.com`. Esta página explica os tipos de imagem base e os requisitos para criar imagens de contêiner compatíveis com o Lambda. **nota** Não é possível 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. **Topics** + [ ## Requisitos ](#images-reqs) + [ ## Usar uma imagem base da AWS para Lambda ](#runtimes-images-lp) + [ ## Usar uma imagem base somente para sistema operacional da AWS ](#runtimes-images-provided) + [ ## Usar uma imagem base que não é da AWS ](#images-types) + [ ## Clientes de interface de runtime ](#images-ric) + [ ## Permissões do Amazon ECR ](#gettingstarted-images-permissions) + [ ## Ciclo de vida da função ](#images-lifecycle) ## Requisitos Instale a [versão 2 da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) e a [CLI do Docker](https://docs.docker.com/get-docker). Além disso, observe os seguintes requisitos: + A imagem de contêiner deve implementar o [Usar a API de runtime do Lambda para runtimes personalizados](runtimes-api.md). Os [clientes de interface de runtime](#images-ric) de código aberto da AWS implementam a API. É possível adicionar um cliente de interface de runtime à sua imagem base preferida para torná-lo compatível com o Lambda. + Deve ser possível executar a imagem do contêiner em um sistema de arquivos somente leitura. Seu código de função pode acessar um diretório `/tmp` gravável com entre 512 MB e 10.240 MB, em incrementos de 1 MB, de armazenamento. + O usuário padrão do Lambda deve ser capaz de ler todos os arquivos necessários para executar seu código de função. O Lambda segue as práticas recomendadas de segurança definindo um usuário padrão do Linux com permissões menos privilegiadas. Isso significa que você não precisa especificar um [USUÁRIO](https://docs.docker.com/reference/dockerfile/#user) em seu Dockerfile. Verifique se o código da aplicação não depende de arquivos que outros usuários do Linux estejam restringidos de executar. + O Lambda é compatível apenas com imagens de contêiner baseadas em Linux. + O Lambda fornece imagens base multiarquitetura. No entanto, a imagem que você criar para sua função deverá ser direcionada para apenas uma das arquiteturas. O Lambda não oferece suporte a funções que usam imagens de contêiner multiarquitetura. ## Usar uma imagem base da AWS para Lambda É possível usar uma das [imagens base da AWS](https://gallery.ecr.aws/lambda/) para o Lambda criar a imagem de contêiner do código da função. As imagens de base são pré-carregadas com um runtime de linguagem e outros componentes necessários para executar uma imagem de contêiner no Lambda. Você adiciona seu código de função e as dependências à imagem base e, em seguida, empacota-os como uma imagem de contêiner. A AWS fornece atualizações periodicamente para as imagens base da AWS para o Lambda. Se o Dockerfile incluir o nome da imagem na propriedade FROM, seu cliente Docker extrairá a versão mais recente da imagem do [repositório do Amazon ECR](https://gallery.ecr.aws/lambda/). Para usar a imagem base atualizada, você deve reconstruir a imagem do contêiner e [atualizar o código da função](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-code.html). As imagens de base do Node.js 20, Python 3.12, Java 21, .NET 8, Ruby 3.3 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). Imagens base anteriores usam o Amazon Linux 2. O AL2023 oferece 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. Para criar uma imagem de contêiner usando uma imagem base da AWS, escolha as instruções para sua linguagem preferencial: + [Node.js](nodejs-image.md#nodejs-image-instructions) + [TypeScript](typescript-image.md#base-image-typescript) (usa uma imagem base Node.js) + [Python](python-image.md#python-image-instructions) + [Java](java-image.md#java-image-instructions) + [Go](go-image.md#go-image-provided) + [.NET](csharp-image.md#csharp-image-instructions) + [Ruby](ruby-image.md#ruby-image-instructions) ## Usar uma imagem base somente para sistema operacional da AWS [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 um [cliente de interface de runtime](#images-ric) para sua linguagem na imagem. | Tags | Runtime | Sistema operacional | Dockerfile | Desaprovação | | --- | --- | --- | --- | --- | | al2023 | Runtime somente para sistema operacional | Amazon Linux 2023 | [Dockerfile para runtime somente para sistema operacional no GitHub](https://github.com/aws/aws-lambda-base-images/blob/provided.al2023/Dockerfile.provided.al2023) | 30 de junho de 2029 | | al2 | Runtime somente para sistema operacional | Amazon Linux 2 | [Dockerfile para runtime somente para sistema operacional no GitHub](https://github.com/aws/aws-lambda-base-images/blob/provided.al2/Dockerfile.provided.al2) | 31 de julho de 2026 | Galeria pública do Amazon Elastic Container Registry: [gallery.ecr.aws/lambda/provided](https://gallery.ecr.aws/lambda/provided) ## Usar uma imagem base que não é da AWS O Lambda é compatível com qualquer imagem que esteja em conformidade com um dos seguintes formatos de manifesto de imagem: + Esquema 2 de manifesto V2 de imagem de Docker (usado com o Docker versão 1.10 e posteriores) + Especificações de Open Container Initiative (OCI – Iniciativa de contêiner aberto) (v1.0.0 e posteriores) O Lambda oferece suporte a um tamanho máximo de imagem descompactada de 10 GB, incluindo todas as camadas. **nota** Para tornar a imagem compatível com o Lambda, você deve incluir um [cliente de interface de runtime](#images-ric) para sua linguagem na imagem. Para performance ideal, mantenha o tamanho do manifesto da imagem abaixo de 25.400 bytes. Para reduzir o tamanho do manifesto da imagem, diminua o número de camadas na imagem e reduza as anotações. ## Clientes de interface de runtime Se você usar uma [imagem base somente para sistema operacional](#runtimes-images-provided) ou uma imagem base alternativa, deverá incluir um cliente de interface de runtime na imagem. O cliente de interface de runtime deve estender o [Usar a API de runtime do Lambda para runtimes personalizados](runtimes-api.md), que gerencia a interação entre o Lambda e o código da sua função. A AWS fornece clientes de interface de runtime de código aberto para as seguintes linguagens: + [Node.js](nodejs-image.md#nodejs-image-clients) + [Python](python-image.md#python-image-clients) + [Java](java-image.md#java-image-clients) + [.NET](csharp-image.md#csharp-image-clients) + [Go](go-image.md#go-image-clients) + [Ruby](ruby-image.md#ruby-image-clients) + [Rust](lambda-rust.md) – Caso esteja usando uma linguagem que não tenha um cliente de interface de runtime fornecido pela AWS, você deverá criar seu próprio cliente de interface de runtime. ## Permissões do Amazon ECR Antes de criar uma função do Lambda com base em uma imagem de contêiner, você deve criar a imagem localmente e carregá-la no repositório do Amazon ECR. Quando criar a função, especifique o URI do repositório do Amazon ECR. Certifique-se de que as permissões para o usuário ou o perfil que cria a função incluam `GetRepositoryPolicy`, `SetRepositoryPolicy`, `BatchGetImage` e `GetDownloadUrlForLayer`. Por exemplo, use o console do IAM para criar uma função com a seguinte política: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Allow", "Action": [ "ecr:SetRepositoryPolicy", "ecr:GetRepositoryPolicy", "ecr:BatchGetImage", "ecr:GetDownloadUrlForLayer" ], "Resource": "arn:aws:ecr:us-east-1:111122223333:repository/hello-world" } ] } ``` ------ ### Políticas do repositório do Amazon ECR Para uma função na mesma conta que a imagem de contêiner no Amazon ECR, você pode adicionar as permissões `ecr:BatchGetImage` e `ecr:GetDownloadUrlForLayer` à política do repositório do Amazon ECR. O exemplo a seguir mostra a política mínima: ``` { "Sid": "LambdaECRImageRetrievalPolicy", "Effect": "Allow", "Principal": { "Service": "lambda.amazonaws.com" }, "Action": [ "ecr:BatchGetImage", "ecr:GetDownloadUrlForLayer" ] } ``` Para obter mais informações sobre as permissões de repositório do Amazon ECR, consulte [Políticas de repositório privado](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-policies.html) no *Guia do usuário do Amazon Elastic Container Registry*. Se o repositório do Amazon ECR não incluir essas permissões, o Lambda tentará adicioná-las automaticamente. O Lambda só poderá adicionar permissões se a entidade principal que chama o Lambda tiver as permissões `ecr:getRepositoryPolicy` e `ecr:setRepositoryPolicy`. Para visualizar ou editar suas permissões de repositório do Amazon ECR, siga as instruções em [Configurar uma instrução de política de repositório](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html) no *Guia do usuário do Amazon Elastic Container Registry*. #### Permissões entre contas do Amazon ECR Uma conta diferente na mesma região pode criar uma função que usa uma imagem de contêiner de propriedade da sua conta. No exemplo a seguir, a [política de permissões de repositório do Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/set-repository-policy.html) precisa das instruções apresentadas a seguir para conceder acesso à conta número 123456789012. + **CrossAccountPermission:** permite que a conta 123456789012 crie e atualize funções do Lambda que usam imagens desse repositório ECR. + **LambdaecrimagecrossAccountRetrievalPolicy:** o Lambda eventualmente definirá o estado de uma função como inativo se ela não for invocada por um período prolongado. Essa declaração é necessária para que o Lambda possa recuperar a imagem do contêiner para otimização e armazenamento em cache em nome da função pertencente a 123456789012. **Example — Adicionar permissão entre contas ao repositório** **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "CrossAccountPermission", "Effect": "Allow", "Action": [ "ecr:BatchGetImage", "ecr:GetDownloadUrlForLayer" ], "Principal": { "AWS": "arn:aws:iam::123456789012:root" }, "Resource": "arn:aws:ecr:us-east-1:123456789012:repository/example-lambda-repository" }, { "Sid": "LambdaECRImageCrossAccountRetrievalPolicy", "Effect": "Allow", "Action": [ "ecr:BatchGetImage", "ecr:GetDownloadUrlForLayer" ], "Principal": { "Service": "lambda.amazonaws.com" }, "Condition": { "ArnLike": { "aws:sourceARN": "arn:aws:lambda:us-east-1:123456789012:function:*" } }, "Resource": "arn:aws:ecr:us-east-1:123456789012:repository/example-lambda-repository" } ] } ``` Para dar acesso a várias contas, você adiciona os IDs de conta à lista Principal na política `CrossAccountPermission` e à lista Avaliação da condição em `LambdaECRImageCrossAccountRetrievalPolicy`. Se você estiver trabalhando com várias contas em uma organização da AWS, recomendamos enumerar cada ID de conta na política de permissões do ECR. Essa abordagem se alinha com a prática recomendada de segurança da AWS de definir permissões estreitas nas políticas do IAM. Além das permissões do Lambda, o usuário ou o perfil que cria a função também deve ter as permissões `BatchGetImage` e `GetDownloadUrlForLayer`. ## Ciclo de vida da função Depois de carregar uma imagem de contêiner nova ou atualizada, o Lambda otimiza a imagem antes que a função possa processar chamadas. O processo de otimização pode levar alguns segundos. A função permanece no estado `Pending` até que o processo seja concluído, quando o estado passa para `Active`. Apenas será possível invocar a função quando ela atingir o estado `Active`. Se uma função não é invocada por várias semanas, o Lambda recupera a versão otimizada e a função muda para o estado `Inactive`. Para reativar a função, você deve chamá-la. O Lambda rejeita a primeira invocação e a função entra no`Pending`até que o Lambda reotimize a imagem. A função então retorna ao estado `Active`. O Lambda busca periodicamente a imagem de contêiner associada a partir do repositório do Amazon ECR. Se a imagem correspondente do contêiner não existir mais no Amazon ECR ou as permissões forem revogadas, a função irá inserir o estado `Failed` e o Lambda retornará uma falha para qualquer chamada de função. É possível usar a API do Lambda para obter informações sobre o estado de uma função. Para obter mais informações, consulte [Estados da função do Lambda](functions-states.md). # Configurar memória para uma função do Lambda O Lambda aloca capacidade da CPU na proporção da quantidade de memória configurada. *Memória* é a quantidade de memória disponível para a função do Lambda no runtime. Você pode aumentar ou diminuir a memória e a capacidade da CPU alocadas para a função usando a configuração **Memória**. Você pode configurar a memória com um valor de 128 MB a 10.240 MB, em incrementos de 1 MB. Com 1.769 MB, uma função tem o equivalente a um vCPU (um vCPU-segundo de créditos por segundo). Esta página descreve como e quando atualizar a configuração de memória para uma função do Lambda. **Topics** + [ ## Determinar a configuração de memória apropriada para uma função do Lambda ](#configuration-memory-use-cases) + [ ## Configurar a memória da função (console) ](#configuration-memory-console) + [ ## Configurar memória para uma função (AWS CLI) ](#configuration-memory-cli) + [ ## Configurar memória para uma função (AWS SAM) ](#configuration-memory-sam) + [ ## Aceitar recomendações de memória de função (console) ](#configuration-memory-optimization-accept) ## Determinar a configuração de memória apropriada para uma função do Lambda A memória é a principal alavanca de controle de performance de uma função. A configuração padrão, 128 MB, é a configuração mais baixa possível. Recomendamos que você só use 128 MB para funções simples do Lambda, por exemplo, as que transformam e roteiam eventos para outros serviços da AWS. Uma alocação maior de memória pode melhorar a performance das funções que usam bibliotecas importadas, [camadas do Lambda](chapter-layers.md), o Amazon Simple Storage Service (Amazon S3) ou o Amazon Elastic File System (Amazon EFS). Adicionar memória aumenta proporcionalmente a quantidade de CPU, aumentando a capacidade computacional geral disponível. Se uma função depender de CPU, rede ou memória, aumentar a configuração de memória pode melhorar muito sua performance. Para encontrar a configuração de memória correta, monitore funções com o Amazon CloudWatch e defina alarmes se o consumo de memória estiver se aproximando dos valores máximos configurados. Isso pode ajudar a identificar funções que dependem de memória. Para funções que dependem de CPU e E/S, o monitoramento da duração também pode fornecer insights. Nesses casos, aumentar a memória pode ajudar a resolver os gargalos de computação ou rede. Você também pode considerar o uso da ferramenta de código aberto [AWS Lambda Power Tuning](https://github.com/alexcasalboni/aws-lambda-power-tuning). Essa ferramenta usa o AWS Step Functions para executar várias versões de uma função do Lambda com diferentes alocações de memória simultaneamente e medir a performance. A função entrada é executada em sua conta da AWS, realizando chamadas de HTTP e interação com o SDK em tempo real para medir a provável performance em um cenário de produção real. Você também pode implementar um processo de CI/CD para usar essa ferramenta para medir automaticamente a performance das novas funções que implantar. ## Configurar a memória da função (console) Você pode configurar a memória da sua função no console do Lambda. **Para atualizar a memória de uma função** 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 **Configuração** e depois selecione **Configuração geral**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/configuration-tab.png) 1. Em **Configuração geral**, escolha **Editar**. 1. Em **Memória**, defina um valor de 128 MB a 10.240 MB. 1. Escolha **Salvar**. ## Configurar memória para uma função (AWS CLI) Você pode usar o comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) para configurar a memória para a sua função. **Example** ``` aws lambda update-function-configuration \ --function-name my-function \ --memory-size 1024 ``` ## Configurar memória para uma função (AWS SAM) Você pode usar o [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) para configurar a memória para a sua função. Atualize a propriedade [MemorySize](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-memorysize) no arquivo `template.yaml` e execute o comando [sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html). **Example template.yaml** ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Description: An AWS Serverless Application Model template describing your function. Resources: my-function: Type: AWS::Serverless::Function Properties: CodeUri: . Description: '' MemorySize: 1024 # Other function properties... ``` ## Aceitar recomendações de memória de função (console) Se você tiver permissões de administrador no AWS Identity and Access Management (IAM), será possível optar por receber recomendações de memória de funções do Lambda do AWS Compute Optimizer. Para obter instruções sobre como aceitar recomendações de memória para sua conta ou organização, consulte [Opting in your account](https://docs.aws.amazon.com/compute-optimizer/latest/ug/getting-started.html#account-opt-in) no *Manual do usuário do AWS Compute Optimizer*. **nota** O Compute Optimizer oferece suporte apenas a funções que usam a arquitetura x86\$164. Quando você tiver aceitado e sua [função do Lambda atender aos requisitos do Compute Optimizer](https://docs.aws.amazon.com/compute-optimizer/latest/ug/requirements.html#requirements-lambda-functions), será possível visualizar e aceitar recomendações de memória de funções do Compute Optimizer no console do Lambda em **Configuração geral**. # Configurar armazenamento efêmero para funções do Lambda O Lambda fornece armazenamento efêmero para funções no diretório `/tmp`. Esse armazenamento é temporário e exclusivo de cada ambiente de execução. Você pode controlar a quantidade de armazenamento efêmero alocado para a função usando a configuração **Armazenamento efêmero**. Você pode configurar o armazenamento efêmero com um valor de 512 MB a 10.240 MB, em incrementos de 1 MB. Todos os dados armazenados em `/tmp` são criptografados em repouso com uma chave gerenciada pela AWS. Esta página descreve os casos de uso comuns e como atualizar o armazenamento efêmero para uma função do Lambda. **Topics** + [ ## Casos de uso comuns para armazenamento efêmero maior ](#configuration-ephemeral-storage-use-cases) + [ ## Como configurar o armazenamento temporário (console) ](#configuration-ephemeral-storage-console) + [ ## Configurar armazenamento efêmero (AWS CLI) ](#configuration-ephemeral-storage-cli) + [ ## Configurar armazenamento efêmero (AWS SAM) ](#configuration-ephemeral-storage-sam) ## Casos de uso comuns para armazenamento efêmero maior Aqui estão vários casos de uso comuns que se beneficiam com um armazenamento efêmero maior: + **Trabalhos de extração, transformação e carga (ETL):** aumente o armazenamento efêmero quando o código executar computação intermediária ou baixar outros recursos para concluir o processamento. Mais espaço temporário permite a execução de trabalhos de ETL mais complexos em funções do Lambda. + **Inferência de machine learning (ML):** muitas tarefas de inferência dependem de grandes arquivos de dados de referência, incluindo bibliotecas e modelos. Com mais armazenamento efêmero, você pode baixar modelos maiores do Amazon Simple Storage Service (Amazon S3) para `/tmp` e usá-los no processamento. + **Processamento de dados:** para workloads que baixam objetos do Amazon S3 em resposta a eventos do S3, mais espaço em `/tmp` permite lidar com objetos maiores sem usar processamento em memória. Workloads que criam PDFs ou que processam mídia também se beneficiam com mais armazenamento efêmero. + **Processamento gráfico:** o processamento de imagens é um caso de uso comum para aplicações baseadas no Lambda. Para workloads que processam arquivos TIFF ou imagens de satélite grandes, ter mais armazenamento efêmero torna mais fácil usar bibliotecas e realizar computação no Lambda. ## Como configurar o armazenamento temporário (console) Você pode configurar armazenamento efêmero no console do Lambda. **Para modificar o armazenamento efêmero de uma função** 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 **Configuração** e depois selecione **Configuração geral**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/configuration-tab.png) 1. Em **Configuração geral**, escolha **Editar**. 1. Para **Armazenamento efêmero** defina um valor de 512 MB a 10.240 MB, em incrementos de 1 MB. 1. Escolha **Salvar**. ## Configurar armazenamento efêmero (AWS CLI) Você pode usar o comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) para configurar armazenamento efêmero. **Example** ``` aws lambda update-function-configuration \ --function-name my-function \ --ephemeral-storage '{"Size": 1024}' ``` ## Configurar armazenamento efêmero (AWS SAM) Você pode usar o [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) para configurar o armazenamento efêmero da função. Atualize a propriedade [EphemeralStorage](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-ephemeralstorage) no arquivo `template.yaml` e execute o comando [sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html). **Example template.yaml** ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Description: An AWS Serverless Application Model template describing your function. Resources: my-function: Type: AWS::Serverless::Function Properties: CodeUri: . Description: '' MemorySize: 128 Timeout: 120 Handler: index.handler Runtime: nodejs22.x Architectures: - x86_64 EphemeralStorage: Size: 10240 # Other function properties... ``` # Selecionar e configurar a arquitetura de um conjunto de instruções para a função do Lambda A *arquitetura do conjunto de instruções* de uma função do Lambda determina o tipo de processador de computador que o Lambda usa para executar a função. O Lambda fornece opções de arquiteturas de conjuntos de instruções: + arm64: arquitetura ARM de 64 bits para o processador AWS Graviton2. + x86\$164: arquitetura x86 de 64 bits para processadores baseados em x86. **nota** A arquitetura arm64 está disponível na maioria das Regiões da AWS. Para saber mais, consulte [Preços do AWS Lambda](https://aws.amazon.com//lambda/pricing/#aws-element-9ccd9262-b656-4d9c-8a72-34ee6b662135). Na tabela de preços de memória, escolha a guia **Arm Price** (Preço do ARM) e, em seguida, abra a lista suspensa **Region** (Regiões) para visualizar quais Regiões da AWS oferecem suporte ao arm64 com o Lambda. Para obter um exemplo de como criar uma função com arquitetura arm64, consulte [AWS Lambda Functions Powered by AWS Graviton2 Processor](https://aws.amazon.com/blogs/aws/aws-lambda-functions-powered-by-aws-graviton2-processor-run-your-functions-on-arm-and-get-up-to-34-better-price-performance/). **Topics** + [ ## Vantagens do uso da arquitetura arm64 ](#foundation-arch-adv) + [ ## Requisitos para a migração para a arquitetura arm64 ](#foundation-arch-consider) + [ ## Compatibilidade do código da função com a arquitetura arm64 ](#foundation-arch-considerations) + [ ## Como migrar para a arquitetura arm64 ](#foundation-arch-steps) + [ ## Configuração da arquitetura do conjunto de instruções ](#foundation-arch-config) ## Vantagens do uso da arquitetura arm64 As funções do Lambda que usam arquitetura arm64 (processador AWS Graviton2) podem alcançar preços e performance significativamente melhores do que a função equivalente executada na arquitetura x86\$164. Considere usar o arm64 para aplicações com uso intenso de computação, como computação de alta performance, codificação de vídeo e workloads de simulação. A CPU Graviton2 usa o núcleo Neoverse N1 e oferece suporte a Armv8.2 (incluindo extensões CRC e cripto), além de várias outras extensões de arquitetura. O Graviton2 reduz o tempo de leitura da memória fornecendo um cache L2 maior por vCPU, o que melhora a performance de latência de backends da Web e móveis, microsserviços e sistemas de processamento de dados. O Graviton2 também oferece melhor performance de criptografia e oferece suporte a conjuntos de instruções que melhoram a latência da inferência de machine learning com base em CPU. Para obter mais informações sobre o AWS Graviton2, consulte [Processador AWS Graviton](https://aws.amazon.com/ec2/graviton). ## Requisitos para a migração para a arquitetura arm64 Ao selecionar uma função do Lambda para migrar para a arquitetura arm64, a fim de garantir uma migração suave, certifique-se de que sua função atenda aos seguintes requisitos: + O pacote de implantação contém apenas componentes de código aberto e código-fonte controlados por você para que você possa fazer as atualizações necessárias para a migração. + Se o código da função incluir dependências de terceiros, cada biblioteca ou pacote fornecerá uma versão arm64. ## Compatibilidade do código da função com a arquitetura arm64 O código da sua função do Lambda deve ser compatível com a arquitetura do conjunto de instruções da função. Antes de migrar uma função para a arquitetura arm64, observe os seguintes pontos sobre o código da função atual: + Se você adicionou o código da função usando o editor de código integrado, seu código provavelmente será executado em qualquer arquitetura sem precisar de modificações. + Se você carregou o código da função, deverá carregar um novo código compatível com a arquitetura de destino. + Se sua função usa camadas, será necessário [verificar cada camada](adding-layers.md#finding-layer-information) para garantir que ela seja compatível com a nova arquitetura. Se uma camada não for compatível, edite a função para substituir a versão da camada atual por uma versão de camada compatível. + Se sua função usa extensões do Lambda, será necessário verificar cada camada para garantir que ela seja compatível com a nova arquitetura. + Se sua função usar um tipo de pacote de implantação de imagem de contêiner, você deverá criar uma nova imagem de contêiner compatível com a arquitetura da função. ## Como migrar para a arquitetura arm64 Para migrar uma função do Lambda para a arquitetura arm64, recomendamos seguir estas etapas: 1. Crie a lista de dependências para sua aplicação ou workload. As dependências comuns incluem: + Todas as bibliotecas e pacotes usados pela função. + As ferramentas que você usa para criar, implantar e testar a função, como compiladores, pacotes de testes, pipelines de integração contínua e entrega contínua (CI/CD), ferramentas de provisionamento e scripts. + As extensões do Lambda e ferramentas de terceiros que você usa para monitorar a função na produção. 1. Para cada uma das dependências, verifique a versão e verifique se há versões arm64 disponíveis. 1. Crie um ambiente para migrar sua aplicação. 1. Faça o bootstrap da aplicação. 1. Teste e depure a aplicação. 1. Teste a performance da função arm64. Compare a performance com a versão x86\$164. 1. Atualize o pipeline da infraestrutura para oferecer suporte às funções do Lambda em arm64. 1. Envie a implantação para a produção. Por exemplo, use a [configuração de roteamento de alias](configuring-alias-routing.md) para dividir o tráfego entre as versões x86 e arm64 da função e comparar a performance e a latência. Para obter mais informações sobre como criar um ambiente de código para a arquitetura arm64, incluindo informações específicas de linguagem para Java, Go, .NET e Python, consulte [Conceitos básicos do AWS Graviton](https://github.com/aws/aws-graviton-getting-started) no GitHub. ## Configuração da arquitetura do conjunto de instruções Você pode configurar a arquitetura do conjunto de instruções para funções do Lambda novas e existentes usando o console do Lambda, a AWS, SDKs, a AWS Command Line Interface (AWS CLI) ou o CloudFormation. Siga estas etapas para alterar a arquitetura do conjunto de instruções para uma função existente do Lambda no console. 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. 1. Escolha o nome da função para a qual você deseja configurar a arquitetura do conjunto de instruções. 1. Na guia principal **Código**, na seção **Configurações de runtime**, escolha **Editar**. 1. Em **Arquitetura**, escolha a arquitetura do conjunto de instruções a ser usado pela sua função. 1. Escolha **Salvar**. # Configurar tempo limite da função do Lambda O Lambda executa o código por um determinado período de tempo antes de atingir o tempo limite. O *tempo limite* é o período de tempo máximo, em segundos, durante o qual uma função do Lambda pode ser executada. O valor padrão dessa configuração é de 3 segundos, mas você pode ajustá-lo em incrementos de 1 segundo até o valor máximo de 900 segundos (15 minutos). Esta página descreve como e quando atualizar a configuração de tempo limite de uma função do Lambda. **Topics** + [ ## Determinar a configuração de tempo imite apropriada para uma função do Lambda ](#configuration-timeout-use-cases) + [ ## Configurar tempo limite (console) ](#configuration-timeout-console) + [ ## Configurar tempo limite (AWS CLI) ](#configuration-timeout-cli) + [ ## Configurar tempo limite (AWS SAM) ](#configuration-timeout-sam) ## Determinar a configuração de tempo imite apropriada para uma função do Lambda Se o valor do tempo limite for próximo da duração média de uma função, há um risco maior de que a função atinja o tempo limite inesperadamente. A duração de uma função pode variar dependendo da quantidade de transferência e processamento de dados, e da latência de qualquer serviço com o qual a função interaja. Algumas causas comuns de tempo limite esgotado incluem: + Os downloads do Amazon Simple Storage Service (Amazon S3) são maiores ou demoram mais que a média. + Uma função faz uma solicitação a outro serviço, que leva mais tempo para responder. + Os parâmetros fornecidos a uma função exigem mais complexidade computacional na função, o que faz com que a invocação leve mais tempo. Ao testar sua aplicação, certifique-se de que os testes reflitam exatamente o tamanho e a quantidade de dados, bem como valores de parâmetros realistas. Os testes geralmente usam amostras pequenas por conveniência, mas você deve usar conjuntos de dados nos limites superiores do que é razoavelmente esperado para a workload. ## Configurar tempo limite (console) É possível configurar o tempo limite da função no console do Lambda. **Para modificar o tempo limite de uma função** 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 **Configuração** e depois selecione **Configuração geral**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/configuration-tab.png) 1. Em **Configuração geral**, escolha **Editar**. 1. Para **Tempo limite**, defina um valor entre 1 e 900 segundos (15 minutos). 1. Escolha **Salvar**. ## Configurar tempo limite (AWS CLI) Você pode usar o comando [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html) para configurar o valor de tempo limite, em segundos. O exemplo de comando a seguir aumenta o tempo limite da função para 120 segundos (2 minutos). **Example** ``` aws lambda update-function-configuration \ --function-name my-function \ --timeout 120 ``` ## Configurar tempo limite (AWS SAM) Você pode usar o [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) para configurar o valor do tempo limite para a função. Atualize a propriedade [Tempo limite](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-timeout) no arquivo `template.yaml` e execute o comando [sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html). **Example template.yaml** ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Description: An AWS Serverless Application Model template describing your function. Resources: my-function: Type: AWS::Serverless::Function Properties: CodeUri: . Description: '' MemorySize: 128 Timeout: 120 # Other function properties... ``` # Configuração de funções duráveis do Lambda Para permitir a execução durável da sua função do Lambda, é necessário definir configurações específicas que controlem por quanto tempo sua função pode ser executada, por quanto tempo os dados de estado são retidos e quais permissões são necessárias. ## Habilitação da execução durável Para permitir a execução durável da sua função do Lambda, configure `DurableConfig` na definição da sua função. Essa configuração controla o tempo limite de execução, a retenção de estado e o comportamento do versionamento. ------ #### [ AWS CLI ] ``` aws lambda update-function-configuration \ --function-name my-durable-function \ --durable-config '{ "ExecutionTimeout": 3600, "RetentionPeriodInDays": 30, "AllowInvokeLatest": true }' ``` ------ #### [ CloudFormation ] ``` Resources: MyDurableFunction: Type: AWS::Lambda::Function Properties: FunctionName: my-durable-function Runtime: nodejs18.x Handler: index.handler Code: ZipFile: | // Your durable function code DurableConfig: ExecutionTimeout: 3600 RetentionPeriodInDays: 30 AllowInvokeLatest: true ``` ------ **Parâmetros de configuração:** + `ExecutionTimeout`: tempo máximo de execução em segundos (até 31.536.000 por um ano) + `RetentionPeriodInDays`: por quanto tempo manter o estado e o histórico de execução (1-365 dias) + `AllowInvokeLatest`: se deve permitir a invocação da versão \$1LATEST para execução durável ## Permissões do IAM para funções duráveis As funções duráveis exigem permissões adicionais do IAM além dos perfis de execução padrão do Lambda. O perfil de execução da sua função precisa incluir permissões para gerenciamento de estado e APIs de execução durável. **Permissões mínimas necessárias:** ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "lambda:InvokeFunction", "lambda:GetFunction", "lambda:ManageDurableState", "lambda:GetDurableExecution", "lambda:ListDurableExecutions" ], "Resource": "arn:aws:lambda:*:*:function:*" }, { "Effect": "Allow", "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents" ], "Resource": "arn:aws:logs:*:*:*" } ] } ``` **Exemplo de perfil de execução do CloudFormation** ``` DurableFunctionRole: Type: AWS::IAM::Role Properties: AssumeRolePolicyDocument: Version: '2012-10-17' Statement: - Effect: Allow Principal: Service: lambda.amazonaws.com Action: sts:AssumeRole ManagedPolicyArns: - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole Policies: - PolicyName: DurableFunctionPolicy PolicyDocument: Version: '2012-10-17' Statement: - Effect: Allow Action: - lambda:ManageDurableState - lambda:GetDurableExecution - lambda:ListDurableExecutions Resource: '*' ``` ## Práticas recomendadas para configuração Siga estas práticas recomendadas ao configurar funções duráveis para uso em produção: + **Defina tempos limite de execução adequados**: configure `ExecutionTimeout` com base na duração máxima esperada do seu fluxo de trabalho. Não defina prazos desnecessariamente longos, pois eles afetam a alocação de custos e recursos. + **Equilibre a retenção com os custos de armazenamento**: defina `RetentionPeriodInDays` com base em seus requisitos de depuração e auditoria. Períodos de retenção mais longos aumentam os custos de armazenamento. + **Use o versionamento na produção**: configure `AllowInvokeLatest` como `false` em ambientes de produção e use versões ou aliases de funções específicas para execuções duráveis. + **Monitore o tamanho do estado**: objetos de estado grandes aumentam os custos de armazenamento e podem afetar a performance. Mantenha o estado mínimo e use armazenamento externo para grandes volumes de dados. + **Configure o registro em log apropriado**: habilite o registro em log detalhado para solucionar problemas de fluxos de trabalho de longa duração, mas esteja atento ao volume e aos custos dos logs. **Exemplo de configuração de produção:** ``` { "ExecutionTimeout": 86400, "RetentionPeriodInDays": 7, "AllowInvokeLatest": false } ``` # Trabalhar com variáveis de ambiente no Lambda É possível usar variáveis de ambiente para ajustar o comportamento da função sem atualizar o código. Uma variável de ambiente é um par de strings armazenadas na configuração específica da versão de uma função. O runtime do Lambda disponibiliza variáveis de ambiente para o código e define variáveis de ambiente adicionais que contêm informações sobre a função e a solicitação de invocação. **nota** Para aumentar a segurança, recomendamos que você use o AWS Secrets Manager em vez de variáveis de ambiente para armazenar as credenciais do banco de dados e outras informações confidenciais, como chaves de API ou tokens de autorização. Para obter mais informações, consulte [Usar segredos do Secrets Manager em funções do Lambda](with-secrets-manager.md). As variáveis ​​de ambiente não são avaliadas antes da invocação da função. Qualquer valor definido é considerado uma string literal e não expandido. Execute a avaliação da variável no seu código de função. ## Criar variáveis ​​de ambiente no Lambda É possível configurar variáveis de ambiente no Lambda usando o console do Lambda, a AWS Command Line Interface (AWS CLI), o AWS Serverless Application Model (AWS SAM) ou um AWS SDK. ------ #### [ Console ] Você define variáveis de ambiente na versão não publicada da sua função. Quando você publica uma versão, as variáveis de ambiente estão bloqueadas para essa versão junto com outras [configurações específicas da versão](configuration-versions.md). Para criar uma variável de ambiente na sua função, defina uma chave e um valor. A função usa o nome da chave para recuperar o valor da variável de ambiente. **Para definir variáveis de ambiente no console do Lambda** 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 a guia **Configuração** e, em seguida, selecione **Variáveis de ambiente**. 1. Em **Environment variables (Variáveis de ambiente)**, selecione **Edit (Editar)**. 1. Escolha **Add environment variable (Adicionar variável de ambiente)**. 1. Insira um par de chave e valor. **Requisitos** + As chaves começam com uma letra e têm pelo menos dois caracteres. + As chaves e os valores contêm somente letras, números e o caractere de sublinhado (`_`). + As chaves não são [reservadas pelo Lambda](#configuration-envvars-runtime). + O tamanho total de todas as variáveis de ambiente não excede 4 KB. 1. Escolha **Salvar**. **Gerar uma lista de variáveis ​​de ambiente no editor de código do console** É possível gerar uma lista de variáveis ​​de ambiente no editor de código do Lambda. Esta é uma maneira rápida de referenciar as variáveis ​​de ambiente enquanto você realiza a codificação. 1. Escolha a guia **Código**. 1. Role a tela para baixo até a seção **VARIÁVEIS DE AMBIENTE** do editor de código. As variáveis de ambiente existentes estão listadas aqui: ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/env-var.png) 1. Para criar novas variáveis de ambiente, escolha o sinal de adição (![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/add-plus.png)): ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/create-env-var.png) As variáveis ​​de ambiente permanecem criptografadas quando estão listadas no editor de código do console. Se você habilitou os auxiliares de criptografia para a criptografia em trânsito, essas configurações permanecerão inalteradas. Para obter mais informações, consulte [Proteger variáveis ​​de ambiente no Lambda](configuration-envvars-encryption.md). A lista de variáveis ​​de ambiente é somente leitura e está disponível somente no console do Lambda. Este arquivo não está incluso quando você realiza download do arquivo .zip da função e não é possível adicionar variáveis ​​de ambiente ao fazer upload deste arquivo. ------ #### [ AWS CLI ] O exemplo a seguir define duas variáveis de ambiente em uma função denominada `my-function`. ``` aws lambda update-function-configuration \ --function-name my-function \ --environment "Variables={BUCKET=amzn-s3-demo-bucket,KEY=file.txt}" ``` Quando você aplica variáveis de ambiente com o comando `update-function-configuration`, todo o conteúdo da estrutura `Variables` é substituído. Para manter variáveis de ambiente existentes ao adicionar uma nova, inclua todos os valores existentes em sua solicitação. Para obter a configuração atual, use o comando `get-function-configuration`. ``` aws lambda get-function-configuration \ --function-name my-function ``` A seguinte saída deverá ser mostrada: ``` { "FunctionName": "my-function", "FunctionArn": "arn:aws:lambda:us-east-2:111122223333:function:my-function", "Runtime": "nodejs24.x", "Role": "arn:aws:iam::111122223333:role/lambda-role", "Environment": { "Variables": { "BUCKET": "amzn-s3-demo-bucket", "KEY": "file.txt" } }, "RevisionId": "0894d3c1-2a3d-4d48-bf7f-abade99f3c15", ... } ``` É possível transmitir o ID de revisão da saída de `get-function-configuration` como um parâmetro para `update-function-configuration`. Isso garante que os valores não sejam alterados entre quando você lê a configuração e quando a atualiza. Para configurar a chave de criptografia de uma função, defina a opção `KMSKeyARN`. ``` aws lambda update-function-configuration \ --function-name my-function \ --kms-key-arn arn:aws:kms:us-east-2:111122223333:key/055efbb4-xmpl-4336-ba9c-538c7d31f599 ``` ------ #### [ AWS SAM ] É possível usar o [AWS Serverless Application Model](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/serverless-getting-started.html ) para configurar as variáveis de ambiente da função. Atualize as propriedades [Ambiente](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-resource-function.html#sam-function-environment) e [Variáveis](https://docs.aws.amazon.com//AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-environment.html#cfn-lambda-function-environment-variables) no arquivo `template.yaml` e execute o comando [sam deploy](https://docs.aws.amazon.com//serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-deploy.html). **Example template.yaml** ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Description: An AWS Serverless Application Model template describing your function. Resources: my-function: Type: AWS::Serverless::Function Properties: CodeUri: . Description: '' MemorySize: 128 Timeout: 120 Handler: index.handler Runtime: nodejs24.x Architectures: - x86_64 EphemeralStorage: Size: 10240 Environment: Variables: BUCKET: amzn-s3-demo-bucket KEY: file.txt # Other function properties... ``` ------ #### [ AWS SDKs ] Para gerenciar variáveis de ambiente usando um AWS SDK, use as operações de API a seguir. + [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) Para saber mais, consulte a [documentação do AWS SDK](https://aws.amazon.com/developer/tools/) para a linguagem de programação que você preferir. ------ ## Exemplo de cenário para variáveis de ambiente É possível usar variáveis de ambiente para personalizar o comportamento da função no ambiente de teste e no ambiente de produção. Por exemplo, você pode criar duas funções com o mesmo código, mas configurações diferentes. Uma função se conecta a um banco de dados de teste e a outra se conecta a um banco de dados de produção. Nessa situação, você usa variáveis ​​de ambiente para transmitir o nome do host e outros detalhes de conexão do banco de dados para a função. O exemplo a seguir mostra como definir o host do banco de dados e o nome do banco de dados como variáveis de ambiente. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/console-env.png) Se quiser que o ambiente de teste gere mais informações de depuração do que o ambiente de produção, você poderá definir uma variável de ambiente para configurar o ambiente de teste para usar um registro em log mais detalhado ou um rastreamento mais detalhado. Por exemplo, em seu ambiente de teste, você pode definir uma variável de ambiente com a chave `LOG_LEVEL` e um valor indicando um nível de log de depuração ou rastreamento. No código da sua função do Lambda, você pode então usar essa variável de ambiente para definir o nível do log. Os exemplos de código a seguir em Python e Node.js ilustram como você pode fazer isso. Esses exemplos pressupõem que sua variável de ambiente tenha um valor de `DEBUG` em Python ou `debug` em Node.js. ------ #### [ Python ] **Example Código Python para definir o nível do log** ``` import os import logging # Initialize the logger logger = logging.getLogger() # Get the log level from the environment variable and default to INFO if not set log_level = os.environ.get('LOG_LEVEL', 'INFO') # Set the log level logger.setLevel(log_level) def lambda_handler(event, context): # Produce some example log outputs logger.debug('This is a log with detailed debug information - shown only in test environment') logger.info('This is a log with standard information - shown in production and test environments') ``` ------ #### [ Node.js (ES module format) ] **Example Código Node.js para definir o nível do log** Este exemplo usa a biblioteca de registro em log `winston`. Use o npm para adicionar essa biblioteca ao pacote de implantação da sua função. Para obter mais informações, consulte [Criar um pacote de implantação .zip com dependências](nodejs-package.md#nodejs-package-create-dependencies). ``` import winston from 'winston'; // Initialize the logger using the log level from environment variables, defaulting to INFO if not set const logger = winston.createLogger({ level: process.env.LOG_LEVEL || 'info', format: winston.format.json(), transports: [new winston.transports.Console()] }); export const handler = async (event) => { // Produce some example log outputs logger.debug('This is a log with detailed debug information - shown only in test environment'); logger.info('This is a log with standard information - shown in production and test environment'); }; ``` ------ ## Recuperar variáveis ​​de ambiente do Lambda Para recuperar variáveis de ambiente em seu código de função, use o método padrão para a sua linguagem de programação. ------ #### [ Node.js ] ``` let region = process.env.AWS_REGION ``` ------ #### [ Python ] ``` import os region = os.environ['AWS_REGION'] ``` **nota** Em alguns casos, talvez seja necessário usar o seguinte formato: ``` region = os.environ.get('AWS_REGION') ``` ------ #### [ Ruby ] ``` region = ENV["AWS_REGION"] ``` ------ #### [ Java ] ``` String region = System.getenv("AWS_REGION"); ``` ------ #### [ Go ] ``` var region = os.Getenv("AWS_REGION") ``` ------ #### [ C\$1 ] ``` string region = Environment.GetEnvironmentVariable("AWS_REGION"); ``` ------ #### [ PowerShell ] ``` $region = $env:AWS_REGION ``` ------ O Lambda armazena as variáveis de ambiente de forma segura, criptografando-as em repouso. É possível [configurar o Lambda para usar uma chave de criptografia diferente](configuration-envvars-encryption.md), criptografar valores de variáveis de ambiente no lado do cliente ou definir variáveis de ambiente em um modelo do CloudFormation com o AWS Secrets Manager. ## Variáveis de ambiente com runtime definido Os [runtimes](lambda-runtimes.md) do Lambda definem diversas variáveis de ambiente durante a inicialização. A maioria das variáveis de ambiente fornece informações sobre a função ou o runtime. As chaves para essas variáveis de ambiente são *reservadas* e não podem ser definidas na configuração de sua função. **Variáveis de ambiente reservadas** + `_HANDLER`: o local do handler configurado na função. + `_X_AMZN_TRACE_ID`— O[Cabeçalho do X-Ray](services-xray.md). Essa variável de ambiente muda a cada invocação. + Essa variável de ambiente não está definida para runtimes somente para sistema operacional (a família `provided` de runtime). É possível definir `_X_AMZN_TRACE_ID` para runtimes personalizados usando o cabeçalho da resposta `Lambda-Runtime-Trace-Id` do [Próxima invocação](runtimes-api.md#runtimes-api-next). + Nas versões 17 e posteriores do runtime do Java, essa variável de ambiente não é usada. Em vez disso, o Lambda armazena informações de rastreamento na propriedade `com.amazonaws.xray.traceHeader` do sistema. + `AWS_DEFAULT_REGION`: a Região da AWS padrão onde a função do Lambda é executada. + `AWS_REGION`: a Região da AWS onde a função do Lambda é executada. Se estiver definido, esse valor substituirá `AWS_DEFAULT_REGION`. + Para obter mais informações sobre como usar as variáveis de ambiente da Região da AWS com AWS SDKs, consulte [Região da AWS](https://docs.aws.amazon.com/sdkref/latest/guide/feature-region.html#feature-region-sdk-compat) no *Guia de referência de SDKs e ferramentas da AWS*. + `AWS_EXECUTION_ENV`: o [identificador de runtime](lambda-runtimes.md), prefixado por `AWS_Lambda_` (por exemplo, `AWS_Lambda_java8`). Essa variável de ambiente não está definida para runtimes somente para sistema operacional (a família `provided` de runtime). + `AWS_LAMBDA_FUNCTION_NAME`: o nome da função. + `AWS_LAMBDA_FUNCTION_MEMORY_SIZE`: a quantidade de memória disponível para a função em MB. + `AWS_LAMBDA_FUNCTION_VERSION`: a versão da função que está sendo executada. + `AWS_LAMBDA_INITIALIZATION_TYPE`: o tipo de inicialização da função, que é `on-demand`, `provisioned-concurrency`, `snap-start` ou `lambda-managed-instances`. Para obter informações, consulte [Configuração de simultaneidade provisionada](provisioned-concurrency.md), [Aprimoramento da performance de inicialização com o Lambda SnapStart](snapstart.md) ou [Instâncias gerenciadas do Lambda](lambda-managed-instances.md). + `AWS_LAMBDA_LOG_GROUP_NAME`,`AWS_LAMBDA_LOG_STREAM_NAME`: o nome do grupo Amazon CloudWatch Logs e do fluxo do para a função. As [variáveis de ambiente](#configuration-envvars-runtime) `AWS_LAMBDA_LOG_GROUP_NAME` e `AWS_LAMBDA_LOG_STREAM_NAME` não estão disponíveis nas funções do Lambda SnapStart. + `AWS_ACCESS_KEY`, `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`: as chaves de acesso obtidas da [função de execução](lambda-intro-execution-role.md) da função. + `AWS_LAMBDA_RUNTIME_API`: ([runtime personalizado](runtimes-custom.md)) o host e a porta da [API de runtime](runtimes-api.md). + `LAMBDA_TASK_ROOT`: o caminho para o código da função do Lambda. + `LAMBDA_RUNTIME_DIR`: o caminho para bibliotecas de runtime. + `AWS_LAMBDA_MAX_CONCURRENCY`: (somente instâncias gerenciadas do Lambda) o número máximo de invocações simultâneas que o Lambda enviará para um ambiente de execução. + `AWS_LAMBDA_METADATA_API`: o endereço do servidor do [endpoint de metadados](configuration-metadata-endpoint.md) no formato `{ipv4_address}:{port}` (por exemplo, `169.254.100.1:9001`). + `AWS_LAMBDA_METADATA_TOKEN`: um token de autenticação exclusivo para o ambiente de execução atual usado para autenticar solicitações no [endpoint de metadados](configuration-metadata-endpoint.md). O Lambda gera esse token automaticamente na inicialização. As variáveis de ambiente adicionais a seguir não são reservadas e podem ser estendidas na configuração de sua função. **Variáveis de ambiente não reservadas** + `LANG`: a localidade do runtime (`en_US.UTF-8`). + `PATH` – o caminho de execução (`/usr/local/bin:/usr/bin/:/bin:/opt/bin`). + `LD_LIBRARY_PATH` – o caminho da biblioteca do sistema (`/var/lang/lib:/lib64:/usr/lib64:$LAMBDA_RUNTIME_DIR:$LAMBDA_RUNTIME_DIR/lib:$LAMBDA_TASK_ROOT:$LAMBDA_TASK_ROOT/lib:/opt/lib`). + `NODE_PATH`: ([Node.js](lambda-nodejs.md)) o caminho da biblioteca Node.js (`/opt/nodejs/node12/node_modules/:/opt/nodejs/node_modules:$LAMBDA_RUNTIME_DIR/node_modules`). + `NODE_OPTIONS`: ([Node.js](lambda-nodejs.md)) Para tempos de execução do Node.js, você pode usar `NODE_OPTIONS` para reativar recursos experimentais que o Lambda desabilita por padrão. + `PYTHONPATH`: ([Python](lambda-python.md)) o caminho da biblioteca Python (`$LAMBDA_RUNTIME_DIR`). + `GEM_PATH`: ([Ruby](lambda-ruby.md)) o caminho da biblioteca Ruby (`$LAMBDA_TASK_ROOT/vendor/bundle/ruby/3.3.0:/opt/ruby/gems/3.3.0`). + `AWS_XRAY_CONTEXT_MISSING`: para o rastreamento do X-Ray, o Lambda define isso como `LOG_ERROR` para evitar a execução de erros de runtime no X-Ray SDK. + `AWS_XRAY_DAEMON_ADDRESS`: para o rastreamento do X-Ray, o endereço IP e a porta do daemon do X-Ray. + `AWS_LAMBDA_DOTNET_PREJIT` ([.NET](lambda-csharp.md)): defina esta variável para habilitar ou desabilitar otimizações específicas de runtime do .NET. Os valores incluem `always`, `never` e `provisioned-concurrency`. Para obter mais informações, consulte [Configurar a simultaneidade provisionada para uma função](provisioned-concurrency.md). + `TZ` – o fuso horário do ambiente (`:UTC`). O ambiente de execução usa o NTP para sincronizar o relógio do sistema. Os valores de exemplo mostrados refletem os runtimes mais recentes. A presença de variáveis específicas ou seus valores pode variar nos runtimes anteriores. # Proteger variáveis ​​de ambiente no Lambda Para proteger suas variáveis de ambiente, você pode usar a criptografia do lado do servidor para proteger seus dados em repouso e a criptografia do lado do cliente para proteger seus dados em trânsito. **nota** Para aumentar a segurança do banco de dados, recomendamos que você use o AWS Secrets Manager em vez de variáveis ​​de ambiente para armazenar as credenciais do banco de dados. Para obter mais informações, consulte [Usar segredos do Secrets Manager em funções do Lambda](with-secrets-manager.md). **Segurança em repouso** O Lambda sempre fornece criptografia do lado do servidor em repouso com AWS KMS key. Por padrão, o Lambda usa um Chave gerenciada pela AWS. Se esse comportamento padrão for adequado ao fluxo de trabalho, você não precisará configurar mais nada. O Lambda cria a Chave gerenciada pela AWS em sua conta e gerencia permissões para você. A AWS não cobra pelo uso dessa chave. Se você preferir, pode fornecer uma AWS KMS chave gerenciada pelo cliente. É possível fazer isso para ter controle sobre a alternância da chave KMS ou para atender aos requisitos de sua organização para gerenciar chaves KMS. Quando você fornece uma chave gerenciada pelo cliente, somente os usuários em sua conta com acesso à chave KMS podem visualizar ou gerenciar variáveis de ambiente na função. As chaves gerenciadas pelo cliente incorrem em cobranças do AWS KMS padrão. Para obter mais informações, consulte [Preços do AWS Key Management Service](https://aws.amazon.com/kms/pricing/). **Segurança em trânsito** Para segurança adicional, você pode habilitar auxiliares para criptografia em trânsito, o que garante que suas variáveis de ambiente sejam criptografadas no lado do cliente para proteção em trânsito. **Para configurar a criptografia para suas variáveis de ambiente** 1. Usar a AWS Key Management Service (AWS KMS) para criar quaisquer chaves gerenciadas pelo cliente para o Lambda usar para criptografia do lado do cliente e do servidor. Para obter mais informações, consulte [Criação de chaves](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) *Guia do desenvolvedor do AWS Key Management Service*. 1. Usando o console do Lambda, navegue até a página **Editar variáveis de ambiente**. 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. Selecione **Configuração** e, depois, escolha **Variáveis de ambiente** na barra de navegação à esquerda. 1. Em **Variáveis de ambiente**, selecione **Editar**. 1. Expanda **Encryption configuration (Configuração de criptografia)**. 1. (Opcional) Habilite os auxiliares de criptografia do console para usar a criptografia do lado do cliente com a finalidade de proteger os dados em trânsito. 1. Em **Criptografia em trânsito**, escolha **Habilitar auxiliares para criptografia em trânsito**. 1. Para cada variável de ambiente na qual deseja habilitar os auxiliares de criptografia do console, escolha **Encrypt** (Criptografar) ao lado da variável de ambiente. 1. Em AWS KMS key para criptografar em trânsito, escolha uma chave gerenciada pelo cliente criada no início deste procedimento. 1. Selecione **Política da função de execução** e copie a política. Essa política concede permissão à função de execução de sua função para descriptografar variáveis de ambiente. Salve essa política para usar na última etapa deste procedimento. 1. Adicione à sua função o código que descriptografa as variáveis de ambiente. Para ver um exemplo, escolha **Snippet de descriptografia de segredos**. 1. (Opcional) Especifique a chave gerenciada pelo cliente para a criptografia em repouso. 1. Escolha **Uso de chave mestra do cliente**. 1. Escolha uma chave gerenciada pelo cliente que você criou no início deste procedimento. 1. Escolha **Salvar**. 1. Configurar permissões Se você estiver usando uma chave gerenciada pelo cliente com criptografia do lado do servidor, conceda permissões a todos os usuários ou perfis que deseja visualizar ou gerenciar variáveis ​​de ambiente na função. Para obter mais informações, consulte [Gerenciar permissões para a chave KMS de criptografia do lado do servidor](#managing-permissions-to-your-server-side-encryption-key). Se você estiver habilitando a criptografia do lado do cliente para segurança em trânsito, sua função precisará de permissão para chamar o método operação da API `kms:Decrypt`. Adicione a política que você salvou anteriormente à [Função de execução](lambda-intro-execution-role.md) neste procedimento. ## Gerenciar permissões para a chave KMS de criptografia do lado do servidor Para usar a chave de criptografia padrão, não é necessária nenhuma permissão do AWS KMS para o usuário ou para a função de execução da função. Para usar uma chave gerenciada pelo cliente, é necessário permissão para usar a chave. O Lambda usa essas permissões para criar uma concessão na chave. Isso permite que o Lambda use-a para criptografia. + `kms:ListAliases`: para visualizar as teclas no console do Lambda. + `kms:CreateGrant`, `kms:Encrypt` – para configurar uma chave gerenciada pelo cliente em uma função. + `kms:Decrypt` – para visualizar e gerenciar variáveis de ambiente criptografadas com uma chave gerenciada pelo cliente. É possível obter essas permissões em sua Conta da AWS ou na política de permissões baseada em recursos de uma chave. `ListAliases` é fornecido pelas [políticas gerenciadas para o Lambda](access-control-identity-based.md). As políticas de chave concedem as permissões restantes aos usuários no grupo **Usuários de chaves**. Os usuários sem permissões `Decrypt` ainda poderão gerenciar funções, mas não poderão visualizar variáveis de ambiente nem gerenciá-las no console do Lambda. Para impedir que um usuário visualize variáveis de ambiente, adicione uma declaração às permissões do usuário que negue o acesso à chave padrão, a uma chave gerenciada pelo cliente ou a todas as chaves. **Example Política do IAM: negar acesso pelo ARN da chave** **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Deny", "Action": [ "kms:Decrypt" ], "Resource": "arn:aws:kms:us-east-2:111122223333:key/3be10e2d-xmpl-4be4-bc9d-0405a71945cc" } ] } ``` Para obter detalhes sobre como gerenciar permissões de chave, consulte [Key policies in AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html) no *Guia do desenvolvedor do AWS Key Management Service*. # Conceder acesso a funções do Lambda para recursos em uma Amazon VPC Com a Amazon Virtual Private Cloud (Amazon VPC), você pode criar redes privadas em sua Conta da AWS para hospedar recursos como instâncias do Amazon Elastic Compute Cloud (Amazon EC2), do Amazon Relational Database Service (Amazon RDS) e do Amazon ElastiCache. É possível dar à sua função do Lambda acesso a recursos hospedados em uma Amazon VPC ao anexar sua função à VPC por meio das sub-redes privadas que contêm os recursos. Siga as instruções nas seções a seguir para anexar uma função do Lambda a uma Amazon VPC usando o console Lambda, a AWS Command Line Interface (AWS CLI) ou AWS SAM. **nota** Cada função do Lambda é executada dentro de uma VPC de propriedade e gerenciada pelo serviço do Lambda. Essas VPCs recebem manutenção automática do Lambda e não são visíveis para os clientes. Configurar sua função para acessar outros recursos da AWS em uma Amazon VPC não tem efeito na VPC gerenciada pelo Lambda na qual sua função é executada. **Topics** + [ ## Permissões obrigatórias do IAM ](#configuration-vpc-permissions) + [ ## Como anexar funções do Lambda a uma Amazon VPC em sua Conta da AWS ](#configuration-vpc-attaching) + [ ## Acesso à Internet quando anexado a uma VPC ](#configuration-vpc-internet-access) + [ ## Suporte a IPv6 ](#configuration-vpc-ipv6) + [ ## Práticas recomendadas para usar o Lambda com Amazon VPCs ](#configuration-vpc-best-practice) + [ ## Noções básicas de interfaces de rede elástica (ENIs) de hiperplano ](#configuration-vpc-enis) + [ ## Usar chaves de condição do IAM para configurações de VPC ](#vpc-conditions) + [ ## Tutoriais de VPC ](#vpc-tutorials) ## Permissões obrigatórias do IAM Para anexar uma função do Lambda a uma Amazon VPC em sua Conta da AWS, o Lambda precisa de permissões para criar e gerenciar as interfaces de rede que usa para dar à sua função acesso aos recursos na VPC. As interfaces de rede que o Lambda cria são conhecidas como Hyperplane Elastic Network Interfaces, ou Hyperplane ENIs. Para saber mais sobre essas interfaces de rede, consulte [Noções básicas de interfaces de rede elástica (ENIs) de hiperplano](#configuration-vpc-enis). É possível dar à sua função as permissões necessárias anexando a política gerenciada [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) da AWS ao perfil de execução da função. Quando você cria uma nova função no console do Lambda e a anexa a uma VPC, o Lambda adiciona automaticamente essa política de permissões para você. Se você preferir criar sua própria política de permissões do IAM, adicione todas as permissões a seguir e permita que eles acessem todos os recursos (`"Resource": "*"`): + ec2:CreateNetworkInterface + ec2:DescribeNetworkInterfaces + ec2:DescribeSubnets + ec2:DeleteNetworkInterface + ec2:AssignPrivateIpAddresses + ec2:UnassignPrivateIpAddresses Observe que o perfil da sua função só precisa dessas permissões para criar as interfaces de rede, não para invocar sua função. Você ainda poderá invocar a função com êxito quando ela estiver anexada a uma Amazon VPC, mesmo que você remova essas permissões do perfil de execução da função. Para anexar sua função a uma VPC, o Lambda também precisa verificar os recursos de rede usando seu perfil de usuário do IAM. Seu perfil de usuário deve ter as seguintes permissões do IAM: + **ec2:DescribeSecurityGroups** + **ec2:DescribeSubnets** + **ec2:DescribeVpcs** + **ec2:GetSecurityGroupsForVpc** **nota** As permissões do Amazon EC2 que você concede ao perfil de execução da função são usadas pelo serviço Lambda para anexar sua função a uma VPC. No entanto, essas permissões também são concedidas implicitamente ao código da sua função. Isso significa que seu código de função pode fazer essas chamadas de API do Amazon EC2. Para obter conselhos sobre como seguir as práticas recomendadas de segurança, consulte [Práticas recomendadas de segurança](#configuration-vpc-best-practice-security). ## Como anexar funções do Lambda a uma Amazon VPC em sua Conta da AWS Anexe sua função a uma Amazon VPC em sua Conta da AWS usando o console do Lambda, a AWS CLI ou o AWS SAM. Se você estiver usando a AWS CLI ou o AWS SAM, ou anexando uma função existente a uma VPC usando o console do Lambda, o perfil de execução da função deve ter as permissões necessárias listadas na seção anterior. As funções do Lambda não podem se conectar diretamente a uma VPC com a [locação de instâncias dedicadas](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/dedicated-instance.html). Para se conectar a recursos em uma VPC dedicada, [emparelhe-a com uma segunda VPC com locação padrão](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-dedicated-vpc/). ------ #### [ Lambda console ] **Para anexar uma função a uma Amazon VPC ao criá-la** 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. Em **Basic information (Informações básicas)**, para **Function name (Nome da função)**, insira um nome para a função. 1. Defina as configurações da função desta forma: 1. Expanda **Advanced settings (Configurações avançadas)**. 1. Selecione **Habilitar VPC** e, em seguida, escolha a VPC à qual deseja anexar a função. 1. (Opcional) Para permitir [tráfego IPv6 de saída](#configuration-vpc-ipv6), selecione **Permitir tráfego IPv6 para sub-redes de pilha dupla**. 1. Escolha as sub-redes e os grupos de segurança para os quais criar a interface de rede. Se você selecionou **Permitir tráfego IPv6 para sub-redes de pilha dupla**, todas as sub-redes selecionadas deverão ter um bloco CIDR IPv4 e um bloco CIDR IPv6. **nota** Para acessar recursos privados, conecte a função às sub-redes privadas. Se sua função precisar de acesso à Internet, consulte [Habilitar o acesso à Internet para funções do Lambda conectadas à VPC](configuration-vpc-internet.md). Conectar uma função a uma sub-rede pública não dá a ela acesso à Internet nem a um endereço IP público. 1. Escolha a opção **Criar função**. **Para anexar uma função existente a uma Amazon VPC** 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. Escolha a guia **Configuração** e depois **VPC**. 1. Escolha **Editar**. 1. Em **VPC**, selecione a Amazon VPC à qual deseja anexar sua função. 1. (Opcional) Para permitir [tráfego IPv6 de saída](#configuration-vpc-ipv6), selecione **Permitir tráfego IPv6 para sub-redes de pilha dupla**. 1. Escolha as sub-redes e os grupos de segurança para os quais criar a interface de rede. Se você selecionou **Permitir tráfego IPv6 para sub-redes de pilha dupla**, todas as sub-redes selecionadas deverão ter um bloco CIDR IPv4 e um bloco CIDR IPv6. **nota** Para acessar recursos privados, conecte a função às sub-redes privadas. Se sua função precisar de acesso à Internet, consulte [Habilitar o acesso à Internet para funções do Lambda conectadas à VPC](configuration-vpc-internet.md). Conectar uma função a uma sub-rede pública não dá a ela acesso à Internet nem a um endereço IP público. 1. Escolha **Salvar**. ------ #### [ AWS CLI ] **Para anexar uma função a uma Amazon VPC ao criá-la** + Para criar uma função do Lambda e anexá-la a uma VPC, execute este comando da CLI `create-function`. ``` aws lambda create-function --function-name my-function \ --runtime nodejs24.x --handler index.js --zip-file fileb://function.zip \ --role arn:aws:iam::123456789012:role/lambda-role \ --vpc-config Ipv6AllowedForDualStack=true,SubnetIds=subnet-071f712345678e7c8,subnet-07fd123456788a036,SecurityGroupIds=sg-085912345678492fb ``` Especifique suas próprias sub-redes e grupos de segurança e defina `Ipv6AllowedForDualStack` como `true` ou `false` de acordo com seu caso de uso. **Para anexar uma função existente a uma Amazon VPC** + Para anexar uma função existente a uma VPC, execute este comando da CLI `update-function-configuration`. ``` aws lambda update-function-configuration --function-name my-function \ --vpc-config Ipv6AllowedForDualStack=true, SubnetIds=subnet-071f712345678e7c8,subnet-07fd123456788a036,SecurityGroupIds=sg-085912345678492fb ``` **Para desanexar sua função de uma VPC** + Para desanexar a função de uma VPC, execute este comando da CLI `update-function-configuration` com uma lista vazia de sub-redes e grupos de segurança da VPC. ``` aws lambda update-function-configuration --function-name my-function \ --vpc-config SubnetIds=[],SecurityGroupIds=[] ``` ------ #### [ AWS SAM ] **Para anexar sua função a uma VPC** + Para anexar uma função do Lambda a uma Amazon VPC, adicione a propriedade `VpcConfig` à sua definição de função, conforme mostrado no modelo de exemplo a seguir. Para obter mais informações sobre essa propriedade, consulte [AWS::Lambda::Function VpcConfig](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-vpcconfig.html) no *Guia do usuário do CloudFormation* (a propriedade `VpcConfig` do AWS SAM é passada diretamente para a propriedade `VpcConfig` de um recurso `AWS::Lambda::Function` do CloudFormation). ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 Resources: MyFunction: Type: AWS::Serverless::Function Properties: CodeUri: ./lambda_function/ Handler: lambda_function.handler Runtime: python3.12 VpcConfig: SecurityGroupIds: - !Ref MySecurityGroup SubnetIds: - !Ref MySubnet1 - !Ref MySubnet2 Policies: - AWSLambdaVPCAccessExecutionRole MySecurityGroup: Type: AWS::EC2::SecurityGroup Properties: GroupDescription: Security group for Lambda function VpcId: !Ref MyVPC MySubnet1: Type: AWS::EC2::Subnet Properties: VpcId: !Ref MyVPC CidrBlock: 10.0.1.0/24 MySubnet2: Type: AWS::EC2::Subnet Properties: VpcId: !Ref MyVPC CidrBlock: 10.0.2.0/24 MyVPC: Type: AWS::EC2::VPC Properties: CidrBlock: 10.0.0.0/16 ``` Para obter mais informações sobre como configurar sua VPC no AWS SAM, consulte [AWS::EC2::VPC](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html) no *Guia do usuário do CloudFormation*. ------ ## Acesso à Internet quando anexado a uma VPC Por padrão, as funções do Lambda têm acesso à Internet pública. Quando você anexar sua função a uma VPC, ela só poderá acessar os recursos disponíveis nessa VPC. Para conceder acesso à Internet para a função, também é necessário configurar a VPC para ter acesso à Internet. Para saber mais, consulte [Habilitar o acesso à Internet para funções do Lambda conectadas à VPC](configuration-vpc-internet.md). ## Suporte a IPv6 Sua função pode se conectar a recursos em sub-redes de VPC de pilha dupla via IPv6. Esta opção é desativada por padrão. Para permitir o tráfego IPv6 de saída, use o console ou a opção `--vpc-config Ipv6AllowedForDualStack=true` com o comando [create-function](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-function.html) ou [update-function-configuration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-function-configuration.html). **nota** Para permitir o tráfego IPv6 de saída em uma VPC, todas as sub-redes conectadas à função devem ser sub-redes de pilha dupla. O Lambda não é compatível com conexões IPv6 de saída para sub-redes apenas IPv6 em uma VPC ou conexões IPv6 de saída para funções não conectadas a uma VPC. É possível atualizar seu código de função para se conectar explicitamente a recursos da sub-rede via IPv6. O exemplo em Python a seguir abre um soquete e se conecta a um servidor IPv6. **Example — Conectar ao servidor IPv6** ``` def connect_to_server(event, context): server_address = event['host'] server_port = event['port'] message = event['message'] run_connect_to_server(server_address, server_port, message) def run_connect_to_server(server_address, server_port, message): sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM, 0) try: # Send data sock.connect((server_address, int(server_port), 0, 0)) sock.sendall(message.encode()) BUFF_SIZE = 4096 data = b'' while True: segment = sock.recv(BUFF_SIZE) data += segment # Either 0 or end of data if len(segment) < BUFF_SIZE: break return data finally: sock.close() ``` ## Práticas recomendadas para usar o Lambda com Amazon VPCs Para garantir que sua configuração de VPC da Lambda atenda às diretrizes de práticas recomendadas, siga os conselhos nas seções a seguir. ### Práticas recomendadas de segurança Para anexar sua função do Lambda a uma VPC, você precisa conceder ao perfil de execução da função várias permissões do Amazon EC2. Essas permissões são necessárias para criar as interfaces de rede que sua função usa para acessar os recursos na VPC. No entanto, essas permissões também são concedidas implicitamente ao código da sua função. Isso significa que seu código de função tem permissão para fazer essas chamadas de API do Amazon EC2. Para seguir o princípio do acesso com privilégios mínimos, adicione uma política de negação, como o exemplo a seguir, ao perfil de execução da sua função. Essa política impede que seu código de função faça chamadas para APIs do Amazon EC2 e, ao mesmo tempo, permite que o serviço do Lambda gerencie recursos de VPC em seu nome. A política usa a chave de condição `lambda:SourceFunctionArn`, que apenas se aplica a chamadas de API feitas pelo código da função durante a execução. Para obter mais informações, consulte [Usar o ARN da função de origem para controlar o comportamento de acesso da função](permissions-source-function-arn.md). ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Deny", "Action": [ "ec2:CreateNetworkInterface", "ec2:DeleteNetworkInterface", "ec2:DescribeNetworkInterfaces", "ec2:DescribeSubnets", "ec2:DetachNetworkInterface", "ec2:AssignPrivateIpAddresses", "ec2:UnassignPrivateIpAddresses" ], "Resource": [ "*" ], "Condition": { "ArnEquals": { "lambda:SourceFunctionArn": [ "arn:aws:lambda:us-west-2:123456789012:function:my_function" ] } } } ] } ``` ------ A AWS fornece *[grupos de segurança](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html)* e *[listas de controle de acesso (ACL) de rede](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html)* para aumentar a segurança em sua VPC. Os grupos de segurança controlam o tráfego de entrada e de saída para seus recursos e as Network ACLs controlam o tráfego de entrada e de saída de suas sub-redes. Os grupos de segurança fornecem controle de acesso suficiente para a maioria das sub-redes. É possível usar as ACLs de rede se desejar uma camada adicional de segurança para a VPC. Para obter diretrizes gerais sobre as práticas recomendadas de segurança ao usar Amazon VPCs, consulte [Melhores práticas de segurança para a sua VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-security-best-practices.html) no *Guia do usuário do Amazon Virtual Private Cloud*. ### Práticas recomendadas de performance Quando você anexa sua função a uma VPC, o Lambda verifica se há um recurso de rede disponível (ENI de hiperplano) que ela possa usar para se conectar. Os ENIs de hiperplano estão associados a uma combinação específica de grupos de segurança e sub-redes da VPC. Se você já anexou uma função a uma VPC, especificar as mesmas sub-redes e grupos de segurança ao anexar outra função significa que o Lambda pode compartilhar os recursos de rede e evitar a necessidade de criar um novo ENI de hiperplano. Para obter mais informações sobre ENIs de hiperplano e seu ciclo de vida, consulte [Noções básicas de interfaces de rede elástica (ENIs) de hiperplano](#configuration-vpc-enis). ## Noções básicas de interfaces de rede elástica (ENIs) de hiperplano Uma ENI de hiperplano é um recurso gerenciado que atua como uma interface de rede entre sua função do Lambda e os recursos aos quais você deseja que sua função se conecte. O serviço do Lambda cria e gerencia essas ENIs automaticamente quando você anexa sua função a uma VPC. As ENIs de hiperplano não são diretamente visíveis para você e você não precisa configurar ou gerenciá-las. No entanto, saber como elas funcionam pode ajudar você a entender o comportamento da sua função ao anexá-la a uma VPC. Na primeira vez que você associa uma função a uma VPC usando uma combinação específica de sub-rede e grupo de segurança, o Lambda cria uma ENI de hiperplano. Outras funções da sua conta que usam a mesma combinação de sub-rede e grupo de segurança também podem usar essa ENI. Sempre que possível, o Lambda reutiliza ENIs existentes para otimizar a utilização de recursos e minimizar a criação de novas ENIs. Porém, cada ENI de hiperplano comporta até 65.000 conexões/portas. Se o número de conexões exceder esse limite, o Lambda escalará o número de ENIs automaticamente com base no tráfego de rede e nos requisitos de simultaneidade. Para novas funções, enquanto o Lambda está criando uma ENI de hiperplano, sua função permanece no estado Pendente e você não pode invocá-la. Sua função fará a transição para o estado ativo somente quando a ENI de hiperplano estiver pronta, o que pode levar vários minutos. Para funções existentes, não é possível executar operações adicionais direcionadas à função, como criar versões ou atualizar o código da função, mas é possível continuar invocando versões anteriores da função. Como parte do gerenciamento do ciclo de vida da ENI, o Lambda pode excluir e recriar ENIs para fazer o balanceamento da carga do tráfego de rede entre ENIs ou resolver problemas detectados nas verificações de integridade da ENI. Além disso, se uma função do Lambda permanecer ociosa por 14 dias, o Lambda recuperará todas as ENIs de hiperplano não utilizadas e definirá o estado da função como `Inactive`. A próxima tentativa de invocação falha e a função entra novamente no estado pendente até que o Lambda conclua a criação ou alocação de uma ENI de hiperplano. Convém que o seu projeto não dependa da persistência de ENIs. Quando você atualiza uma função para remover sua configuração de VPC, o Lambda demora até 20 minutos para excluir a ENI de hiperplano anexada. O Lambda só exclui a ENI se nenhuma outra função (ou versão de função publicada) estiver usando essa ENI de hiperplano. O Lambda depende de permissões na [função de execução](lambda-intro-execution-role.md) da função para excluir a ENI de hiperplano. Se você excluir a função de execução antes que o Lambda exclua a ENI de hiperplano, o Lambda não poderá excluir a ENI de hiperplano. É possível executar a exclusão manualmente. ## Usar chaves de condição do IAM para configurações de VPC É possível usar chaves de condição específicas do Lambda para configurações de VPC a fim de fornecer controles de permissão adicionais para as funções do Lambda. Por exemplo, você pode exigir que todas as funções em sua organização estejam conectadas a uma VPC. Também é possível especificar as sub-redes e os grupos de segurança que os usuários da função podem e não podem usar. O Lambda oferece suporte às seguintes chaves de condição em políticas do IAM: + **lambda:VpcIds**: permitir ou negar uma ou mais VPCs. + **lambda:SubnetIds**: permitir ou negar uma ou mais sub-redes. + **lambda:SecurityGroupIds**: permitir ou negar um ou mais grupos de segurança. As operações de API [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html) e [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html) do Lambda oferecem suporte a essas chaves de condição. Para obter mais informações sobre o uso de chaves de condição em políticas do IAM, consulte[Elementos de política JSON do: condição](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html)no*IAM User Guide*. **dica** Se a função já incluir uma configuração de VPC de uma solicitação de API anterior, você poderá enviar uma solicitação `UpdateFunctionConfiguration` sem a configuração da VPC. ### Políticas de exemplo com chaves de condição para configurações de VPC Os exemplos a seguir demonstram como usar chaves de condição para configurações de VPC. Depois de criar uma instrução de política com as restrições desejadas, acrescente a instrução de política para o usuário ou a função de destino. #### Os usuários devem implantar somente funções conectadas à VPC Para garantir que todos os usuários implantem somente funções conectadas à VPC, você pode negar operações de criação e de atualização de funções que não incluam um ID de VPC válido. Observe que o ID da VPC não é um parâmetro de entrada para a solicitação `CreateFunction` ou `UpdateFunctionConfiguration`. O Lambda recupera o valor do ID da VPC com base nos parâmetros da sub-rede e do grupo de segurança. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "EnforceVPCFunction", "Action": [ "lambda:CreateFunction", "lambda:UpdateFunctionConfiguration" ], "Effect": "Deny", "Resource": "*", "Condition": { "Null": { "lambda:VpcIds": "true" } } } ] } ``` ------ #### Negar acesso de usuários a VPCs, sub-redes ou grupos de segurança específicos Para negar acesso de usuários a VPCs específicas, use `StringEquals` para verificar o valor da condição `lambda:VpcIds`. O exemplo a seguir nega aos usuários acesso à `vpc-1` e à `vpc-2`. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "EnforceOutOfVPC", "Action": [ "lambda:CreateFunction", "lambda:UpdateFunctionConfiguration" ], "Effect": "Deny", "Resource": "*", "Condition": { "StringEquals": { "lambda:VpcIds": [ "vpc-1", "vpc-2" ] } } } ] } ``` ------ Para negar acesso de usuários a sub-redes específicas, use `StringEquals` para verificar o valor da condição `lambda:SubnetIds`. O exemplo a seguir nega aos usuários acesso à `subnet-1` e à `subnet-2`. ``` { "Sid": "EnforceOutOfSubnet", "Action": [ "lambda:CreateFunction", "lambda:UpdateFunctionConfiguration" ], "Effect": "Deny", "Resource": "*", "Condition": { "ForAnyValue:StringEquals": { "lambda:SubnetIds": ["subnet-1", "subnet-2"] } } } ``` Para negar acesso de usuários a grupos de segurança específicos, use `StringEquals` para verificar o valor da condição `lambda:SecurityGroupIds`. O exemplo a seguir nega aos usuários acesso à `sg-1` e à `sg-2`. ``` { "Sid": "EnforceOutOfSecurityGroups", "Action": [ "lambda:CreateFunction", "lambda:UpdateFunctionConfiguration" ], "Effect": "Deny", "Resource": "*", "Condition": { "ForAnyValue:StringEquals": { "lambda:SecurityGroupIds": ["sg-1", "sg-2"] } } } ] } ``` #### Permitir que os usuários criem e atualizem funções com configurações de VPC específicas Para permitir que os usuários acessem VPCs específicas, use `StringEquals` para verificar o valor da condição `lambda:VpcIds`. O exemplo a seguir dá aos usuários permissão para acessar `vpc-1` e `vpc-2`. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "EnforceStayInSpecificVpc", "Action": [ "lambda:CreateFunction", "lambda:UpdateFunctionConfiguration" ], "Effect": "Allow", "Resource": "*", "Condition": { "StringEquals": { "lambda:VpcIds": [ "vpc-1", "vpc-2" ] } } } ] } ``` ------ Para permitir que os usuários acessem sub-redes específicas, use `StringEquals` para verificar o valor da condição `lambda:SubnetIds`. O exemplo a seguir dá aos usuários permissão para acessar `subnet-1` e `subnet-2`. ``` { "Sid": "EnforceStayInSpecificSubnets", "Action": [ "lambda:CreateFunction", "lambda:UpdateFunctionConfiguration" ], "Effect": "Allow", "Resource": "*", "Condition": { "ForAllValues:StringEquals": { "lambda:SubnetIds": ["subnet-1", "subnet-2"] } } } ``` Para permitir que os usuários acessem grupos de segurança específicos, use `StringEquals` para verificar o valor da condição `lambda:SecurityGroupIds`. O exemplo a seguir dá aos usuários permissão para acessar `sg-1` e `sg-2`. ``` { "Sid": "EnforceStayInSpecificSecurityGroup", "Action": [ "lambda:CreateFunction", "lambda:UpdateFunctionConfiguration" ], "Effect": "Allow", "Resource": "*", "Condition": { "ForAllValues:StringEquals": { "lambda:SecurityGroupIds": ["sg-1", "sg-2"] } } } ] } ``` ## Tutoriais de VPC Nos tutoriais a seguir, você conecta uma função do Lambda a recursos na VPC. + [Tutorial: usar uma função do Lambda para acessar o Amazon RDS em uma Amazon VPC](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-lambda-tutorial.html) + [Tutorial: configurar uma função do Lambda para acessar o Amazon ElastiCache em uma Amazon VPC](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/LambdaRedis.html) # Conceder acesso a funções do Lambda para um recurso em uma Amazon VPC em outra conta Você pode conceder à sua função do AWS Lambda acesso a um recurso em uma Amazon VPC na Amazon Virtual Private Cloud gerenciada por outra conta, sem expor nenhuma VPC à internet. Esse padrão de acesso permite que você compartilhe dados com outras organizações usando a AWS. Usando esse padrão de acesso, você pode compartilhar dados entre VPCs com um nível maior de segurança e performance do que pela internet. Configure a função do Lambda para usar uma conexão de emparelhamento da Amazon VPC para acessar esses recursos. **Atenção** Ao permitir o acesso entre contas ou VPCs, verifique se o plano atende aos requisitos de segurança das respectivas organizações que gerenciam essas contas. Seguir as instruções deste documento afetará a postura de segurança dos recursos. Neste tutorial, você conecta duas contas com uma conexão de emparelhamento usando IPv4. Você configura uma função do Lambda que ainda não está conectada a uma Amazon VPC. Você configura a resolução de DNS para conectar a função a recursos que não fornecem IPs estáticos. Para adaptar essas instruções a outros cenários de emparelhamento, consulte o [Guia de emparelhamento de VPCs](https://docs.aws.amazon.com//vpc/latest/peering/what-is-vpc-peering.html). ## Pré-requisitos Para conceder acesso a uma função do Lambda a um recurso em outra conta, você deve ter: + Uma função do Lambda, configurada para se autenticar e depois ler seu recurso. + Um recurso em outra conta, como um cluster do Amazon RDS, disponível por meio da Amazon VPC. + Credenciais para a conta da função do Lambda e a conta do recurso. Se você não estiver autorizado a usar a conta do recurso, entre em contato com um usuário autorizado para preparar essa conta. + Permissão para criar e atualizar uma VPC (e ser compatível com recursos da Amazon VPC) para associá-la à função do Lambda. + Permissão para atualizar o perfil de execução e a configuração da VPC para a função do Lambda. + Permissão para criar uma conexão de emparelhamento da VPC na conta da função do Lambda. + Permissão para aceitar uma conexão de emparelhamento da VPC na conta do recurso. + Permissão para atualizar a configuração da VPC do recurso (e ser compatível com os recursos da Amazon VPC). + Permissão para invocar a função do Lambda. ## Criar uma Amazon VPC na conta da função Crie uma Amazon VPC, sub-redes, tabelas de rotas e um grupo de segurança na conta da função do Lambda. **Para criar uma VPC, sub-redes e outros recursos de VPC usando o console** 1. Abra o console da Amazon VPC em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. No painel, escolha **Criar VPC**. 1. Para o **bloco CIDR IPv4**, forneça um bloco CIDR privado. Seu bloco CIDR não deve se sobrepor aos blocos usados na VPC do recurso. Não escolha um bloco que a VPC de recursos usa para atribuir IPs aos recursos ou um bloco já definido nas tabelas de rotas da VPC de recursos. Para obter mais informações sobre como definir blocos CIDR apropriados, consulte [Blocos CIDR da VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html). 1. Escolha **Personalizar AZs**. 1. Selecione as mesmas AZs do recurso. 1. Para **Número de sub-redes públicas**, escolha **0**. 1. Em **VPC endpoints** (Endpoints de VPC), escolha **None** (Nenhum). 1. Escolha **Criar VPC**. ## Conceda permissões da VPC ao perfil de execução da função. Anexe [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) ao perfil de execução da função para permitir que ela se conecte às VPCs. **Para conceder permissões da VPC ao perfil de execução da função** 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. 1. Escolha o nome da sua função. 1. Escolher **configuração**. 1. Escolha **Permissões**. 1. Em **Nome do perfil**, escolha o perfil de execução. 1. Na seção **Políticas de permissões**, escolha **Adicionar permissões**. 1. Escolha **Anexar políticas** na lista suspensa. 1. Na caixa de pesquisa, insira `AWSLambdaVPCAccessExecutionRole`. 1. À esquerda do nome da política, marque a caixa de seleção. 1. Escolha **Adicionar permissões**. **Para anexar a função à Amazon VPC** 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. 1. Escolha o nome da sua função. 1. Escolha a guia **Configuração** e depois **VPC**. 1. Escolha **Editar**. 1. Em **VPC**, selecione a VPC. 1. Em **Sub-redes**, escolha as sub-redes. 1. Em **Grupos de segurança**, escolha o grupo de segurança padrão da VPC. 1. Escolha **Salvar**. ## Criar uma solicitação de conexão de emparelhamento da VPC Crie uma solicitação de conexão de emparelhamento da VPC da função da VPC (a VPC solicitante) para a VPC do recurso (a VPC aceitante). **Para solicitar uma conexão de emparelhamento da VPC da VPC da função** 1. Abra [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. No painel de navegação, escolha **Peering Connections** (Conexões de emparelhamento). 1. Selecione **Create Peering Connection** (Criar conexão de emparelhamento). 1. Em **ID da VPC (Solicitante)**, selecione a VPC da função. 1. Em **ID da conta**, insira o ID da conta do recurso. 1. Em **ID da VPC ID (Aceitante)**, insira a VPC do recurso. ## Preparar a conta do recurso Para criar a conexão de emparelhamento e preparar a VPC do recurso para usar a conexão, faça login na conta do recurso com um perfil que tenha as permissões listadas nos pré-requisitos. As etapas para fazer login podem ser diferentes com base em como a conta está protegida. Para obter mais informações sobre como fazer login na conta da AWS, consulte o [Guia do usuário de Início de Sessão da AWS](https://docs.aws.amazon.com//signin/latest/userguide/what-is-sign-in.html). Na conta do recurso, execute os procedimentos a seguir. **Para aceitar uma solicitação de conexão de emparelhamento da VPC** 1. Abra [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. No painel de navegação, escolha **Peering Connections** (Conexões de emparelhamento). 1. Selecione a conexão pendente de emparelhamento da VPC (o status é pending-acceptance). 1. Escolha **Ações**. 1. Na lista suspensa, escolha **Aceitar solicitação**. 1. Quando a confirmação for solicitada, escolha **Aceitar solicitação**. 1. Escolha **Modificar as tabelas de rotas agora** para adicionar uma rota à tabela de rotas principal da VPC para que você possa enviar e receber tráfego pela conexão de emparelhamento. Inspecione as tabelas de rotas da VPC do recurso. A rota gerada pela Amazon VPC pode não estabelecer conectividade, com base em como a VPC do recurso está configurada. Verifique se há conflitos entre a nova rota e a configuração existente da VPC. Para obter mais informações sobre solução de problemas, consulte [Solucionar problemas com a conexão de emparelhamento da VPC](https://docs.aws.amazon.com/vpc/latest/peering/troubleshoot-vpc-peering-connections.html) no *Guia de emparelhamento de VPC da Amazon Virtual Private Cloud*. **Para atualizar o grupo de segurança do recurso** 1. Abra [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. No painel de navegação, selecione **Grupos de segurança**. 1. Selecione o grupo de segurança do recurso. 1. Escolha **Ações**. 1. Na lista suspensa, escolha **Editar regras de entrada**. 1. Escolha **Adicionar regra**. 1. Para **Origem**, insira o ID do grupo de segurança o ID da conta da função, separados por uma barra inclinada (por exemplo, 111122223333/sg-1a2b3c4d). 1. Escolha **Editar regras de saída**. 1. Verifique se o tráfego de saída é restrito. As configurações de VPC padrão permitem todo o tráfego de saída. Se o tráfego de saída for restrito, continue para a próxima etapa. 1. Escolha **Adicionar regra**. 1. Para **Destino**, insira o ID do grupo de segurança o ID da conta da função, separados por uma barra inclinada (por exemplo, 111122223333/sg-1a2b3c4d). 1. Selecione **Salvar regras**. **Para habilitar a resolução de DNS para a conexão de emparelhamento** 1. Abra [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. No painel de navegação, escolha **Peering Connections** (Conexões de emparelhamento). 1. Selecione a conexão de emparelhamento. 1. Escolha **Ações**. 1. Escolha **Editar as configurações de DNS**. 1. Abaixo de **Resolução de DNS aceitante**, selecione **Permitir que a VPC solicitante resolva o DNS dos hosts da VPC aceitante para IP privado**. 1. Escolha **Salvar alterações**. ## Atualizar a configuração da VPC na conta da função Faça login na conta da função e atualize a configuração da VPC. **Para adicionar uma rota à conexão de emparelhamento da VPC** 1. Abra [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. No painel de navegação, escolha **Route tables**. 1. Marque a caixa de seleção próxima ao nome da tabela de rotas para a sub-rede que você associou à função. 1. Escolha **Ações**. 1. Escolha **Edit routes (Editar rotas)**. 1. Selecione **Adicionar rota**. 1. Em **Destino**, insira o bloco CIDR da VPC do recurso. 1. Em **Destino**, selecione a conexão de emparelhamento da VPC. 1. Escolha **Salvar alterações**. Para obter mais informações sobre as considerações que você pode encontrar ao atualizar as tabelas de rotas, consulte [Atualizar suas tabelas de rotas para uma conexão de emparelhamento da VPC](https://docs.aws.amazon.com//vpc/latest/peering/vpc-peering-routing.html). **Para atualizar o grupo de segurança da função do Lambda** 1. Abra [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. No painel de navegação, selecione **Grupos de segurança**. 1. Escolha **Ações**. 1. Escolha **Editar regras de entrada**. 1. Escolha **Adicionar regra**. 1. Para **Origem**, insira o ID do grupo de segurança o ID da conta do recurso, separados por uma barra inclinada (por exemplo, 111122223333/sg-1a2b3c4d). 1. Selecione **Salvar regras**. **Para habilitar a resolução de DNS para a conexão de emparelhamento** 1. Abra [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. No painel de navegação, escolha **Peering Connections** (Conexões de emparelhamento). 1. Selecione a conexão de emparelhamento. 1. Escolha **Ações**. 1. Escolha **Editar as configurações de DNS**. 1. Abaixo de **Resolução de DNS solicitante**, selecione **Permitir que a VPC aceitante resolva o DNS dos hosts da VPC solicitante para IP privado**. 1. Escolha **Salvar alterações**. ## Testar a função **Para criar um evento de teste e inspecionar a saída da função** 1. No painel **Origem do código**, escolha **Testar**. 1. Selecione **Criar novo evento**. 1. No painel **Event JSON**, substitua os valores padrão por uma entrada apropriada para a função do Lambda. 1. Escolha **Invoke (Invocar)**. 1. Na guia **Resultados da execução**, confirme se a **resposta** contém a saída esperada. Além disso, você pode checar os logs da função para verificar se os logs estão conforme o esperado. **Para visualizar os registros de invocação da sua função no CloudWatch Logs** 1. Escolha a guia **Monitor** (Monitorar). 1. Escolha **Visualizar logs do CloudWatch**. 1. Na guia **Fluxos de log**, escolha o fluxo de logs para a invocação da sua função. 1. Confirme se os logs estão conforme o esperado. # Habilitar o acesso à Internet para funções do Lambda conectadas à VPC Por padrão, as funções do Lambda são executadas em uma VPC gerenciada pelo Lambda que tem acesso à Internet. Para acessar recursos em uma VPC em sua conta, você pode adicionar uma configuração de VPC a uma função. A menos que a VPC tenha acesso à Internet, isso restringirá a função aos recursos dentro dessa VPC. Esta página explica como fornecer acesso à Internet às funções do Lambda conectadas à VPC. ## Ainda não tenho uma VPC ### Criar a VPC O **fluxo de trabalho Criar VPC** cria todos os recursos de VPC necessários para que uma função do Lambda acesse a Internet pública usando uma sub-rede privada, inclusive sub-redes, gateway NAT, gateway da Internet e entradas na tabela de rotas. **Como criar a VPC** 1. Abra o console da Amazon VPC, em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. No painel, escolha **Criar VPC**. 1. Em **Resources to create (Recursos a serem criados)**, escolha **VPC and more (VPC e mais)**. 1. **Configurar a VPC** 1. Em **Name tag auto-generation** (Geração automática de tags de nome), insira um nome para a VPC. 1. Em **Bloco CIDR IPv4**, é possível manter a sugestão padrão ou inserir o bloco CIDR exigido por sua aplicação ou rede. 1. Se a sua aplicação se comunica usando endereços IPv6, escolha **Bloco CIDR IPv6**, **Bloco CIDR IPv6 fornecido pela Amazon**. 1. **Configurar as sub-redes** 1. Em **Número de zonas de disponibilidade**, escolha **2**. Recomendamos pelo menos duas AZs para alta disponibilidade. 1. Em **Number of public subnets** (Número de sub-redes públicas), escolha **2**. 1. Em **Number of private subnets** (Número de sub-redes privadas), escolha **2**. 1. É possível manter o bloco CIDR padrão para a sub-rede pública ou, alternativamente, expandir **Personalizar blocos CIDR da sub-rede** e inserir um bloco CIDR. Para obter mais informações, consulte [Blocos CIDR de sub-rede](https://docs.aws.amazon.com/vpc/latest/userguide/subnet-sizing.html). 1. Em **Gateways NAT**, escolha **1 por zona de disponibilidade** para melhorar a resiliência. 1. Em **Gateway da Internet somente de saída**, escolha **Sim** se tiver optado por incluir um bloco CIDR IPv6. 1. Em **Endpoints da VPC**, mantenha o valor padrão (**Gateway do S3**). Não há custo para essa opção. Para obter mais informações, consulte [Tipos de endpoints da VPC para o Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/privatelink-interface-endpoints.html#types-of-vpc-endpoints-for-s3). 1. Em **Opções de DNS**, mantenha as configurações padrão. 1. Escolha **Criar VPC**. ### Configurar a função do Lambda **Como configurar uma VPC ao criar 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 opção **Criar função**. 1. Em **Basic information (Informações básicas)**, para **Function name (Nome da função)**, insira um nome para a função. 1. Expanda **Advanced settings (Configurações avançadas)**. 1. Selecione **Habilitar VPC** e, em seguida, escolha uma VPC. 1. (Opcional) Para permitir [tráfego IPv6 de saída](configuration-vpc.md#configuration-vpc-ipv6), selecione **Permitir tráfego IPv6 para sub-redes de pilha dupla**. 1. Em **Sub-redes**, selecione todas as sub-redes privadas. As sub-redes privadas podem acessar a Internet por meio do gateway NAT. Conectar uma função a uma sub-rede pública não permite que ela tenha acesso à Internet. **nota** Se você selecionou **Permitir tráfego IPv6 para sub-redes de pilha dupla**, todas as sub-redes selecionadas deverão ter um bloco CIDR IPv4 e um bloco CIDR IPv6. 1. Em **Grupos de segurança**, selecione um grupo de segurança que permita tráfego de saída. 1. Escolha a opção **Criar função**. O Lambda criará automaticamente um perfil de execução com a política [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) gerenciada pela AWS. As permissões nessa política são necessárias apenas para criar interfaces de rede elástica para a configuração da VPC, mas não para invocar a função. Para aplicar permissões com privilégios mínimos, você pode remover a política **AWSLambdaVPCAccessExecutionRole** do seu perfil de execução após criar a função e a configuração da VPC. Para obter mais informações, consulte [Permissões obrigatórias do IAM](configuration-vpc.md#configuration-vpc-permissions). **Como configurar uma VPC para uma função existente** Para adicionar uma configuração de VPC a uma função existente, o perfil de execução da função precisa ter [permissão para criar e gerenciar interfaces de rede elástica](configuration-vpc.md#configuration-vpc-permissions). A política [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) gerenciada pela AWS inclui as permissões necessárias. Para aplicar permissões com privilégios mínimos, você pode remover a política **AWSLambdaVPCAccessExecutionRole** do seu perfil de execução após criar a configuração da VPC. 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 a guia **Configuração** e depois **VPC**. 1. Em **VPC**, selecione **Edit (Editar)**. 1. Selecionar a VPC. 1. (Opcional) Para permitir [tráfego IPv6 de saída](configuration-vpc.md#configuration-vpc-ipv6), selecione **Permitir tráfego IPv6 para sub-redes de pilha dupla**. 1. Em **Sub-redes**, selecione todas as sub-redes privadas. As sub-redes privadas podem acessar a Internet por meio do gateway NAT. Conectar uma função a uma sub-rede pública não permite que ela tenha acesso à Internet. **nota** Se você selecionou **Permitir tráfego IPv6 para sub-redes de pilha dupla**, todas as sub-redes selecionadas deverão ter um bloco CIDR IPv4 e um bloco CIDR IPv6. 1. Em **Grupos de segurança**, selecione um grupo de segurança que permita tráfego de saída. 1. Escolha **Salvar**. ### Testar a função Use o seguinte exemplo de código para confirmar se a sua função conectada à VPC pode acessar a Internet pública. Se for bem-sucedido, o código retornará um código de status `200`. Se não for bem-sucedido, o tempo-limite da função esgotará. ------ #### [ Node.js ] 1. No painel **Código-fonte** no console do Lambda, cole o código a seguir no arquivo **index.mjs**. A função faz uma solicitação HTTP GET para um endpoint público e retorna o código de resposta HTTP para testar se a função tem acesso à Internet pública. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/code-source-nodejs.png) **Example – Solicitação HTTP com async/await** ``` const url = "https://aws.amazon.com/"; export const handler = async(event) => { try { const res = await fetch(url); console.info("status", res.status); return res.status; } catch (e) { console.error(e); return 500; } }; ``` 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) 1. Selecione a guia **Testar**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/test-tab.png) 1. Escolha **Testar**. 1. A função retorna um código de status `200`. Isso significa que a função tem acesso de saída à Internet. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/test-successful-200.png) Se a função não conseguir acessar a Internet pública, você receberá uma mensagem de erro como esta: ``` { "errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds" } ``` ------ #### [ Python ] 1. No painel **Código-fonte** no console do Lambda, cole o código a seguir no arquivo **lambda\$1function.py**. A função faz uma solicitação HTTP GET para um endpoint público e retorna o código de resposta HTTP para testar se a função tem acesso à Internet pública. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/code-source-python.png) ``` import urllib.request def lambda_handler(event, context): try: response = urllib.request.urlopen('https://aws.amazon.com') status_code = response.getcode() print('Response Code:', status_code) return status_code except Exception as e: print('Error:', e) raise e ``` 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) 1. Selecione a guia **Testar**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/test-tab.png) 1. Escolha **Testar**. 1. A função retorna um código de status `200`. Isso significa que a função tem acesso de saída à Internet. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/test-successful-200.png) Se a função não conseguir acessar a Internet pública, você receberá uma mensagem de erro como esta: ``` { "errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds" } ``` ------ ## Já tenho uma VPC Se você já tiver uma VPC, mas precisar configurar o acesso público à Internet para uma função do Lambda, siga estas etapas. Este procedimento pressupõe que a VPC tenha pelo menos duas sub-redes. Se você não tiver duas sub-redes, consulte [Criar uma sub-rede](https://docs.aws.amazon.com/vpc/latest/userguide/create-subnets.html) no *Guia do usuário da Amazon VPC*. ### Verifique a configuração da tabela de rotas 1. Abra o console da Amazon VPC, em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. Escolha o **ID da VPC**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/vpc-id.png) 1. Role para baixo até a seção **Mapa de recursos**. Anote os mapeamentos da tabela de rotas. Abra cada tabela de rotas mapeada para uma sub-rede. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/route-table-associations.png) 1. Role para baixo até a guia **Rotas**. Revise as rotas para determinar se a VPC tem ambas as tabelas de rotas a seguir. É necessário atender a cada um desses requisitos com uma tabela de rotas separada. + O tráfego vinculado à Internet (`0.0.0.0/0` para IPv4, `::/0` para IPv6) é roteado para um gateway da Internet (`igw-xxxxxxxxxx`). Isso significa que a sub-rede associada à tabela de rotas é uma sub-rede pública. **nota** Se sua sub-rede não tiver um bloco CIDR IPv6, você verá somente a rota IPv4 (`0.0.0.0/0`). **Example tabela de rotas de sub-rede pública** ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/routes-public.png) + O tráfego vinculado à Internet para IPv4 (`0.0.0.0/0`) é roteado para um gateway NAT (`nat-xxxxxxxxxx`) associado a uma sub-rede pública. Isso significa que a sub-rede é uma sub-rede privada capaz de acessar a Internet por meio do gateway NAT. **nota** Se a sub-rede tiver um bloco CIDR IPv6, a tabela de rotas também deverá rotear o tráfego IPv6 direcionado à Internet (`::/0`) para um gateway da Internet somente de saída (`eigw-xxxxxxxxxx`). Se sua sub-rede não tiver um bloco CIDR IPv6, você verá somente a rota IPv4 (`0.0.0.0/0`). **Example tabela de rotas de sub-rede privada** ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/routes-private.png) 1. Repita a etapa anterior até ter revisado cada tabela de rotas associada a uma sub-rede em sua VPC e confirmar que tem uma tabela de rotas com um gateway da Internet e uma tabela de rotas com um gateway NAT. Se você não tiver duas tabelas de rotas, uma com uma rota para um gateway da Internet e outra com uma rota para um gateway NAT, siga estas etapas a fim de criar os recursos e as entradas da tabela de rotas ausentes. ### Crie uma tabela de rotas Siga estas etapas para criar uma tabela de rotas e associá-la a uma sub-rede. **Para criar uma tabela de rotas personalizada usando o console da Amazon VPC** 1. Abra o console da Amazon VPC em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. No painel de navegação, escolha **Route tables**. 1. Escolha **Create Route Table (Criar tabela de rotas)**. 1. (Opcional) Em **Name** (Nome), insira um nome para a tabela de rotas. 1. Em **VPC**, escolha sua VPC. 1. (Opcional) Para adicionar uma etiqueta, escolha **Add new tag** (Adicionar nova etiqueta) e insira a chave e o valor da etiqueta. 1. Escolha **Create Route Table (Criar tabela de rotas)**. 1. Na guia **Subnet Associations** (Associações da sub-rede) selecione **Edit subnet associations** (Editar associações da sub-rede). ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/route-table-subnet.png) 1. Marque a caixa de seleção para a sub-rede associada à tabela de rotas. 1. Selecione **Salvar associações**. ### Criar um gateway da Internet Siga estas etapas para criar um gateway da Internet, anexá-lo à sua VPC e adicioná-lo à tabela de rotas da sua sub-rede pública. **Para criar um gateway da Internet** 1. Abra o console da Amazon VPC em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. No painel de navegação, escolha **Internet gateways** (Gateways da Internet). 1. Escolha **Criar gateway da Internet**. 1. (Opcional) Insira um nome para o gateway da Internet. 1. (Opcional) Para adicionar uma tag, escolha **Add new tag** (Adicionar nova tag) e insira a chave e o valor da tag. 1. Escolha **Criar gateway da Internet**. 1. Escolha **Anexar a uma VPC** no banner na parte superior da tela, selecione uma VPC disponível e escolha **Anexar gateway da Internet**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/igw-attach-vpc.png) 1. Escolha o **ID da VPC**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/igw-subnet-1.png) 1. Escolha o **ID da VPC** novamente para abrir a página de detalhes da VPC. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/igw-your-vpcs.png) 1. Role para baixo até a seção **Mapa de recursos** e escolha uma sub-rede. Os detalhes sobre a sub-rede são exibidos em uma nova guia. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/vpc-subnets.png) 1. Escolha o link em **Tabela de rotas**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/subnet-route-table.png) 1. Escolha o **ID da tabela de rotas** para abrir a respectiva página de detalhes da tabela de rotas. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/route-table-id.png) 1. Em **Rotas**, escolha **Editar rotas**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/edit-routes.png) 1. Escolha **Adicionar rota** e, em seguida, insira `0.0.0.0/0` na caixa **Destino**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/create-route-1.png) 1. Em **Destino**, selecione **Gateway da Internet** e, em seguida, escolha o gateway da Internet que você criou anteriormente. Se a sub-rede tiver um bloco CIDR IPv6, você também deverá adicionar uma rota para `::/0` ao mesmo gateway da Internet. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/create-route-2.png) 1. Escolha **Salvar alterações**. ### Criar um gateway NAT Siga estas etapas para criar um gateway NAT, associá-lo a uma sub-rede pública e adicioná-lo à tabela de rotas da sua sub-rede privada. **Para criar um gateway NAT e associá-lo a uma sub-rede pública** 1. No painel de navegação, escolha **Gateways NAT**. 1. Escolha **Criar um gateway NAT**. 1. (Opcional) Insira um nome para o gateway NAT. 1. Em **Sub-rede**, selecione uma sub-rede pública na sua VPC. (Uma sub-rede pública é uma sub-rede que tem uma rota direta para um gateway da Internet em sua tabela de rotas.) **nota** Os gateways NAT estão associados a uma sub-rede pública, mas a entrada da tabela de rotas está na sub-rede privada. 1. Em **ID de alocação de IP elástico**, selecione um endereço IP elástico ou escolha **Alocar IP elástico**. 1. Escolha **Criar um gateway NAT**. **Para adicionar uma rota ao gateway NAT na tabela de rotas da sub-rede privada** 1. No painel de navegação, escolha **Sub-redes**. 1. Selecione uma sub-rede privada em sua VPC. (Uma sub-rede privada é uma sub-rede que não tem uma rota direta para um gateway da Internet em sua tabela de rotas.) 1. Escolha o link em **Tabela de rotas**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/subnet-route-table.png) 1. Escolha o **ID da tabela de rotas** para abrir a respectiva página de detalhes da tabela de rotas. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/route-table-id.png) 1. Role para baixo e escolha a guia **Rotas** e **Editar rotas** ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/route-table-edit-routes.png) 1. Escolha **Adicionar rota** e, em seguida, insira `0.0.0.0/0` na caixa **Destino**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/create-route-1.png) 1. Em **Destino**, selecione **Gateway NAT** e, em seguida, escolha o gateway NAT que você criou anteriormente. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/create-route-nat.png) 1. Escolha **Salvar alterações**. ### Criar um gateway da Internet somente de saída (somente IPv6) Siga estas etapas para criar um gateway da Internet somente de saída e adicioná-lo à tabela de rotas da sua sub-rede privada. **Como criar um gateway da Internet somente de saída para a VPC** 1. No painel de navegação, escolha **Gateways da Internet somente de saída**. 1. Escolha **Criar um Gateway da Internet somente de saída**. 1. (Opcional) Insira um nome. 1. Selecione a VPC para a qual será criado um gateway de Internet somente de saída. 1. Escolha **Criar um Gateway da Internet somente de saída**. 1. Escolha o link em **ID da VPC anexada**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/eigw-details.png) 1. Escolha o link em **ID da VPC** para abrir a página de detalhes da VPC. 1. Role para baixo até a seção **Mapa de recursos** e escolha uma sub-rede privada. (Uma sub-rede privada é uma sub-rede que não tem uma rota direta para um gateway da Internet em sua tabela de rotas.) Os detalhes sobre a sub-rede são exibidos em uma nova guia. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/vpc-subnet-private.png) 1. Escolha o link em **Tabela de rotas**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/private-subnet-route-table.png) 1. Escolha o **ID da tabela de rotas** para abrir a respectiva página de detalhes da tabela de rotas. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/route-table-id.png) 1. Em **Rotas**, escolha **Editar rotas**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/edit-routes.png) 1. Escolha **Adicionar rota** e, em seguida, insira `::/0` na caixa **Destino**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/create-route-1.png) 1. Em **Destino**, selecione **Gateway da Internet somente de saída** e, em seguida, escolha o gateway que você criou anteriormente. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/eigw-route.png) 1. Escolha **Salvar alterações**. ### Configurar a função do Lambda **Como configurar uma VPC ao criar 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 opção **Criar função**. 1. Em **Basic information (Informações básicas)**, para **Function name (Nome da função)**, insira um nome para a função. 1. Expanda **Advanced settings (Configurações avançadas)**. 1. Selecione **Habilitar VPC** e, em seguida, escolha uma VPC. 1. (Opcional) Para permitir [tráfego IPv6 de saída](configuration-vpc.md#configuration-vpc-ipv6), selecione **Permitir tráfego IPv6 para sub-redes de pilha dupla**. 1. Em **Sub-redes**, selecione todas as sub-redes privadas. As sub-redes privadas podem acessar a Internet por meio do gateway NAT. Conectar uma função a uma sub-rede pública não permite que ela tenha acesso à Internet. **nota** Se você selecionou **Permitir tráfego IPv6 para sub-redes de pilha dupla**, todas as sub-redes selecionadas deverão ter um bloco CIDR IPv4 e um bloco CIDR IPv6. 1. Em **Grupos de segurança**, selecione um grupo de segurança que permita tráfego de saída. 1. Escolha a opção **Criar função**. O Lambda criará automaticamente um perfil de execução com a política [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) gerenciada pela AWS. As permissões nessa política são necessárias apenas para criar interfaces de rede elástica para a configuração da VPC, mas não para invocar a função. Para aplicar permissões com privilégios mínimos, você pode remover a política **AWSLambdaVPCAccessExecutionRole** do seu perfil de execução após criar a função e a configuração da VPC. Para obter mais informações, consulte [Permissões obrigatórias do IAM](configuration-vpc.md#configuration-vpc-permissions). **Como configurar uma VPC para uma função existente** Para adicionar uma configuração de VPC a uma função existente, o perfil de execução da função precisa ter [permissão para criar e gerenciar interfaces de rede elástica](configuration-vpc.md#configuration-vpc-permissions). A política [AWSLambdaVPCAccessExecutionRole](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSLambdaVPCAccessExecutionRole.html) gerenciada pela AWS inclui as permissões necessárias. Para aplicar permissões com privilégios mínimos, você pode remover a política **AWSLambdaVPCAccessExecutionRole** do seu perfil de execução após criar a configuração da VPC. 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 a guia **Configuração** e depois **VPC**. 1. Em **VPC**, selecione **Edit (Editar)**. 1. Selecionar a VPC. 1. (Opcional) Para permitir [tráfego IPv6 de saída](configuration-vpc.md#configuration-vpc-ipv6), selecione **Permitir tráfego IPv6 para sub-redes de pilha dupla**. 1. Em **Sub-redes**, selecione todas as sub-redes privadas. As sub-redes privadas podem acessar a Internet por meio do gateway NAT. Conectar uma função a uma sub-rede pública não permite que ela tenha acesso à Internet. **nota** Se você selecionou **Permitir tráfego IPv6 para sub-redes de pilha dupla**, todas as sub-redes selecionadas deverão ter um bloco CIDR IPv4 e um bloco CIDR IPv6. 1. Em **Grupos de segurança**, selecione um grupo de segurança que permita tráfego de saída. 1. Escolha **Salvar**. ### Testar a função Use o seguinte exemplo de código para confirmar se a sua função conectada à VPC pode acessar a Internet pública. Se for bem-sucedido, o código retornará um código de status `200`. Se não for bem-sucedido, o tempo-limite da função esgotará. ------ #### [ Node.js ] 1. No painel **Código-fonte** no console do Lambda, cole o código a seguir no arquivo **index.mjs**. A função faz uma solicitação HTTP GET para um endpoint público e retorna o código de resposta HTTP para testar se a função tem acesso à Internet pública. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/code-source-nodejs.png) **Example – Solicitação HTTP com async/await** ``` const url = "https://aws.amazon.com/"; export const handler = async(event) => { try { const res = await fetch(url); console.info("status", res.status); return res.status; } catch (e) { console.error(e); return 500; } }; ``` 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) 1. Selecione a guia **Testar**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/test-tab.png) 1. Escolha **Testar**. 1. A função retorna um código de status `200`. Isso significa que a função tem acesso de saída à Internet. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/test-successful-200.png) Se a função não conseguir acessar a Internet pública, você receberá uma mensagem de erro como esta: ``` { "errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds" } ``` ------ #### [ Python ] 1. No painel **Código-fonte** no console do Lambda, cole o código a seguir no arquivo **lambda\$1function.py**. A função faz uma solicitação HTTP GET para um endpoint público e retorna o código de resposta HTTP para testar se a função tem acesso à Internet pública. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/code-source-python.png) ``` import urllib.request def lambda_handler(event, context): try: response = urllib.request.urlopen('https://aws.amazon.com') status_code = response.getcode() print('Response Code:', status_code) return status_code except Exception as e: print('Error:', e) raise e ``` 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) 1. Selecione a guia **Testar**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/test-tab.png) 1. Escolha **Testar**. 1. A função retorna um código de status `200`. Isso significa que a função tem acesso de saída à Internet. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/test-successful-200.png) Se a função não conseguir acessar a Internet pública, você receberá uma mensagem de erro como esta: ``` { "errorMessage": "2024-04-11T17:22:20.857Z abe12jlc-640a-8157-0249-9be825c2y110 Task timed out after 3.01 seconds" } ``` ------ # Como conectar endpoints da VPC de interface de entrada para o Lambda Se você usar a Amazon Virtual Private Cloud (Amazon VPC) para hospedar os recursos da AWS, poderá estabelecer uma conexão entre a VPC e o Lambda. Você pode usar essa conexão para invocar a função do Lambda sem passar pela Internet pública. Para estabelecer uma conexão privada entre a VPC e o Lambda, crie um [endpoint da VPC de interface](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html). Os endpoints de interface são desenvolvidos pelo [AWS PrivateLink](https://aws.amazon.com/privatelink), o que permite que você acesse APIs do Lambda de forma privada, sem um gateway da Internet, um dispositivo NAT, uma conexão VPN ou uma conexão do AWS Direct Connect. As instâncias na VPC não precisam de endereços IP públicos para a comunicação com APIs do Lambda. O tráfego de rede entre a VPC e o Lambda não sai da rede da AWS. Cada endpoint de interface é representado por uma ou mais [interfaces de rede elástica](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) nas sub-redes. Uma interface de rede fornece um endereço IP privado que serve como um ponto de entrada do tráfego para o Lambda. **Topics** + [ ## Considerações para endpoints de interface do Lambda ](#vpc-endpoint-considerations) + [ ## Criar um endpoint de interface para o Lambda ](#vpc-endpoint-create) + [ ## Criar uma política de endpoint de interface para o Lambda ](#vpc-endpoint-policy) ## Considerações para endpoints de interface do Lambda Antes de configurar um endpoint de interface para o Lambda, analise o tópico [Interface endpoint properties and limitations](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#vpce-interface-limitations) no *Manual do usuário da Amazon VPC*. É possível chamar qualquer uma das operações de API do Lambda pela VPC. Por exemplo, você pode invocar a função do Lambda chamando a API `Invoke` de dentro da VPC. Para obter a lista completa de APIs do Lambda, consulte [Ações](https://docs.aws.amazon.com/lambda/latest/dg/API_Operations.html) na Referência da API do Lambda. `use1-az3` é uma região de capacidade limitada para funções da VPC do Lambda. Não se deve usar sub-redes nessa zona de disponibilidade com funções do Lambda, pois isso pode resultar em redução da redundância da zona em caso de interrupção. ### Keep-alive para conexões persistentes O Lambda limpa conexões ociosas ao longo do tempo, portanto, é necessário usar uma diretiva de keep-alive para manter conexões persistentes. 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) no *Guia do desenvolvedor do AWS SDK para JavaScript*. ### Considerações sobre faturamento Não há custo adicional para acessar uma função do Lambda por meio de um endpoint de interface. Para obter mais informações sobre o preço do Lambda, consulte [Preço do AWS Lambda](https://aws.amazon.com/lambda/pricing/). O preço padrão para o AWS PrivateLink aplica-se a endpoints de interface para o Lambda. Sua conta da AWS é cobrada por cada hora que um endpoint de interface é provisionado em cada zona de disponibilidade e pelos dados processados por meio do endpoint de interface. Para obter mais informações sobre preço do endpoint de interface, consulte [Preço do AWS PrivateLink](https://aws.amazon.com/privatelink/pricing/). ### Considerações sobre emparelhamento de VPC É possível conectar outras VPCs à VPC endpoints de interface usando o[Emparelhamento de VPC](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html). O emparelhamento de VPC é uma conexão de rede entre duas VPCs. É possível estabelecer uma conexão de emparelhamento entre suas próprias duas VPCs ou com uma VPC de outra conta da AWS. As VPCs também podem estar em duas regiões da AWS diferentes. O tráfego entre VPCs emparelhadas permanece na rede da AWS e não passa pela Internet pública. Depois que as VPCs estiverem emparelhadas, recursos como instâncias do Amazon Elastic Compute Cloud (Amazon EC2), instâncias do Amazon Relational Database Service (Amazon RDS) ou funções do Lambda habilitadas para VPC em ambas as VPCs podem acessar a API do Lambda por meio de endpoints de interface criados em uma das VPCs. ## Criar um endpoint de interface para o Lambda Você pode criar um endpoint de interface para o Lambda usando o console da Amazon VPC ou aAWS Command Line Interface(AWS CLI). Para mais informações, consulte [Criar um endpoint de interface](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#create-interface-endpoint) no *Guia do usuário da Amazon VPC*. **Para criar um endpoint de interface para o Lambda (console)** 1. Abra a [página Endpoints](https://console.aws.amazon.com/vpc/home?#Endpoints) no console da Amazon VPC. 1. Escolha **Criar Endpoint**. 1. Em **Categoria de serviço**, verifique se a opção **Serviços da AWS** está selecionada. 1. Em **Service Name (Nome do serviço)**, selecione **com.amazonaws.*região*.lambda**. Verifique se o **Type (Tipo)** é **Interface**. 1. Escolher uma VPC e sub-redes 1. Para habilitar o DNS privado para o endpoint de interface, marque a caixa de seleção **Enable DNS Name** (Habilitar nome de DNS). Recomendamos que você habilite nomes DNS privados para seus endpoints da VPC para Serviços da AWS. Isso garante que as solicitações que usam os endpoints de serviço público, como solicitações feitas por meio de um AWS SDK, cheguem ao seu endpoint da VPC. 1. Em **Security group (Grupo de segurança)**, selecione um ou mais grupos de segurança. 1. Escolha **Criar endpoint**. Para usar a opção de DNS privado, defina `enableDnsHostnames` e `enableDnsSupportattributes` da VPC. Para obter mais informações, consulte [Viewing and updating DNS support for your VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-updating) no *Manual do usuário da Amazon VPC*. Se você habilitar o DNS privado para o endpoint de interface, poderá fazer solicitações de API para o Lambda usando seu nome DNS padrão para a região, por exemplo, `lambda.us-east-1.amazonaws.com`. Para obter mais endpoints de serviço, consulte [Endpoints e cotas de serviço](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) no *Referência geral da AWS*. Para mais informações, consulte [Acessar um serviço por um endpoint de interface](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#access-service-though-endpoint) no *Guia do usuário da Amazon VPC*. Para obter informações sobre como criar e configurar um endpoint usando o CloudFormation, consulte o recurso [AWS::EC2::VPCEndpoint](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html) no *Manual do usuário do AWS CloudFormation*. **Para criar um endpoint de interface para o Lambda (AWS CLI)** Use o comando [create-vpc-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/create-vpc-endpoint.html) e especifique o ID da VPC, o tipo de endpoint da VPC (interface), o nome do serviço, as sub-redes que usarão o endpoint e os grupos de segurança associados às interfaces de rede do endpoint. Por exemplo: ``` aws ec2 create-vpc-endpoint --vpc-id vpc-ec43eb89 --vpc-endpoint-type Interface --service-name com.amazonaws.us-east-1.lambda --subnet-id subnet-abababab --security-group-id sg-1a2b3c4d ``` ## Criar uma política de endpoint de interface para o Lambda Para controlar quem pode usar o endpoint de interface e quais funções do Lambda o usuário pode acessar, é possível anexar uma política ao endpoint. Essa política especifica as seguintes informações: + A entidade principal que pode realizar ações. + As ações que o principal pode executar. + Os recursos nos quais o principal pode executar ações. Para obter mais informações, consulte [Controlar o acesso a serviços com endpoints da VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html) no *Guia do Usuário do Amazon VPC*. **Exemplo: política de endpoint de interface para ações do Lambda** Veja a seguir um exemplo de uma política de endpoint para o Lambda. Quando anexada a um endpoint, essa política permite que o usuário `MyUser` invoque a função `my-function`. **nota** Você precisa incluir o ARN das funções qualificada e não qualificada no recurso. ``` { "Statement":[ { "Principal": { "AWS": "arn:aws:iam::111122223333:user/MyUser" }, "Effect":"Allow", "Action":[ "lambda:InvokeFunction" ], "Resource": [ "arn:aws:lambda:us-east-2:123456789012:function:my-function", "arn:aws:lambda:us-east-2:123456789012:function:my-function:*" ] } ] } ``` # Configurar o acesso ao sistema de arquivos para funções do Lambda É possível configurar uma função para montar um sistema de arquivos Amazon Elastic File System (Amazon EFS) em um diretório local. Com o Amazon EFS, o código da função pode acessar e modificar os recursos compartilhados de forma segura e com alta simultaneidade. ## Regiões com suporte O Amazon EFS para Lambda está disponível em todas as [regiões comerciais](https://docs.aws.amazon.com/general/latest/gr/glos-chap.html#region), exceto Ásia-Pacífico (Nova Zelândia), Ásia-Pacífico (Taipei), Ásia-Pacífico (Malásia), México (Central), Ásia-Pacífico (Tailândia) e Canadá Oeste (Calgary). **Topics** + [ ## Regiões com suporte ](#configuration-filesystem-supported-regions) + [ ## Função de execução e permissões de usuário ](#configuration-filesystem-permissions) + [ ## Configurar um sistema de arquivos e ponto de acesso ](#configuration-filesystem-setup) + [ ## Como conectar-se a um sistema de arquivos (console) ](#configuration-filesystem-config) ## Função de execução e permissões de usuário Se o sistema de arquivos não tiver uma política do AWS Identity and Access Management (IAM) configurada pelo usuário, o EFS usará uma política padrão, que concede acesso total a qualquer cliente que possa se conectar ao sistema de arquivos usando um destino de montagem do sistema de arquivos. Se o sistema de arquivos tiver uma política do IAM configurada pelo usuário, a função de execução da função precisa ter permissões `elasticfilesystem`. **Permissões da função de execução** + **elasticfilesystem:ClientMount** + **elasticfilesystem:ClientWrite (não obrigatório para conexões somente leitura)** Essas permissões estão incluídas na política gerenciada **AmazonElasticFileSystemClientReadWriteAccess**. Além disso, a função de execução deve ter as [permissões necessárias para conectar à VPC do sistema de arquivos](configuration-vpc.md#configuration-vpc-permissions). Quando você configura um sistema de arquivos, o Lambda usa as suas permissões para verificar os destinos de montagem. Para configurar uma função para se conectar a um sistema de arquivos, seu usuário precisa das permissões a seguir: **Permissões de usuário** + **elasticfilesystem:DescribeMountTargets** ## Configurar um sistema de arquivos e ponto de acesso Crie um sistema de arquivos no Amazon EFS com um destino de montagem em cada zona de disponibilidade à qual a função se conecta. Para performance e resiliência, use pelo menos duas zonas de disponibilidade. Por exemplo, em uma configuração simples, é possível ter uma VPC com duas sub-redes privadas em zonas de disponibilidade separadas. A função se conecta às duas sub-redes e um destino de montagem está disponível em cada uma delas. Verifique se o tráfego de NFS (porta 2049) é permitido pelos grupos de segurança usados pela função e pelos destinos de montagem. **nota** Ao criar um arquivo de sistemas, você escolhe um modo de performance que não pode ser alterado posteriormente. O modo **Uso geral** possui menor latência e o modo **Máx. E/S** oferece suporte a um throughput e IOPS máximo mais alto. Para obter ajuda na escolha, consulte [Performance do Amazon EFS](https://docs.aws.amazon.com/efs/latest/ug/performance.html) no *Manual do usuário do Amazon Elastic File System*. Um ponto de acesso conecta cada instância da função ao destino de montagem correto para a zona de disponibilidade à qual ele se conecta. Para obter a melhor performance, crie um ponto de acesso com um caminho não raiz e limite o número de arquivos criados em cada diretório. O exemplo a seguir cria um diretório chamado `my-function` no sistema de arquivos e define o ID do proprietário como 1001 com permissões de diretório padrão (755). **Example configuração do ponto de acesso** + **Nome** – `files` + **ID do usuário** – `1001` + **ID do grupo** – `1001` + **Caminho** – `/my-function` + **Permissões** – `755` + **ID de usuário do proprietário** – `1001` + **ID de usuário do grupo** – `1001` Quando uma função usa o ponto de acesso, ele recebe o ID de usuário 1001 e tem acesso total ao diretório. Para obter mais informações, consulte os seguintes tópicos no *Manual do usuário do Amazon Elastic File System*: + [Criar recursos para o Amazon EFS](https://docs.aws.amazon.com/efs/latest/ug/creating-using.html) + [Trabalhar com usuários, grupos e permissões](https://docs.aws.amazon.com/efs/latest/ug/accessing-fs-nfs-permissions.html) ## Como conectar-se a um sistema de arquivos (console) Uma função se conecta a um sistema de arquivos pela rede local em uma VPC. As sub-redes às quais a função se conecta podem ser as mesmas sub-redes que contêm pontos de montagem para o sistema e arquivos, ou sub-redes na mesma zona de disponibilidade que pode rotear o tráfego de NFS (porta 2049) para o sistema de arquivos. **nota** Se a função ainda não estiver conectada a uma VPC, consulte [Conceder acesso a funções do Lambda para recursos em uma Amazon VPC](configuration-vpc.md). **Como configurar o acesso ao sistema de arquivos** 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 **Files systems (Sistemas de arquivos)**. 1. Em **Sistema de arquivos**, escolha **Adicionar sistema de arquivos**. 1. Configure as seguintes propriedades: + **Sistema de arquivos do EFS**: o ponto de acesso de um sistema de arquivos na mesma VPC. + **Caminho de montagem local**: o local onde o sistema de arquivos está montado na função do Lambda, começando com `/mnt/`. **Preços** O Amazon EFS cobra pelo armazenamento e pelo throughput, com taxas que variam de acordo com a classe de armazenamento. Para obter mais detalhes, consulte .[Preço do Amazon EFS](https://aws.amazon.com/efs/pricing). O Lambda cobra pela transferência de dados entre VPCs. Isso se aplica somente se a VPC da função for emparelhada com outra VPC em um sistema de arquivos. As taxas são as mesmas para a transferência de dados do Amazon EC2 entre VPCs na mesma região. Para obter detalhes, consulte [Preço do Lambda](https://aws.amazon.com/lambda/pricing). # Criar um alias para uma função do Lambda É possível criar aliases para sua função do Lambda. Um alias do Lambda é um ponteiro para uma versão da função que pode ser atualizada. Os usuários da função podem acessar a versão da função usando o nome do recurso da Amazon (ARN) do alias. Ao implantar uma nova versão, é possível atualizar o alias para usar a nova versão ou dividir o tráfego entre duas versões. ------ #### [ Console ] **Para criar um alarme usando o console** 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 **Aliases** e, em seguida, escolha **Create alias (Criar alias)**. 1. Na página **Create alias (Criar alias)**, faça o seguinte: 1. Insira um **Name (Nome)** para o alias. 1. (Opcional) Insira uma **Description (Descrição)** do alias. 1. Em **Version (Versão)**, escolha uma versão da função para a qual você deseja que o alias indique. 1. (Opcional) Para configurar o roteamento no alias, expanda **Weighted alias (Alias ponderado)**. Para ter mais informações, consulte [Implemente implantações canárias do Lambda usando um alias ponderado](configuring-alias-routing.md). 1. Escolha **Salvar**. ------ #### [ AWS CLI ] Para criar um alias usando a AWS Command Line Interface (AWS CLI), use o comando [create-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-alias.html). ``` aws lambda create-alias \ --function-name my-function \ --name alias-name \ --function-version version-number \ --description " " ``` Para alterar um alias para apontar para uma nova versão da função, use o comando [update-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-alias.html). ``` aws lambda update-alias \ --function-name my-function \ --name alias-name \ --function-version version-number ``` Para excluir um alias, use o comando [delete-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/delete-alias.html). ``` aws lambda delete-alias \ --function-name my-function \ --name alias-name ``` Os comandos da AWS CLI nas etapas anteriores correspondem às seguintes operações de API do Lambda: + [CreateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_CreateAlias.html) + [UpdateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateAlias.html) + [DeleteAlias](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteAlias.html) ------ # Usar aliases do Lambda em políticas de permissões e origens de eventos Cada alias tem um ARN exclusivo. Um alias pode apontar somente para uma versão de função, e não para outro alias. O alias pode ser atualizado para apontar para uma nova versão da função. Fontes de eventos como Amazon Simple Storage Service (Amazon S3) invocam sua função do Lambda. Essas origens de evento mantêm um mapeamento que identifica a função a ser invocada quando ocorrem eventos. Se você especificar um alias da função do Lambda na configuração de mapeamento, não precisará atualizar o mapeamento quando a versão da função for alterada. Para ter mais informações, consulte [Como o Lambda processa registros de origens de eventos baseadas em fluxos e filas](invocation-eventsourcemapping.md). Em uma política de recursos, é possível conceder permissões para fontes de eventos para usar sua função do Lambda. Se um ARN de alias for especificado na política, não será necessário atualizar a política quando a versão da função for alterada. ## Políticas de recursos É possível usar uma [política baseada em recurso](access-control-resource-based.md) para conceder acesso a um serviço, recurso ou conta à sua função. O escopo dessa permissão depende se você a aplica a um alias, uma versão ou a toda a função. Por exemplo, se você usar um nome de alias (como `helloworld:PROD`), a permissão permite invocar a função `helloworld` usando o ARN do alias (`helloworld:PROD`). Se você tentar invocar a função sem um alias ou uma versão específica, receberá um erro de permissão. Esse erro de permissão ainda ocorrerá mesmo se você tentar invocar diretamente a versão da função associada ao alias. Por exemplo, o comando da AWS CLI a seguir concede permissões do Amazon S3 para invocar o alias PROD da função `helloworld` quando o Amazon S3 está agindo em nome de `amzn-s3-demo-bucket`. ``` aws lambda add-permission \ --function-name helloworld \ --qualifier PROD \ --statement-id 1 \ --principal s3.amazonaws.com \ --action lambda:InvokeFunction \ --source-arn arn:aws:s3:::amzn-s3-demo-bucket \ --source-account 123456789012 ``` Para obter mais informações sobre como usar nomes de recursos em políticas, consulte [Ajustar as seções de Recursos e Condições das políticas](lambda-api-permissions-ref.md). # Implemente implantações canárias do Lambda usando um alias ponderado É possível usar um alias ponderado para dividir o tráfego entre duas diferentes [versões](configuration-versions.md) da mesma função. Com essa abordagem, você pode testar novas versões de funções com uma pequena porcentagem de tráfego e reverter rapidamente, caso necessário. Esse processo é conhecido como [implantação canária](https://docs.aws.amazon.com/whitepapers/latest/overview-deployment-options/canary-deployments.html). Implantações canárias diferem de implantações azul/verde por exporem a nova versão a apenas uma parte das solicitações, em vez de alternar todo o tráfego de uma só vez. Você pode apontar um alias para um máximo de duas versões de função do Lambda. As versões devem atender aos seguintes critérios: + As duas versões devem ter a mesma [função de execução](lambda-intro-execution-role.md). + Ambas as versões devem ter a mesma configuração de [fila de mensagens mortas](invocation-async-retain-records.md#invocation-dlq) ou configuração de nenhuma fila de mensagens mortas. + Ambas as versões devem ser publicadas. O alias não pode apontar para `$LATEST`. **nota** O Lambda usa um modelo probabilístico simples para distribuir o tráfego entre as duas versões de função. Em níveis de tráfego baixos, você pode ver uma alta variação entre a porcentagem configurada e real de tráfego em cada versão. Se sua função usa simultaneidade provisionada, você pode evitar[Invocações de transbordamento](monitoring-metrics-types.md#invocation-metrics)configurando um número maior de instâncias de simultaneidade provisionadas durante o tempo em que o roteamento de alias está ativo. ## Criar um alias ponderado ------ #### [ Console ] **Para configurar o roteamento em um alias usando o console** **nota** Verifique se a função tem pelo menos duas versões publicadas. Para criar versões adicionais, siga as instruções em [Como criar versões de função](configuration-versions.md#configuration-versions-config). 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 **Aliases** e, em seguida, escolha **Create alias (Criar alias)**. 1. Na página **Create alias (Criar alias)**, faça o seguinte: 1. Insira um **Name (Nome)** para o alias. 1. (Opcional) Insira uma **Description (Descrição)** do alias. 1. Em **Version (Versão)**, escolha a primeira versão da função para a qual você deseja que o alias aponte. 1. Expanda **Weighted alias (Alias ponderado)**. 1. Em **Additional version (Versão adicional)**, escolha a segunda versão da função para a qual você deseja que o alias aponte. 1. Em **Weight (%) (Peso (%))**, insira um valor de peso para a função. *Peso* é a porcentagem do tráfego atribuído a essa versão quando o alias é invocado. A primeira versão recebe o peso residual. Por exemplo, se você especificar 10% para **Additional version (Versão adicional)**, a primeira versão receberá automaticamente a atribuição de 90 por cento. 1. Escolha **Salvar**. ------ #### [ AWS CLI ] Use os comandos [create-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/create-alias.html) e [update-alias](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/update-alias.html) AWS CLI para configurar os pesos do tráfego entre duas versões de uma função. Ao criar ou atualizar o alias, o peso do tráfego é especificado no parâmetro `routing-config`. O exemplo a seguir cria um alias de função do Lambda chamado **routing-alias** que aponta para a versão 1 da função. A versão 2 da função recebe 3 por cento do tráfego. Os 97 por cento do tráfego restantes são roteados para a versão 1. ``` aws lambda create-alias \ --name routing-alias \ --function-name my-function \ --function-version 1 \ --routing-config AdditionalVersionWeights={"2"=0.03} ``` Use o comando `update-alias` para aumentar a porcentagem de tráfego de entrada para a versão 2. No exemplo a seguir, o tráfego é aumentado para 5%. ``` aws lambda update-alias \ --name routing-alias \ --function-name my-function \ --routing-config AdditionalVersionWeights={"2"=0.05} ``` Para rotear todo o tráfego para a versão 2, use o comando `update-alias` para alterar a propriedade `function-version` para apontar o alias para a versão 2. O comando também redefine a configuração de roteamento. ``` aws lambda update-alias \ --name routing-alias \ --function-name my-function \ --function-version 2 \ --routing-config AdditionalVersionWeights={} ``` Os comandos da AWS CLI nas etapas anteriores correspondem às seguintes operações de API do Lambda: + [CreateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_CreateAlias.html) + [UpdateAlias](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateAlias.html) ------ ## Determinar qual versão foi invocada Ao configurar pesos de tráfego entre duas versões da função, há duas maneiras de determinar a versão da função do Lambda que foi chamada: + **CloudWatch Logs**: o Lambda emite automaticamente uma entrada de log `START` que contém o ID da versão invocada em cada invocação da função. Exemplo: `START RequestId: 1dh194d3759ed-4v8b-a7b4-1e541f60235f Version: 2` Para invocações de alias, o Lambda usa a dimensão `ExecutedVersion` para filtrar os dados de métrica pela versão invocada. Para obter mais informações, consulte [Exibição de métricas de funções do Lambda](monitoring-metrics-view.md). + **Carga de resposta (invocações síncronas)** – As respostas às invocações de função síncrona incluem um cabeçalho `x-amz-executed-version` para indicar qual versão de função foi invocada. ## Criar uma implantação contínua com aliases ponderados Use o AWS CodeDeploy e o AWS Serverless Application Model (AWS SAM) para criar uma implantação contínua que detecta automaticamente alterações no código da função, implanta uma nova versão da função e aumenta gradualmente a quantidade de tráfego que flui para essa nova versão. A quantidade de tráfego e a taxa de aumento são parâmetros que você pode configurar. Em uma implantação contínua, o AWS SAM executa estas tarefas: + Configura sua função do Lambda e cria um alias. A configuração de roteamento do alias ponderado é o recurso subjacente que implementa a implantação contínua. + Cria um aplicativo CodeDeploy e um grupo de implantação. O grupo de implantação gerencia a implantação contínua e a reversão, se necessário. + Detecta quando você cria uma nova versão da sua função do Lambda. + Aciona o CodeDeploy para iniciar a implantação da nova versão. ### Exemplo de modelo AWS SAM O exemplo a seguir mostra um [Modelo do AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html) para uma implantação contínua simples. ``` AWSTemplateFormatVersion : '2010-09-09' Transform: AWS::Serverless-2016-10-31 Description: A sample SAM template for deploying Lambda functions Resources: # Details about the myDateTimeFunction Lambda function myDateTimeFunction: Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html) Properties: Handler: myDateTimeFunction.handler Runtime: nodejs24.x # Creates an alias named "live" for the function, and automatically publishes when you update the function. AutoPublishAlias: live DeploymentPreference: # Specifies the deployment configuration Type: Linear10PercentEvery2Minutes ``` Este modelo define uma função do Lambda denominada `myDateTimeFunction` com as propriedades a seguir. **AutoPublishAlias ** A propriedade `AutoPublishAlias` cria um alias chamado `live`. Além disso, o framework AWS SAM detecta automaticamente quando você salva um código novo para a função. O framework publica uma nova versão da função e atualiza o alias do `live` para apontar para a nova versão. **DeploymentPreference** A propriedade `DeploymentPreference` determina a taxa na qual a aplicação do CodeDeploy muda o tráfego da versão original da função do Lambda para a nova versão. O valor `Linear10PercentEvery2Minutes` muda dez por cento adicionais do tráfego para a nova versão a cada dois minutos. Para obter uma lista das configurações de implantação predefinidas, consulte [Configurações de implantação](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-configurations.html). Para obter mais informações sobre como criar implantações contínuas com o CodeDeploy e o AWS SAM, consulte o seguinte: + [Tutorial: Implantar uma função do Lambda atualizada com o CodeDeploy e o AWS Serverless Application Model](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-lambda-sam.html) + [Implantação gradual de aplicações sem servidor com o AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/automating-updates-to-serverless-apps.html) # Gerenciar versões da função do Lambda É possível usar versões para gerenciar a implantação das suas funções. Por exemplo, você pode publicar uma nova versão de uma função para testes beta sem afetar os usuários da versão de produção estável. O Lambda cria uma nova versão da sua função sempre que você publicá-la. A nova versão é uma cópia da versão não publicada da função. A versão não publicada é denominada `$LATEST`. É importante ressaltar que sempre que você implanta seu código de função, você sobrescreve o código atual no `$LATEST`. Para salvar a iteração atual do `$LATEST`, crie uma nova versão da função. Se a `$LATEST` for idêntica a uma versão publicada anterior, você não poderá criar uma nova versão até implantar alterações na `$LATEST`. Essas alterações podem incluir atualizar o código ou modificar as definições de configuração de função. Depois de publicar uma versão da função, o código, o runtime, a arquitetura, a memória, as camadas e a maioria das outras definições de configuração da função são imutáveis. Isso significa que você não pode alterar essas configurações sem publicar uma nova versão `$LATEST`. Você pode configurar os seguintes itens para uma versão de função publicada: + [Acionadores](lambda-services.md#lambda-invocation-trigger) + [Destinos](invocation-async-retain-records.md#create-destination) + [Simultaneidade provisionada](provisioned-concurrency.md) + [Invocação assíncrona](invocation-async.md) + [Conexões e proxies de banco de dados](services-rds.md#rds-configuration) **nota** Ao usar os [controles de gerenciamento de runtime](runtimes-update.md#runtime-management-controls) com o modo **Automático**, a versão do runtime usada pela versão da função é atualizada automaticamente. Ao usar **Function update** (Atualização de função) ou o modo **Manual**, a versão de runtime não será atualizada. Para obter mais informações, consulte [Entender como o Lambda gerencia as atualizações de versão do runtime](runtimes-update.md). **Topics** + [ ## Como criar versões de função ](#configuration-versions-config) + [ ## Usar versões ](#versioning-versions-using) + [ ## Conceder permissões ](#versioning-permissions) ## Como criar versões de função O código e as configurações das funções somente podem ser alterados na versão não publicada de uma função. Quando você publica uma versão, o Lambda bloqueia o código e a maioria das configurações para manter uma experiência consistente para os usuários dessa versão. Você pode criar uma versão de função usando o console do Lambda. **Para criar uma nova versão de função** 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. 1. Escolha uma função e, em seguida, selecione a guia **Versões**. 1. Na página de configuração de versões, escolha **Publish new version (Publicar nova versão)**. 1. (Opcional) Insira uma descrição de versão. 1. Selecione **Publish**. Como alternativa, é possível publicar uma versão de uma função usando a operação de API [PublishVersion](https://docs.aws.amazon.com/lambda/latest/api/API_PublishVersion.html). O comando da AWS CLI a seguir publica uma nova versão de uma função. A resposta retorna as informações de configuração sobe a versão da função, incluindo o número da versão e o ARN da função com o sufixo da versão. ``` aws lambda publish-version --function-name my-function ``` A seguinte saída deverá ser mostrada: ``` { "FunctionName": "my-function", "FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function:1", "Version": "1", "Role": "arn:aws:iam::123456789012:role/lambda-role", "Handler": "function.handler", "Runtime": "nodejs24.x", ... } ``` **nota** O Lambda atribui números de sequência monotônicos crescentes para o controle de versionamento. O Lambda nunca reutiliza números de versão, mesmo após você excluir e recriar uma função. ## Usar versões É possível fazer referência à sua função do Lambda usando um ARN qualificado ou um ARN não qualificado. + **ARN qualificado**: o ARN da função com um sufixo da versão. O exemplo a seguir faz referência à versão 42 da função `helloworld`. ``` arn:aws:lambda:aws-region:acct-id:function:helloworld:42 ``` + **ARN não qualificado**: o ARN da função sem um sufixo da versão. ``` arn:aws:lambda:aws-region:acct-id:function:helloworld ``` É possível usar um ARN qualificado ou não qualificado em todas as operações de API relevantes. No entanto, não é possível usar um ARN não qualificado para criar um alias. Se você decidir não publicar versões de funções, será possível invocar a função usando o ARN qualificado ou não qualificado no [mapeamento da origem do evento](invocation-eventsourcemapping.md). Quando você invoca uma função usando um ARN não qualificado, o Lambda invoca implicitamente a `$LATEST`. O ARN qualificado para cada versão de função do Lambda é exclusivo. Depois de publicar uma versão, não é possível alterar o ARN ou o código da função. O Lambda só publica uma nova versão da função se o código nunca tiver sido publicado ou se o código foi alterado em relação à última versão publicada. Se não houver nenhuma alteração, a versão da função permanecerá na última versão publicada. Quando você publica uma versão, o Lambda cria um snapshot imutável do código e da configuração da sua função. Nem todas as alterações de configuração acionam a publicação de uma nova versão. As seguintes alterações de configuração qualificam uma função para a publicação de uma versão: + Código da função + Variáveis de ambiente + Runtime + Manipulador + Camadas + Tamanho da memória + Tempo limite + Configuração de VPC + Configuração de fila de mensagens não entregues (DLQ) + perfil do IAM + Descrição + Arquitetura (x86\$164 ou arm64) + Tamanho do armazenamento efêmero + Tipo de pacote + Configuração de registro em log + Configuração do sistema de arquivos + SnapStart + Configuração de rastreamento Configurações operacionais, como [simultaneidade reservada](configuration-concurrency.md), não acionam a publicação de uma nova versão quando alteradas. ## Conceder permissões É possível usar uma [política baseada em recurso](access-control-resource-based.md) ou uma [política baseada em identidade](access-control-identity-based.md) para conceder acesso à sua função. O escopo da permissão depende se você aplicar a política a uma função ou a uma versão de uma função. Para obter mais informações sobre nomes de recursos de função em políticas, consulte [Ajustar as seções de Recursos e Condições das políticas](lambda-api-permissions-ref.md). É possível simplificar o gerenciamento de fontes de eventos e políticas do AWS Identity and Access Management (IAM) utilizando aliases de funções. Para obter mais informações, consulte [Criar um alias para uma função do Lambda](configuration-aliases.md). # Utilizar etiquetas em funções do Lambda Você pode marcar funções para organizar e gerenciar os recursos. Tags são pares de chave-valor de formato livre associados aos recursos compatíveis com todos os Serviços da AWS. Para obter mais informações sobre casos de uso de tags, consulte [Common tagging strategies](https://docs.aws.amazon.com//tag-editor/latest/userguide/best-practices-and-strats.html#tag-strategies) no *Guia do editor de tags e recursos de marcação da AWS*. As tags se aplicam no nível da função, não em versões ou aliases. Etiquetas não fazem parte da configuração específica da versão da qual o AWS Lambda cria um snapshot quando você publica uma versão. É possível usar a API do Lambda para visualizar e atualizar tags. Você também pode visualizar e atualizar tags enquanto gerencia uma função específica no console do Lambda. **Topics** + [ ## Permissões necessárias para trabalhar com tags ](#fxn-tags-required-permissions) + [ ## Uso de tags usando o console do Lambda ](#using-tags-with-the-console) + [ ## Uso de tags com a AWS CLI ](#configuration-tags-cli) ## Permissões necessárias para trabalhar com tags Para permitir que uma identidade do AWS Identity and Access Management (IAM) (usuário, grupo ou perfil) leia ou defina tags em um recurso, conceda a ela as permissões correspondentes: + **lambda:ListTags**: quando um recurso tiver tags, conceda essa permissão a qualquer usuário que precise chamar `ListTags` nele. Para funções marcadas, essa permissão também será necessária para `GetFunction`. + **lambda:TagResource**: conceda essa permissão a qualquer pessoa que precise chamar `TagResource` ou executar uma tag na criação. Opcionalmente, considere conceder também a permissão **lambda:UntagResource** para permitir chamadas `UntagResource` ao recurso. Para obter mais informações, consulte [Políticas do IAM baseadas em identidade para o Lambda](access-control-identity-based.md). ## Uso de tags usando o console do Lambda Você pode usar o console do Lambda para criar funções que têm etiquetas, adicionar etiquetas a funções existentes e filtrar funções pelas etiquetas adicionadas. **Para adicionar etiquetas ao criar 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 opção **Criar função**. 1. Escolha **Author from scratch** (Criar do zero) ou **Container image** (Imagem de contêiner). 1. Em **Informações básicas**, configure a função. Para obter mais informações sobre a configuração de funções, consulte [Configurar funções do AWS Lambda](lambda-functions.md). 1. Expanda **Advanced settings** (Configurações avançadas) e selecione **Enable tags** (Habilitar etiquetas). 1. Escolha **Add new tag** (Adicionar nova etiqueta) e insira **Key** (Chave) e uma opção de **Value** (Valor) opcional. Para adicionar mais tags, repita esta etapa. 1. Escolha a opção **Criar função**. **Para adicionar etiquetas a uma função existente** 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. 1. Escolha o nome de uma função. 1. Escolha **Configuration** (Configuração) e depois **Tags** (Etiquetas). 1. Em **Tags**, selecione **Gerenciar tags**. 1. Escolha **Add new tag** (Adicionar nova etiqueta) e insira **Key** (Chave) e uma opção de **Value** (Valor) opcional. Para adicionar mais tags, repita esta etapa. 1. Escolha **Salvar**. **Como filtrar funções com tags** 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. 1. Escolha a barra de pesquisa para ver uma lista de propriedades de funções e chaves de tags. 1. Selecione uma chave de tag para ver uma lista de valores que estão sendo usados na região da AWS atual. 1. Selecione **Usar: “tag-name”** para ver todas funções marcadas com essa chave, ou escolha um **operador** para filtrar ainda mais por valor. 1. Selecione o valor da tag para filtrar por uma combinação de chave e valor da tag. A barra de pesquisa também oferece suporte para a pesquisa de chaves de tag. Insira `tag` para ver somente uma lista de chaves de tag ou insira o nome de uma chave para encontrá-la na lista. ## Uso de tags com a AWS CLI Você pode adicionar e remover tags em recursos existentes do Lambda, incluindo funções, com a API do Lambda. Você também pode adicionar tags ao criar uma função, o que permite manter um recurso marcado durante todo o ciclo de vida. ### Atualização de tags usando as APIs de tag do Lambda Você pode adicionar e remover tags dos recursos compatíveis do Lambda por meio das operações da API [TagResource](https://docs.aws.amazon.com/lambda/latest/api/API_TagResource.html) e [UntagResource](https://docs.aws.amazon.com/lambda/latest/api/API_UntagResource.html). Você também pode chamar essas operações usando a AWS CLI. Para adicionar tags a um recurso existente, use o comando `tag-resource`. Este exemplo adiciona duas tags, uma com a chave *Department* e outra com a chave *CostCenter*. ``` aws lambda tag-resource \ --resource arn:aws:lambda:us-east-2:123456789012:resource-type:my-resource \ --tags Department=Marketing,CostCenter=1234ABCD ``` Para remover tags, use o comando `untag-resource`. Este exemplo remove a tag com a chave *Department*. ``` aws lambda untag-resource --resource arn:aws:lambda:us-east-1:123456789012:resource-type:resource-identifier \ --tag-keys Department ``` ### Adição de tags ao criar uma função Para criar uma função do Lambda com tags, use a operação da API [CreateFunction](https://docs.aws.amazon.com//lambda/latest/api/API_CreateFunction.html). Especifique o parâmetro `Tags`. Você pode chamar essa operação com o comando `create-function` da CLI e a opção --tags. Antes de usar o parâmetro tags com `CreateFunction`, certifique-se de que seu perfil tenha permissão para marcar recursos junto com as permissões usuais necessárias para essa operação. Para obter mais informações sobre permissões para marcação, consulte [Permissões necessárias para trabalhar com tags](#fxn-tags-required-permissions). Este exemplo adiciona duas tags, uma com a chave *Department* e outra com a chave *CostCenter*. ``` aws lambda create-function --function-name my-function --handler index.js --runtime nodejs24.x \ --role arn:aws:iam::123456789012:role/lambda-role \ --tags Department=Marketing,CostCenter=1234ABCD ``` ### Visualização de tags em uma função Para visualizar as tags que são aplicadas à um recurso específico do Lambda, use a operação da API `ListTags`. Para obter mais informações, consulte [ListTags](https://docs.aws.amazon.com/lambda/latest/api/API_ListTags.html). Você pode chamar essa operação com o comando `list-tags` da AWS CLI fornecendo um ARN (nome do recurso da Amazon). ``` aws lambda list-tags --resource arn:aws:lambda:us-east-1:123456789012:resource-type:resource-identifier ``` Você pode visualizar as tags que são aplicadas a um recurso específico com a operação da API [GetFunction](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html). Funcionalidades comparáveis não estão disponíveis para outros tipos de recursos. Você pode chamar essa operação usando o comando `get-function` da CLI: ``` aws lambda get-function --function-name my-function ``` ### Filtragem de recursos por tag Você pode usar a operação de API [GetResources](https://docs.aws.amazon.com/resourcegroupstagging/latest/APIReference/API_GetResources.html) do AWS Resource Groups Tagging API para filtrar seus recursos por etiquetas. A operação `GetResources` aceita até 10 filtros, cada um contendo uma chave de etiquetas e até 10 valores de etiquetas. Você fornece a `GetResources` um `ResourceType` para filtrar por tipos de recursos específicos. Você pode chamar essa operação usando o comando `get-resources` da AWS CLI. Para ver exemplos de uso de `get-resources`, consulte [get-resources](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/resourcegroupstaggingapi/get-resources.html#examples) na *referência de comandos da AWS CLI*. # Streaming de resposta para funções do Lambda As funções do Lambda podem transmitir nativamente cargas úteis de resposta de volta aos clientes por meio de [URLs de funções do Lambda](urls-configuration.md) ou usando a API [InvokeWithResponseStream](https://docs.aws.amazon.com/lambda/latest/api/API_InvokeWithResponseStream.html) (por meio do SDK da AWS ou de chamadas diretas de API). Sua função do Lambda também pode transmitir cargas úteis de resposta por meio da [integração de proxy do Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/response-transfer-mode-lambda.html), que usa a API [InvokeWithResponseStream](https://docs.aws.amazon.com/lambda/latest/api/API_InvokeWithResponseStream.html) para invocar sua função. O streaming de respostas pode beneficiar aplicações sensíveis à latência ao melhorar a performance do tempo até o primeiro byte (TTFB). Isso ocorre porque é possível enviar respostas parciais de volta ao cliente assim que elas se tornarem disponíveis. Além disso, as funções de streaming de resposta podem retornar cargas úteis de até 200 MB, em comparação com o máximo de 6 MB para respostas armazenadas em buffer. O streaming de uma resposta também significa que sua função não precisa caber em toda a resposta na memória. Para respostas muito grandes, isso pode reduzir a quantidade de memória que você precisa configurar para sua função. **nota** O streaming de respostas do Lambda ainda não está disponível em todas as Regiões da AWS. Consulte os [Recursos da AWS por região](https://builder.aws.com/build/capabilities) do Builder Center para obter a disponibilidade de recursos por região. A velocidade com que o Lambda faz o streaming das suas respostas depende do tamanho da resposta. A taxa de streaming dos primeiros 6 MB da resposta da sua função é ilimitada. Para respostas maiores que 6 MB, o restante da resposta está sujeito a um limite de largura de banda. Para obter mais informações sobre largura de banda de streaming, consulte [Limites de largura de banda para streaming de resposta](#config-rs-bandwidth-cap). As respostas de streaming têm custos e as respostas transmitidas não são interrompidas quando a conexão do cliente de chamada é quebrada. Os clientes serão cobrados pela duração total da função, portanto, devem ter cuidado ao configurar tempos limite de função longos. O Lambda oferece suporte ao streaming de respostas em runtimes gerenciados por Node.js. Em outras linguagens, incluindo o Python, é possível [usar um runtime personalizado com uma integração personalizada da API de runtime](runtimes-custom.md#runtimes-custom-response-streaming) para transmitir respostas ou usar o [Lambda Web Adapter](https://github.com/awslabs/aws-lambda-web-adapter). **nota** Ao testar sua função por meio do console do Lambda, você sempre verá as respostas como armazenadas em buffer. **Topics** + [ ## Limites de largura de banda para streaming de resposta ](#config-rs-bandwidth-cap) + [ ## Compatibilidade da VPC com streaming de resposta ](#config-rs-vpc-compatibility) + [ # Escrever funções do Lambda habilitadas para streaming de resposta ](config-rs-write-functions.md) + [ # Invocação de uma função habilitada para streaming de resposta usando URLs de função do Lambda ](config-rs-invoke-furls.md) + [ # Tutorial: criação de um função do Lambda de streaming de resposta com um URL da função ](response-streaming-tutorial.md) ## Limites de largura de banda para streaming de resposta Os primeiros 6 MB da carga útil de resposta da sua função têm largura de banda ilimitada. Após essa intermitência inicial, o Lambda faz o streaming da sua resposta a uma taxa máxima de 2 MBps. Se as respostas da sua função nunca excederem 6 MB, esse limite de largura de banda nunca será aplicado. **nota** Os limites de largura de banda se aplicam somente à carga útil da resposta da sua função e não ao acesso à rede por sua função. A taxa de largura de banda ilimitada varia de acordo com diversos fatores, incluindo a velocidade de processamento da sua função. Normalmente, você pode esperar uma taxa superior a 2 MBps para os primeiros 6 MB da resposta da sua função. Se sua função estiver fazendo o streaming de uma resposta para um destino fora da AWS, a taxa de streaming também dependerá da velocidade da conexão externa com a Internet. ## Compatibilidade da VPC com streaming de resposta Ao usar funções do Lambda em um ambiente de VPC, há considerações importantes sobre o streaming de resposta: + Os URLs das funções do Lambda não são compatíveis com streaming de resposta em um ambiente de VPC. + É possível usar streaming de resposta em uma VPC invocando a função do Lambda por meio do SDK da AWS usando a API `InvokeWithResponseStream`. Isso requer a configuração dos endpoints da VPC apropriados para o Lambda. + Para ambientes de VPC, você precisará criar um endpoint da VPC de interface para o Lambda de modo a permitir a comunicação entre os recursos da VPC e o serviço Lambda. Uma arquitetura típica para streaming de resposta em uma VPC pode incluir: ``` Client in VPC -> Interface VPC endpoint for Lambda -> Lambda function -> Response streaming back through the same path ``` # Escrever funções do Lambda habilitadas para streaming de resposta Escrever o manipulador para funções de streaming de resposta é diferente dos padrões típicos do manipulador. Ao escrever funções de streaming, certifique-se de fazer o seguinte: + Envolva sua função com o decorador `awslambda.streamifyResponse()`. O objeto global `awslambda` é fornecido pelo ambiente de execução Node.js do Lambda. + Encerre a stream adequadamente para garantir que todo o processamento de dados seja concluído. ## Configuração de uma função de manipulador para o streaming de respostas Para indicar ao runtime que o Lambda deve fazer o streaming das respostas da sua função, é necessário encapsular sua função com o decorador `streamifyResponse()`. Isso faz com que o runtime use o caminho lógico adequado para o streaming de respostas e habilita a função a fazer o streaming das respostas. O decorador `streamifyResponse()` aceita uma função que aceita os seguintes parâmetros: + `event`: fornece informações sobre o evento de invocação do URL da função, como o método HTTP, os parâmetros da consulta e o corpo da solicitação. + `responseStream`: fornece um stream gravável. + `context`: fornece métodos e propriedades com informações sobre a invocação, a função e o ambiente de execução. O objeto `responseStream` é um [`writableStream` de Node.js](https://nodesource.com/blog/understanding-streams-in-nodejs/). Como em qualquer stream desse tipo, use o método `pipeline()`. **nota** O objeto global `awslambda` é fornecido automaticamente pelo tempo de execução Node.js do Lambda e nenhuma importação é necessária. **Example manipulador habilitado para streaming de resposta** ``` import { pipeline } from 'node:stream/promises'; import { Readable } from 'node:stream'; export const echo = awslambda.streamifyResponse(async (event, responseStream, _context) => { // As an example, convert event to a readable stream. const requestStream = Readable.from(Buffer.from(JSON.stringify(event))); await pipeline(requestStream, responseStream); }); ``` Embora `responseStream` ofereça o método `write()` para gravar no stream, recomendamos que você use [https://nodejs.org/api/stream.html#streampipelinesource-transforms-destination-callback](https://nodejs.org/api/stream.html#streampipelinesource-transforms-destination-callback) sempre que possível. O uso de `pipeline()` garante que o stream gravável não seja sobrecarregado por um stream legível mais rápido. ## Encerramento do stream Certifique-se de encerrar o stream corretamente antes que o manipulador retorne. O método `pipeline()` lida com isso automaticamente. Para outros casos de uso, chame o método `responseStream.end()` para encerrar corretamente um stream. Esse método sinaliza que nenhum outro dado deve ser gravado no stream. Esse método não é necessário se você gravar no stream com `pipeline()` ou `pipe()`. A partir do Node.js 24, o Lambda não espera mais que as promessas não resolvidas sejam concluídas após o retorno do manipulador ou o término do fluxo de respostas. Se a sua função depender de operações assíncronas adicionais, como cronômetros ou buscas, será necessário o `await` delas no seu manipulador. **Example Exemplo de encerramento de um stream com pipeline()** ``` import { pipeline } from 'node:stream/promises'; export const handler = awslambda.streamifyResponse(async (event, responseStream, _context) => { await pipeline(requestStream, responseStream); }); ``` **Example Exemplo de encerramento de um stream sem pipeline()** ``` export const handler = awslambda.streamifyResponse(async (event, responseStream, _context) => { responseStream.write("Hello "); responseStream.write("world "); responseStream.write("from "); responseStream.write("Lambda!"); responseStream.end(); }); ``` # Invocação de uma função habilitada para streaming de resposta usando URLs de função do Lambda **nota** Sua função do Lambda agora pode transmitir carga útil de resposta por meio da integração de proxy do [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/response-transfer-mode-lambda.html). É possível invocar funções habilitadas para streaming de resposta alterando o modo de invocação do URL da função. O modo de invocação determina qual operação de API o Lambda usa para invocar sua função. Os modos de invocação disponíveis são: + `BUFFERED`: esta é a opção padrão. O Lambda invoca sua função usando a operação `Invoke` da API. Os resultados da invocação estarão disponíveis quando a carga estiver concluída. O tamanho máximo da carga é de 6 GB. + `RESPONSE_STREAM`: permite que sua função faça o streaming dos resultados da carga assim que eles se tornem disponíveis. O Lambda invoca sua função usando a operação `InvokeWithResponseStream` da API. O tamanho máximo da carga útil de resposta é de 200 MB. Você ainda pode invocar sua função sem streaming de resposta chamando diretamente a operação `Invoke` da API. No entanto, o Lambda faz o streaming de todas as cargas de resposta para invocações que passam pela URL da função até que você altere o modo de invocação para `BUFFERED`. ------ #### [ Console ] **Para definir o modo de invocação de um URL da função (console)** 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. 1. Escolha o nome da função para a qual você deseja definir o modo de invocação. 1. Escolha a guia **Configuration** (Configuração) e depois **Function URL** (URL de função). 1. Escolha **Editar** e, em seguida, escolha **Configurações adicionais**. 1. Em **Modo de invocação**, escolha o modo de invocação desejado. 1. Escolha **Salvar**. ------ #### [ AWS CLI ] **Para definir o modo de invocação da URL de uma função (AWS CLI)** ``` aws lambda update-function-url-config \ --function-name my-function \ --invoke-mode RESPONSE_STREAM ``` ------ #### [ CloudFormation ] **Para definir o modo de invocação da URL de uma função (CloudFormation)** ``` MyFunctionUrl: Type: AWS::Lambda::Url Properties: AuthType: AWS_IAM InvokeMode: RESPONSE_STREAM ``` ------ Para obter mais informações sobre a configuração de URLs de função, consulte [URLs de função do Lambda](urls-configuration.md). # Tutorial: criação de um função do Lambda de streaming de resposta com um URL da função Neste tutorial, você criará uma função do Lambda definida como um arquivo .zip com um endpoint público do URL da função que retorna um fluxo de resposta. Para obter mais informações sobre a configuração de URLs de função, consulte [URLs de função](urls-configuration.md). ## Pré-requisitos Este tutorial presume que você tenha algum conhecimento de operações básicas do Lambda e do console do Lambda. Caso ainda não tenha feito isso, siga as instruções em [Criar uma função do Lambda com o console](getting-started.md#getting-started-create-function) para criar sua primeira função do Lambda. Para concluir as etapas apresentadas a seguir, é necessário ter a [versão 2 da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). Os comandos e a saída esperada são mostrados em blocos separados: ``` aws --version ``` A seguinte saída deverá ser mostrada: ``` aws-cli/2.13.27 Python/3.11.6 Linux/4.14.328-248.540.amzn2.x86_64 exe/x86_64.amzn.2 ``` Para comandos longos, um caractere de escape (`\`) é usado para dividir um comando em várias linhas. No Linux e no macOS, use seu gerenciador preferido de pacotes e de shell. **nota** No Windows, alguns comandos da CLI do Bash que você costuma usar com o Lambda (como `zip`) não são compatíveis com os terminais integrados do sistema operacional. Para obter uma versão do Ubuntu com o Bash integrada no Windows, [instale o Subsistema do Windows para Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Os exemplos de comandos da CLI neste guia usam a formatação Linux. Os comandos que incluem documentos JSON em linha deverão ser reformatados se você estiver usando a CLI do Windows. ## Criar uma função de execução Crie a [função de execução](lambda-intro-execution-role.md) que dá à sua função do Lambda permissão para acessar recursos da AWS. **Para criar uma função de execução** 1. Abra a [página Roles](https://console.aws.amazon.com/iam/home#/roles) (Funções) no console do AWS Identity and Access Management (IAM). 1. Selecione **Criar perfil**. 1. Crie uma função com as seguintes propriedades: + **Tipo de entidade confiável**: **serviço da AWS** + **Caso de uso**: **Lambda** + **Permissões**: **AWSLambdaBasicExecutionRole** + **Role name (Nome da função** – **response-streaming-role** A política **AWSLambdaBasicExecutionRole** tem as permissões de que a função necessita para gravar logs no Amazon CloudWatch Logs. Após criar o perfil, anote seu nome do recurso da Amazon (ARN). Você precisará dele na próxima etapa. ## Crie uma função de streaming de respostas (AWS CLI) Crie uma função do Lambda de streaming resposta com um endpoint de URL da função usando a AWS Command Line Interface (AWS CLI). **Para criar uma função que possa fazer o streaming de respostas** 1. Copie o exemplo de código a seguir em um arquivo com o nome `index.js`. Essa função transmite três respostas, separadas por 1 segundo. ``` exports.handler = awslambda.streamifyResponse( async (event, responseStream, _context) => { // Metadata is a JSON serializable JS object. Its shape is not defined here. const metadata = { statusCode: 200, headers: { "Content-Type": "application/json", "CustomHeader": "outerspace" } }; // Assign to the responseStream parameter to prevent accidental reuse of the non-wrapped stream. responseStream = awslambda.HttpResponseStream.from(responseStream, metadata); responseStream.write("Streaming with Helper \n"); await new Promise(r => setTimeout(r, 1000)); responseStream.write("Hello 0 \n"); await new Promise(r => setTimeout(r, 1000)); responseStream.write("Hello 1 \n"); await new Promise(r => setTimeout(r, 1000)); responseStream.write("Hello 2 \n"); await new Promise(r => setTimeout(r, 1000)); responseStream.end(); await responseStream.finished(); } ); ``` 1. Crie um pacote de implantação. ``` zip function.zip index.js ``` 1. Crie uma função do Lambda com o comando `create-function`. Substitua o valor de `--role` pelo ARN do perfil da etapa anterior. Esse comando define o tempo limite da função para 10 segundos, o que permite que a função transmita três respostas. ``` aws lambda create-function \ --function-name my-streaming-function \ --runtime nodejs24.x \ --zip-file fileb://function.zip \ --handler index.handler \ --timeout 10 \ --role arn:aws:iam::123456789012:role/response-streaming-role ``` **Para criar um URL da função** 1. Adicione uma política baseada em recursos à sua função concedendo as permissões `lambda:InvokeFunctionUrl` e `lambda:InvokeFunction`. Cada instrução deve ser adicionada em um comando individual. Substitua o valor de `--principal` pela sua ID da Conta da AWS. ``` aws lambda add-permission \ --function-name my-streaming-function \ --action lambda:InvokeFunctionUrl \ --statement-id UrlPolicyInvokeURL \ --principal 123456789012 \ --function-url-auth-type AWS_IAM ``` ``` aws lambda add-permission \ --function-name my-streaming-function \ --action lambda:InvokeFunction \ --statement-id UrlPolicyInvokeFunction \ --principal 123456789012 ``` 1. Crie um endpoint de URL para a função com o comando `create-function-url-config`. ``` aws lambda create-function-url-config \ --function-name my-streaming-function \ --auth-type AWS_IAM \ --invoke-mode RESPONSE_STREAM ``` **nota** Se você receber um erro sobre `--invoke-mode`, talvez seja necessário atualizar para uma [versão mais recente do AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). ## Testar o endpoint de URL de função Teste sua integração invocando sua função. É possível abrir o URL da sua função em um navegador, ou usar o curl. ``` curl --request GET "https://abcdefghijklm7nop7qrs740abcd.lambda-url.us-east-1.on.aws/" --user "AKIAIOSFODNN7EXAMPLE" --aws-sigv4 "aws:amz:us-east-1:lambda" --no-buffer ``` A URL da nossa função usa o tipo de autenticação `IAM_AUTH`. Isso significa que você precisa assinar solicitações com sua [chave de acesso e chave secreta da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html). No comando anterior, substitua `AKIAIOSFODNN7EXAMPLE` pela ID da chave de acesso da AWS. Insira sua chave secreta da AWS, quando solicitada. Se você não tiver sua chave secreta da AWS, é possível [usar credenciais da AWS temporárias](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) em vez disso. Você obterá uma resposta parecida com esta: ``` Streaming with Helper Hello 0 Hello 1 Hello 2 ``` ## Limpe os recursos Agora você pode excluir os recursos criados para este tutorial, a menos que queira mantê-los. Excluindo os recursos da AWS que você não está mais usando, você evita cobranças desnecessárias em sua Conta da AWS. **Para excluir a função de execução** 1. Abra a página [Roles](https://console.aws.amazon.com/iam/home#/roles) (Funções) no console do IAM. 1. Selecione a função de execução que você criou. 1. Escolha **Excluir**. 1. Insira o nome do perfil no campo de entrada de texto e escolha **Delete** (Excluir). **Como excluir a função do Lambda** 1. Abra a página [Functions](https://console.aws.amazon.com/lambda/home#/functions) (Funções) no console do Lambda. 1. Selecione a função que você criou. 1. Selecione **Ações**, **Excluir**. 1. Digite **confirm** no campo de entrada de texto e escolha **Delete** (Excluir). # Usar o endpoint de metadados Lambda O endpoint de metadados do Lambda permite que suas funções do Lambda identifiquem em qual Zona de Disponibilidade (AZ) estão sendo executadas, possibilitando a otimização da latência por meio do roteamento para recursos na mesma AZ, como o Amazon ElastiCache e os endpoints do Amazon RDS, além de permitir a implementação de padrões de resiliência que levam em conta a AZ. O endpoint retorna metadados em um formato JSON simples por meio de uma API HTTP no localhost dentro do ambiente de execução e está acessível tanto aos runtimes quanto às extensões. **Topics** + [ ## Introdução ](#metadata-endpoint-getting-started) + [ ## Sobre IDs de zonas de disponibilidade ](#metadata-endpoint-az-ids) + [ ## Referência de API ](#metadata-endpoint-api-reference) ## Introdução [O Powertools para AWS Lambda](https://docs.aws.amazon.com/powertools/) fornece um utilitário para acessar o endpoint de metadados do Lambda em Python, TypeScript, Java e .NET. O utilitário armazena a resposta em cache após a primeira chamada e lida com a invalidação do cache do SnapStart automaticamente. Use o utilitário de metadados Powertools para AWS Lambda ou chame o endpoint de metadados diretamente ------ #### [ Python ] Instale o pacote Powertools: ``` pip install "aws-lambda-powertools" ``` Use o utilitário de metadados em seu manipulador: **Example Recuperação do ID de AZ com o Powertools (Python)** ``` from aws_lambda_powertools.utilities.lambda_metadata import get_lambda_metadata def handler(event, context): metadata = get_lambda_metadata() az_id = metadata.availability_zone_id # e.g., "use1-az1" return {"az_id": az_id} ``` ------ #### [ TypeScript ] Instale o pacote Powertools: ``` npm install @aws-lambda-powertools/commons ``` Use o utilitário de metadados em seu manipulador: **Example Recuperação do ID de AZ com o Powertools (TypeScript)** ``` import { getMetadata } from '@aws-lambda-powertools/commons/utils/metadata'; const metadata = await getMetadata(); export const handler = async () => { const { AvailabilityZoneID: azId } = metadata; return azId; }; ``` ------ #### [ Java ] Adicione a dependência Powertools ao seu `pom.xml`: ``` software.amazon.lambda powertools-lambda-metadata 2.10.0 ``` Utilize o cliente de metadados no seu manipulador: **Example Recuperação do ID de AZ com o Powertools (Java)** ``` import software.amazon.lambda.powertools.metadata.LambdaMetadata; import software.amazon.lambda.powertools.metadata.LambdaMetadataClient; public class App implements RequestHandler { @Override public String handleRequest(Object input, Context context) { LambdaMetadata metadata = LambdaMetadataClient.get(); String azId = metadata.getAvailabilityZoneId(); // e.g., "use1-az1" return "{\"azId\": \"" + azId + "\"}"; } } ``` ------ #### [ .NET ] Instale o pacote Powertools: ``` dotnet add package AWS.Lambda.Powertools.Metadata ``` Utilize a classe de metadados no seu manipulador: **Example Recuperação do ID de AZ com o Powertools (.NET)** ``` using AWS.Lambda.Powertools.Metadata; public class Function { public string Handler(object input, ILambdaContext context) { var azId = LambdaMetadata.AvailabilityZoneId; return $"Running in AZ: {azId}"; } } ``` ------ #### [ All Runtimes ] Todos os runtimes do Lambda oferecem suporte ao endpoint de metadados, incluindo runtimes personalizados e imagens de contêiner. Utilize o exemplo a seguir para acessar a API de metadados diretamente a partir da sua função do Lambda, utilizando as variáveis de ambiente que o Lambda define automaticamente no ambiente de execução. **Example Acessar diretamente o endpoint de metadados** ``` # Variables are automatically set by Lambda METADATA_ENDPOINT="http://${AWS_LAMBDA_METADATA_API}/2026-01-15/metadata/execution-environment" # Make the request RESPONSE=$(curl -s -H "Authorization: Bearer ${AWS_LAMBDA_METADATA_TOKEN}" "$METADATA_ENDPOINT") # Parse the AZ ID AZ_ID=$(echo "$RESPONSE" | jq -r '.AvailabilityZoneID') echo "Function is running in AZ ID: $AZ_ID" ``` ------ ## Sobre IDs de zonas de disponibilidade Os IDs de AZ (por exemplo, `use1-az1`) sempre se referem à mesma localização física em todas as contas da AWS, enquanto os nomes de AZ (por exemplo,`us-east-1a`) podem ser mapeados para diferentes infraestruturas físicas em cada conta da AWS em determinadas regiões. Para obter mais informações, consulte [IDs de AZ para garantir a consistência entre contas](https://docs.aws.amazon.com/global-infrastructure/latest/regions/az-ids.html). **Converter o ID da AZ em nome da AZ:** Para converter um ID de AZ em um nome de AZ, utilize a API [DescribeAvailabilityZones](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAvailabilityZones.html) do Amazon EC2. Para usar essa API, adicione a permissão `ec2:DescribeAvailabilityZones` ao perfil de execução da sua função. ## Referência de API ### Variáveis de ambiente O Lambda define automaticamente as seguintes variáveis de ambiente em todos os ambientes de execução: + `AWS_LAMBDA_METADATA_API`: o endereço do servidor de metadados no formato `{ipv4_address}:{port}` (por exemplo, `169.254.100.1:9001`). + `AWS_LAMBDA_METADATA_TOKEN`: um token de autenticação exclusivo para o ambiente de execução atual. O Lambda gera esse token automaticamente na inicialização. Inclua-o em todas as solicitações da API de metadados. ### Endpoint `GET http://${AWS_LAMBDA_METADATA_API}/2026-01-15/metadata/execution-environment` ### Solicitação **Cabeçalhos obrigatórios:** + `Authorization`: o valor do token da variável de ambiente `AWS_LAMBDA_METADATA_TOKEN` com o esquema Bearer: `Bearer `. Essa autenticação baseada em token oferece proteção em camadas contra vulnerabilidades de falsificação de solicitação do lado do servidor (SSRF). Cada ambiente de execução recebe um token único, gerado aleatoriamente, durante a inicialização. ### Resposta **Status:** `200 OK` **Content-Type:** `application/json` **Cache-Control:** `private, max-age=43200, immutable` A resposta é imutável em um ambiente de execução. Os clientes devem armazenar a resposta em cache e respeitar o TTL `Cache-Control`. No caso das funções SnapStart, o TTL é reduzido durante a inicialização para que os clientes atualizem os metadados após a restauração, quando o ambiente de execução estiver em uma zona de disponibilidade diferente. Se você usa o Powertools, o armazenamento em cache e a invalidação do SnapStart são gerenciados automaticamente. **Corpo:** ``` { "AvailabilityZoneID": "use1-az1" } ``` O campo `AvailabilityZoneID` contém o identificador exclusivo da zona de disponibilidade onde o ambiente de execução está sendo executado. **nota** Campos adicionais podem ser adicionados à resposta em atualizações futuras. Os clientes devem ignorar campos desconhecidos e não falhar se novos campos aparecerem. ### Respostas de erro + **401 Não autorizado**: o cabeçalho `Authorization` está ausente ou contém um token inválido. Verifique se você está passando `Bearer ${AWS_LAMBDA_METADATA_TOKEN}`. + **405 Método não permitido**: o método de solicitação não é `GET`. + **500 Erro interno do servidor**: erro de processamento no lado do servidor.