Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Guida introduttiva alle istanze gestite Lambda
<a name="lambda-managed-instances-getting-started"></a>

## Creazione di una funzione Lambda Managed Instance (console)
<a name="lambda-managed-instances-getting-started-console"></a>

Puoi utilizzare la console Lambda per creare una funzione Managed Instance che viene eseguita su istanze Amazon EC2 gestite da un fornitore di capacità.

**Importante: ** prima di creare una funzione di istanza gestita, devi prima creare un fornitore di capacità. Queste funzioni richiedono che un fornitore di capacità definisca l'infrastruttura Amazon EC2 che esegue le tue funzioni.

**Per creare una funzione Lambda Managed Instance (console) **

1. Apri la console Lambda.

1. Scegli i fornitori di ** capacità ** dal riquadro di navigazione a sinistra.

1. Scegli ** Crea fornitore di capacità**.

1. Nella ** sezione delle impostazioni del fornitore di ** capacità, inserisci un nome per il tuo fornitore di capacità.

1. Seleziona VPC e le autorizzazioni per il tuo fornitore di capacità. Puoi utilizzarne uno esistente o crearne uno nuovo. Per informazioni sulla creazione del ruolo operatore richiesto, consulta Ruolo operatore [ Lambda per le istanze gestite Lambda. ](lambda-managed-instances-operator-role.md)

1. Espandere **Advanced settings (Impostazioni avanzate)**.

1. Definisci i requisiti dell'**istanza ** scegliendo l'architettura del processore e i tipi di istanza.

1. In ** Auto scaling**, specifica il numero massimo di vCPU EC2 per il tuo fornitore di capacità. Puoi anche scegliere la modalità di ridimensionamento ** manuale delle istanze ** per impostare il tuo valore di scalabilità per un controllo preciso.

1. Scegli ** Crea fornitore di capacità ** per crearne uno nuovo.

1. Quindi, scegli ** Crea funzione**.

1. Scegli **Crea da zero**.

1. Nel ** riquadro Informazioni ** di base, fornisci un nome di ** funzione**.

1. Per ** Runtime**, scegli uno dei Runtime supportati.

1. Scegli l'**architettura ** per la tua funzione (uguale a quella selezionata per il fornitore di capacità). Per impostazione predefinita, ** x86\_64**.

1. In ** Autorizzazioni**, assicurati di disporre dell'autorizzazione per il ruolo di esecuzione scelto. ** ** Altrimenti, puoi creare un nuovo ruolo.

1. In Configurazioni ** aggiuntive**, seleziona il tipo di ** calcolo ** come ** Lambda Managed Instances. **

1. L'ARN del fornitore di capacità creato nei passaggi precedenti deve essere preselezionato.

1. Scegliete ** la dimensione della memoria ** e il rapporto tra memoria dell'ambiente di ** esecuzione (GiB) per vCPU. **

1. Scegli **Crea funzione**.

La funzione Lambda Managed Instance viene creata e fornisce capacità al provider di capacità specificato. La creazione della funzione richiede in genere diversi minuti. Una volta completata, puoi modificare il codice della funzione ed eseguire il primo test.

## Creazione di una funzione Lambda Managed Instance (AWS CLI)
<a name="lambda-managed-instances-getting-started-cli"></a>

### Prerequisiti
<a name="lambda-managed-instances-prerequisites"></a>

