Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Commencer à utiliser les instances gérées Lambda
<a name="lambda-managed-instances-getting-started"></a>

## Création d'une fonction d'instance gérée Lambda (console)
<a name="lambda-managed-instances-getting-started-console"></a>

Vous pouvez utiliser la console Lambda pour créer une fonction d'instance gérée qui s'exécute sur des EC2 instances Amazon gérées par un fournisseur de capacité.

**Important :** Avant de créer une fonction d'instance gérée, vous devez d'abord créer un fournisseur de capacité. Ces fonctions nécessitent un fournisseur de capacité pour définir l' EC2 infrastructure Amazon qui exécutera vos fonctions.

**Pour créer une fonction d'instance gérée Lambda (console)**

1. Ouvrez la console Lambda.

1. Choisissez **Capacity providers** dans le volet de navigation de gauche.

1. Choisissez **Créer un fournisseur de capacité**.

1. Dans la section **Paramètres du fournisseur de capacité**, entrez le nom de votre fournisseur de capacité.

1. Sélectionnez le VPC et les autorisations pour votre fournisseur de capacité. Vous pouvez utiliser un existant ou en créer un nouveau. Pour plus d'informations sur la création du rôle d'opérateur requis, voir Rôle d'[opérateur Lambda pour les instances gérées Lambda](lambda-managed-instances-operator-role.md).

1. Développez **Advanced settings** (Paramètres avancés).

1. Définissez les **exigences de votre instance** en choisissant l'architecture du processeur et les types d'instance.

1. Sous **Mise à l'échelle automatique**, spécifiez le nombre maximal de EC2 v CPUs pour votre fournisseur de capacité. Vous pouvez également choisir le **mode de dimensionnement manuel de l'instance** pour définir votre propre valeur de mise à l'échelle pour un contrôle précis.

1. Choisissez **Créer un fournisseur de capacité** pour en créer un nouveau.

1. Choisissez ensuite **Create function**.

1. Sélectionnez **Créer à partir de zéro**.

1. Dans le volet **Informations de base**, indiquez le **nom de la fonction**.

1. Pour **Runtime**, choisissez l'un des Runtimes pris en charge.

1. Choisissez l'**architecture** de votre fonction (identique à celle que vous avez sélectionnée pour le fournisseur de capacité). Par défaut, **x86\_64**.

1. Sous **Autorisations**, assurez-vous d'avoir l'autorisation pour le **rôle d'exécution** choisi. Sinon, vous pouvez créer un nouveau rôle.

1. Sous **Configurations supplémentaires**, sélectionnez le **type de calcul** en tant qu'**instances gérées Lambda**.

1. L'ARN du fournisseur de capacité que vous avez créé au cours des étapes précédentes doit être présélectionné.

1. Choisissez **la taille de la mémoire** et le ratio de **mémoire de l'environnement d'exécution (GiB) par vCPU**.

1. Choisissez **Créer une fonction**.

Votre fonction d'instance gérée Lambda est créée et fournira de la capacité au fournisseur de capacité que vous avez spécifié. La création d'une fonction prend généralement plusieurs minutes. Une fois terminé, vous pouvez modifier le code de votre fonction et exécuter votre premier test.

## Création d'une fonction d'instance gérée Lambda (CLI)AWS
<a name="lambda-managed-instances-getting-started-cli"></a>

### Conditions préalables
<a name="lambda-managed-instances-prerequisites"></a>

Avant de commencer, assurez-vous de disposer des éléments suivants :
+ **AWS CLI** — Installez et configurez la AWS CLI. Pour plus d'informations, voir [Installation ou mise à jour de la dernière version de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ **Autorisations IAM** : votre utilisateur ou rôle IAM doit être autorisé à créer des fonctions Lambda, à fournir des capacités et à transmettre des rôles IAM. Notez que vous en aurez également besoin `iam:CreateServiceLinkedRole` si c'est la première fois que vous créez un fournisseur de capacité dans le compte ou si le rôle lié au service (SLR) a été supprimé.

### Étape 1 : créer les rôles IAM requis
<a name="lambda-managed-instances-step1-iam"></a>

