# Conceitos básicos das instâncias gerenciadas do Lambda
<a name="lambda-managed-instances-getting-started"></a>

## Criação de uma função de instância gerenciada do Lambda (console)
<a name="lambda-managed-instances-getting-started-console"></a>

É possível usar o console do Lambda para criar uma função de instância gerenciada que é executada em instâncias do Amazon EC2 gerenciadas por um provedor de capacidade.

**Importante:** antes de criar uma função de instância gerenciada, você deve primeiro criar um provedor de capacidade. Essas funções exigem que um provedor de capacidade defina a infraestrutura do Amazon EC2 que executará suas funções.

**Para criar uma função de instância gerenciada do Lambda (console)**

1. Abra o console do lambda.

1. Escolha **Provedores de capacidade** no painel de navegação à esquerda.

1. Escolha **Criar provedor de capacidade**.

1. Na seção **Configurações do provedor de capacidade**, insira um nome para seu provedor de capacidade.

1. Selecione a VPC e as permissões para seu provedor de capacidade. É possível usar uma existente ou criar uma nova. Para obter informações sobre como criar o perfil de operador necessário, consulte [Perfil de operador do Lambda para instâncias gerenciadas do Lambda](lambda-managed-instances-operator-role.md).

1. Expanda **Advanced settings (Configurações avançadas)**.

1. Defina seus **requisitos de instância** escolhendo a arquitetura do processador e os tipos de instância.

1. Em **Ajuste de escala automático**, especifique o número máximo de vCPUs EC2 para seu provedor de capacidade. Também é possível escolher o **modo de escalabilidade de instâncias manual** para definir seu próprio valor de escalabilidade para um controle preciso.

1. Escolha **Criar provedor de capacidade** para criar um novo.

1. A seguir, escolha **Create function**.

1. Selecione **Criar do zero**.

1. No painel **Informações básicas**, forneça o **Nome da função**.

1. Em **Runtime**, escolha qualquer um dos runtimes com suporte.

1. Escolha a **Arquitetura** para sua função (a mesma que você selecionou para o provedor de capacidade). Por padrão, **x86\_64**.

1. Em **Permissões**, verifique se você tem permissão para o **perfil de execução** escolhido. Caso contrário, é possível criar um novo perfil.

1. Em **Configurações adicionais**, escolha o **Tipo de computação** como **Instâncias gerenciadas do Lambda**.

1. O ARN do provedor de capacidade que você criou nas etapas anteriores deve ser pré-selecionado.

1. Escolha **Tamanho da memória** e **Memória do ambiente de execução (GiB) por proporção de vCPU**.

1. Escolha a opção **Criar função**.

Sua função de Instância gerenciada do Lambda é criada e provisionará a capacidade em seu provedor de capacidade especificado. A criação da função normalmente leva vários minutos. Depois de concluído, será possível editar o código da função e executar seu primeiro teste.

## Criação de uma função de instância gerenciada do Lambda (AWS CLI)
<a name="lambda-managed-instances-getting-started-cli"></a>

### Pré-requisitos
<a name="lambda-managed-instances-prerequisites"></a>