Prima di iniziare, assicurati di disporre di:
+ **AWS CLI**: installa e configura la CLI AWS . Per ulteriori informazioni, vedere [ Installazione o aggiornamento della versione più recente della CLI AWS . ](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ **Autorizzazioni IAM**: l'utente o il ruolo IAM deve disporre delle autorizzazioni per creare funzioni Lambda, fornitori di capacità e passare ruoli IAM. Tieni presente che ti serviranno anche `iam:CreateServiceLinkedRole` se è la prima volta che crei un fornitore di capacità nell'account o se il Service Linked Role (SLR) è stato eliminato.

### Fase 1: Creare i ruoli IAM richiesti
<a name="lambda-managed-instances-step1-iam"></a>

Le istanze gestite Lambda richiedono due ruoli IAM: un ruolo di esecuzione per la funzione e un ruolo di operatore per il fornitore di capacità. Il ruolo di operatore consente a Lambda di avviare, terminare e monitorare le istanze Amazon EC2 per tuo conto. Il ruolo di esecuzione della funzione concede alla funzione le autorizzazioni per accedere ad altri servizi e risorse. AWS 

**Per creare il ruolo di esecuzione Lambda **

1. Crea un documento sulla politica di fiducia che consenta a Lambda di assumere il ruolo:

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

1. Crea il ruolo di esecuzione:

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

1. Allega la politica di esecuzione di base:

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

**Per creare il ruolo di operatore del fornitore di capacità **

1. Crea un documento sulla politica di fiducia che consenta a Lambda di assumere il ruolo di operatore:

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

1. Crea il ruolo di operatore:

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

1. Allega la politica di autorizzazione EC2 richiesta:

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

### Fase 2: Configurare le risorse VPC
<a name="lambda-managed-instances-step2-vpc"></a>

Le istanze gestite Lambda vengono eseguite nel tuo VPC e richiedono una sottorete e un gruppo di sicurezza.

**Per creare risorse VPC **

1. Crea un VPC:

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

1. Crea una sottorete:

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

1. Crea un gruppo di sicurezza:

   ```
   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)
   ```

**Nota: le funzioni delle ** tue istanze gestite Lambda richiedono la configurazione del VPC per accedere alle risorse esterne al VPC e per trasmettere i dati di telemetria a Logs e. CloudWatch X-Ray Per i dettagli sulla configurazione, vedi Networking for Lambda Managed Instances. [Rete per istanze gestite Lambda](lambda-managed-instances-networking.md)

### Fase 3: creazione di un provider di capacità
<a name="lambda-managed-instances-step3-capacity-provider"></a>

Un fornitore di capacità gestisce le istanze EC2 che eseguono le funzioni Lambda.

**Come creare un provider di capacità**

```
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
```

Questo comando crea un fornitore di capacità con la seguente configurazione:
+ **Configurazione VPC**: specifica la sottorete e il gruppo di sicurezza per le istanze EC2
+ **Autorizzazioni**: definisce il ruolo IAM utilizzato da Lambda per gestire le istanze EC2
+ **Requisiti di istanza**: specifica l'architettura x86\_64
+ **Configurazione di scalabilità**: imposta un massimo di 30 vCPU per il fornitore di capacità

### Fase 4: Creare una funzione Lambda con codice in linea
<a name="lambda-managed-instances-step4-function"></a>

**Per creare una funzione con codice in linea **

1. Innanzitutto, crea una semplice funzione Python e impacchettala in linea:

   ```
   # 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. Crea la funzione Lambda usando il file ZIP in linea:

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

   La funzione viene creata con:
   + **Runtime ** — Python 3.13
   + **Handler ** — La funzione in `lambda_handler` `lambda_function.py`
   + **Memoria**: 2048 MB
   + **Memoria temporanea: 512 MB **
   + **Fornitore di capacità**: collegamenti al fornitore di capacità creato

### Fase 5: Pubblicare una versione della funzione
<a name="lambda-managed-instances-step5-publish"></a>

Per eseguire la funzione su Lambda Managed Instances, devi pubblicare una versione.

**Per pubblicare una versione della funzione **

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

Questo comando pubblica la versione 1 della funzione e la distribuisce al fornitore di capacità.

### Passaggio 6: richiama la tua funzione
<a name="lambda-managed-instances-step6-invoke"></a>

Dopo la pubblicazione, puoi richiamare la tua funzione.

**Per richiamare la tua funzione **

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

# View the response
cat response.json
```

La funzione viene eseguita sulle istanze EC2 gestite dal fornitore di capacità e restituisce una risposta.

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

Per evitare di incorrere in addebiti, elimina le risorse che hai creato:

1. Elimina la funzione:

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

1. Eliminare il fornitore di capacità:

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

1. Elimina le risorse 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. Elimina i ruoli 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
   ```