Les instances gérées Lambda nécessitent deux rôles IAM : un rôle d'exécution pour votre fonction et un rôle d'opérateur pour le fournisseur de capacité. Le rôle d'opérateur permet à Lambda de lancer, de résilier et de surveiller les EC2 instances Amazon en votre nom. Le rôle d'exécution de la fonction accorde à la fonction l'autorisation d'accéder à d'autres AWS services et ressources.

**Pour créer le rôle d'exécution Lambda**

1. Créez un document de politique de confiance qui permet à Lambda d'assumer le rôle :

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

1. Créez le rôle d'exécution :

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

1. Joignez la politique d'exécution de base :

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

**Pour créer le rôle d'opérateur fournisseur de capacité**

1. Créez un document de politique de confiance qui permet à Lambda d'assumer le rôle d'opérateur :

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

1. Créez le rôle d'opérateur :

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

1. Joignez la politique EC2 d'autorisation requise :

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

### Étape 2 : configurer les ressources VPC
<a name="lambda-managed-instances-step2-vpc"></a>

Les instances gérées Lambda s'exécutent dans votre VPC et nécessitent un sous-réseau et un groupe de sécurité.

**Pour créer des ressources VPC**

1. Créez un VPC :

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

1. Créez un sous-réseau :

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

1. Créez un groupe de sécurité :

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

**Remarque :** Les fonctions de vos instances gérées Lambda nécessitent une configuration VPC pour accéder à des ressources extérieures au VPC et pour transmettre des données de télémétrie à Logs and X-Ray. CloudWatch Pour plus de détails sur la configuration, consultez la section [Mise en réseau pour les instances gérées Lambda](lambda-managed-instances-networking.md).

### Étape 3 : Créer un fournisseur de capacité
<a name="lambda-managed-instances-step3-capacity-provider"></a>

Un fournisseur de capacité gère les EC2 instances qui exécutent vos fonctions Lambda.

**Pour créer un fournisseur de 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
```

Cette commande crée un fournisseur de capacité avec la configuration suivante :
+ **Configuration VPC** — Spécifie le sous-réseau et le groupe de sécurité pour les instances EC2 
+ **Autorisations** — Définit le rôle IAM que Lambda utilise pour gérer les instances EC2 
+ **Exigences relatives à l'instance** — Spécifie l'architecture x86\_64
+ **Configuration de mise à l'échelle** : définit un maximum de 30 V CPUs pour le fournisseur de capacité

### Étape 4 : Création d'une fonction Lambda avec du code en ligne
<a name="lambda-managed-instances-step4-function"></a>

**Pour créer une fonction avec du code en ligne**

1. Tout d'abord, créez une fonction Python simple et empaquez-la en ligne :

   ```
   # 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. Créez la fonction Lambda à l'aide du fichier ZIP intégré :

   ```
   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 fonction est créée avec :
   + **Runtime** — Python 3.13
   + **Handler** — La `lambda_handler` fonction dans `lambda_function.py`
   + **Mémoire** — 2048 Mo
   + **Stockage éphémère — 512** Mo
   + **Fournisseur de capacité** : liens vers le fournisseur de capacité que vous avez créé

### Étape 5 : Publier une version de fonction
<a name="lambda-managed-instances-step5-publish"></a>

Pour exécuter votre fonction sur des instances gérées Lambda, vous devez publier une version.

**Pour publier une version de fonction**

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

Cette commande publie la version 1 de votre fonction et la déploie auprès du fournisseur de capacité.

### Étape 6 : Invoquez votre fonction
<a name="lambda-managed-instances-step6-invoke"></a>

Après la publication, vous pouvez appeler votre fonction.

**Pour appeler votre fonction**

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

# View the response
cat response.json
```

La fonction s'exécute sur les EC2 instances gérées par votre fournisseur de capacité et renvoie une réponse.

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

Pour éviter d'encourir des frais, supprimez les ressources que vous avez créées :

1. Supprimez la fonction :

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

1. Supprimez le fournisseur de capacité :

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

1. Supprimez les ressources 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. Supprimez les rôles 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
   ```