Antes de começar, você deve ter o seguinte:
+ **AWS CLI**: instale e configure a AWS CLI. Para obter mais informações, consulte [Instalação ou atualização da versão mais recente da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ **Permissões do IAM**: seu perfil ou usuário do IAM deve ter permissões para criar funções do Lambda, provedores de capacidade e transmitir perfis do IAM. Observe que você também precisará de `iam:CreateServiceLinkedRole` se for a primeira vez que cria um provedor de capacidade na conta ou se o perfil vinculado ao serviço (SLR) foi excluído.

### Etapa 1: criação dos perfis do IAM necessários.
<a name="lambda-managed-instances-step1-iam"></a>

As instâncias gerenciadas do Lambda exigem dois perfis do IAM: um perfil de execução para sua função e um perfil de operador para o provedor de capacidade. O perfil do operador permite que o Lambda inicie, encerre e monitore instâncias do Amazon EC2 em seu nome. O perfil de execução da função concede a ela permissões para acessar outros serviços e recursos da AWS.

**Para criar o perfil de execução do Lambda**

1. Crie um documento de política de confiança que permita que o Lambda assuma o perfil:

   ```
   cat > lambda-trust-policy.json << 'EOF'
   {
     "Version": "2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Service": "lambda.amazonaws.com"
         },
         "Action": "sts:AssumeRole"
       }
     ]
   }
   EOF
   ```

1. Crie o perfil de execução

   ```
   aws iam create-role \
     --role-name MyLambdaExecutionRole \
     --assume-role-policy-document file://lambda-trust-policy.json
   ```

1. Anexe a política básica de execução:

   ```
   aws iam attach-role-policy \
     --role-name MyLambdaExecutionRole \
     --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
   ```

**Para criar o perfil de operador do provedor de capacidade**

1. Crie um documento de política de confiança que permita que o Lambda assuma o perfil de operador:

   ```
   cat > operator-trust-policy.json << 'EOF'
   {
     "Version": "2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Service": "lambda.amazonaws.com"
         },
         "Action": "sts:AssumeRole"
       }
     ]
   }
   EOF
   ```

1. Crie o perfil de operador:

   ```
   aws iam create-role \
     --role-name MyCapacityProviderOperatorRole \
     --assume-role-policy-document file://operator-trust-policy.json
   ```

1. Anexe a política de permissões do EC2 necessária:

   ```
   aws iam attach-role-policy \
     --role-name MyCapacityProviderOperatorRole \
     --policy-arn arn:aws:iam::aws:policy/AWSLambdaManagedEC2ResourceOperator
   ```

### Etapa 2: configuração dos recursos da VPC
<a name="lambda-managed-instances-step2-vpc"></a>

As instâncias gerenciadas do Lambda são executadas em sua VPC e exigem uma sub-rede e um grupo de segurança.

**Para criar recursos de VPC**

1. Crie uma VPC:

   ```
   VPC_ID=$(aws ec2 create-vpc \
     --cidr-block 10.0.0.0/16 \
     --query 'Vpc.VpcId' \
     --output text)
   ```

1. Crie uma sub-rede:

   ```
   SUBNET_ID=$(aws ec2 create-subnet \
     --vpc-id $VPC_ID \
     --cidr-block 10.0.1.0/24 \
     --query 'Subnet.SubnetId' \
     --output text)
   ```

1. Crie um grupo de segurança:

   ```
   SECURITY_GROUP_ID=$(aws ec2 create-security-group \
     --group-name my-capacity-provider-sg \
     --description "Security group for Lambda Managed Instances" \
     --vpc-id $VPC_ID \
     --query 'GroupId' \
     --output text)
   ```

**Observação:** suas funções de instâncias gerenciadas do Lambda exigem a configuração da VPC para acessar recursos fora da VPC e transmitir dados de telemetria para o CloudWatch Logs e o X-Ray. Para obter detalhes de configuração, consulte [Rede para instâncias gerenciadas do Lambda](lambda-managed-instances-networking.md).

### Etapa 3: Criar um provedor de capacidade
<a name="lambda-managed-instances-step3-capacity-provider"></a>

Um provedor de capacidade gerencia as instâncias do EC2 que executam suas funções do Lambda.

**Para criar um provedor de capacidade**

```
ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)

aws lambda create-capacity-provider \
  --capacity-provider-name my-capacity-provider \
  --vpc-config SubnetIds=[$SUBNET_ID],SecurityGroupIds=[$SECURITY_GROUP_ID] \
  --permissions-config CapacityProviderOperatorRoleArn=arn:aws:iam::${ACCOUNT_ID}:role/MyCapacityProviderOperatorRole \
  --instance-requirements Architectures=[x86_64] \
  --capacity-provider-scaling-config MaxVCpuCount=30
```

Este comando cria um provedor de capacidade com a configuração a seguir:
+ **Configuração da VPC**: especifica a sub-rede e o grupo de segurança para as instâncias do EC2
+ **Permissões**: define o perfil do IAM que o Lambda usa para gerenciar instâncias do EC2
+ **Requisitos da instância**: especifica a arquitetura x86\_64
+ **Configuração de escalabilidade**: define um máximo de 30 vCPUs para o provedor de capacidade

### Etapa 4: criação de uma função do Lambda com código embutido
<a name="lambda-managed-instances-step4-function"></a>

**Para criar uma função com código embutido**

1. Primeiro, crie uma função simples do Python e empacote-a em linha:

   ```
   # Create a temporary directory for the function code
   mkdir -p /tmp/my-lambda-function
   cd /tmp/my-lambda-function
   
   # Create a simple Python handler
   cat > lambda_function.py << 'EOF'
   import json
   
   def lambda_handler(event, context):
       return {
           'statusCode': 200,
           'body': json.dumps({
               'message': 'Hello from Lambda Managed Instances!',
               'event': event
           })
       }
   EOF
   
   # Create a ZIP file
   zip function.zip lambda_function.py
   ```

1. Crie a função do Lambda usando o arquivo ZIP embutido:

   ```
   ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
   REGION=$(aws configure get region)
   
   aws lambda create-function \
     --function-name my-managed-instance-function \
     --package-type Zip \
     --runtime python3.13 \
     --handler lambda_function.lambda_handler \
     --zip-file fileb:///tmp/my-lambda-function/function.zip \
     --role arn:aws:iam::${ACCOUNT_ID}:role/MyLambdaExecutionRole \
     --architectures x86_64 \
     --memory-size 2048 \
     --ephemeral-storage Size=512 \
     --capacity-provider-config LambdaManagedInstancesCapacityProviderConfig={CapacityProviderArn=arn:aws:lambda:${REGION}:${ACCOUNT_ID}:capacity-provider:my-capacity-provider}
   ```

   A função é criada com:
   + **Runtime**: Python 3,13
   + **Manipulador**: a função `lambda_handler` em `lambda_function.py`
   + **Memória**: 2048 MB
   + **Armazenamento efêmero**: 512 MB
   + **Provedor de capacidade**: links para o provedor de capacidade que você criou

### Etapa 5: publicação de uma versão da função
<a name="lambda-managed-instances-step5-publish"></a>

Para executar sua função nas instâncias gerenciadas do Lambda, é necessário publicar uma versão.

**Para publicar uma versão da função**

```
aws lambda publish-version \
  --function-name my-managed-instance-function
```

Esse comando publica a versão 1 da sua função e a implanta no provedor de capacidade.

### Etapa 6: invocação da sua função
<a name="lambda-managed-instances-step6-invoke"></a>

Depois de publicar, é possível invocar sua função.

**Para invocar sua função**

```
aws lambda invoke \
  --function-name my-managed-instance-function:1 \
  --payload '{"name": "World"}' \
  response.json

# View the response
cat response.json
```

A função é executada nas instâncias do EC2 gerenciadas pelo seu provedor de capacidade e retorna uma resposta.

### Limpeza
<a name="lambda-managed-instances-cleanup"></a>

Para evitar incorrer em custos, exclua os recursos que você criou:

1. Exclua a função:

   ```
   aws lambda delete-function --function-name my-managed-instance-function
   ```

1. Exclua o provedor de capacidade:

   ```
   aws lambda delete-capacity-provider --capacity-provider-name my-capacity-provider
   ```

1. Exclua os recursos da VPC:

   ```
   aws ec2 delete-security-group --group-id $SECURITY_GROUP_ID
   aws ec2 delete-subnet --subnet-id $SUBNET_ID
   aws ec2 delete-vpc --vpc-id $VPC_ID
   ```

1. Excluas os perfis do IAM:

   ```
   aws iam detach-role-policy \
     --role-name MyLambdaExecutionRole \
     --policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
   aws iam detach-role-policy \
     --role-name MyCapacityProviderOperatorRole \
     --policy-arn arn:aws:iam::aws:policy/AWSLambdaManagedEC2ResourceOperator
   
   aws iam delete-role --role-name MyLambdaExecutionRole
   aws iam delete-role --role-name MyCapacityProviderOperatorRole
   ```