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.

# Didacticiels pour Amazon ECS
<a name="ecs-tutorials"></a>

Les didacticiels suivants montrent comment exécuter les tâches courantes à l'aide d'Amazon ECS.

Vous pouvez utiliser l’un des didacticiels suivants pour en savoir plus sur la prise en main d’Amazon ECS.


| Aperçu du didacticiel | En savoir plus | 
| --- | --- | 
|  Démarrage avec Amazon ECS sur Fargate.  |  [Création d’une tâche Amazon ECS Linux pour Fargate](getting-started-fargate.md)  | 
|  Démarrage avec les conteneurs Windows sur Fargate.  |  [Création d’une tâche Windows Amazon ECS pour Fargate](Windows_fargate-getting_started.md)  | 
|  Démarrage avec les conteneurs Windows sur EC2.  |  [Création d’une tâche Windows Amazon ECS pour EC2](getting-started-ecs-ec2-v2.md)  | 

Vous pouvez utiliser l'un des didacticiels suivants pour déployer des tâches sur Amazon ECS à l'aide du AWS CLI


| Aperçu du didacticiel | En savoir plus | 
| --- | --- | 
|  Création d’une tâche Linux pour Fargate.  |  [Création d'une tâche Linux Amazon ECS pour le Fargate avec AWS CLI](ECS_AWSCLI_Fargate.md)  | 
|  Création d’une tâche Windows pour Fargate.  |  [Création d'une tâche Windows Amazon ECS pour le Fargate avec AWS CLI](ECS_AWSCLI_Fargate_windows.md)  | 
|  Création d’une tâche Linux pour EC2.  |  [Création d'une tâche Amazon ECS pour EC2 avec AWS CLI](ECS_AWSCLI_EC2.md)  | 

Vous pouvez utiliser l’un des didacticiels suivants pour en savoir plus sur la surveillance et la journalisation.


| Aperçu du didacticiel | En savoir plus | 
| --- | --- | 
|  Configurez une fonction Lambda simple qui écoute les événements des tâches et les écrit dans un flux de CloudWatch journal des journaux.  |  [Configuration d'Amazon ECS pour écouter CloudWatch les événements](ecs_cwet.md)  | 
|  Configurez une règle d' EventBridge événement Amazon qui capture uniquement les événements de tâche lorsque la tâche a cessé de s'exécuter parce que l'un de ses conteneurs essentiels s'est arrêté.   |  [Envoi d’alertes Amazon Simple Notification Service pour les événements de tâche Amazon ECS arrêtés](ecs_cwet2.md)  | 
|  Configuration de messages de journaux qui appartiennent à l’origine à un seul contexte, mais qui ont été divisés en plusieurs enregistrements ou lignes de journal.  |  [Concaténation des messages du journal Amazon ECS multiligne ou de suivi de pile](firelens-concatanate-multiline.md)  | 
|  Déployez des conteneurs Fluent Bit sur leurs instances Windows exécutées dans Amazon ECS pour diffuser les journaux générés par les tâches Windows vers Amazon afin CloudWatch de centraliser la journalisation.  |  [Déploiement de Fluent Bit sur Amazon ECS pour des conteneurs Windows](tutorial-deploy-fluentbit-on-windows.md)  | 

Vous pouvez utiliser l’un des didacticiels suivants pour en savoir plus sur l’utilisation de l’authentification Active Directory avec un compte de service géré de groupe sur Amazon ECS.


| Aperçu du didacticiel | En savoir plus | 
| --- | --- | 
|  Utilisation d’un compte de service géré de groupe avec des conteneurs Linux sur EC2.  |  [Utilisation de gMSA pour les conteneurs Linux EC2 sur Amazon ECS](linux-gmsa.md)  | 
|  Utilisation d’un compte de service géré de groupe avec des conteneurs Windows sur EC2.  |  [Utilisation des gMSA pour les conteneurs Windows EC2 pour Amazon ECS](windows-gmsa.md)  | 
|  Utilisation d’un compte de service géré de groupe avec des conteneurs Linux sur Fargate.  |  [Utilisation de gMSA pour les conteneurs Linux sur Fargate](fargate-linux-gmsa.md)  | 
|  Création d’une tâche qui exécute un conteneur Windows disposant des informations d’identification nécessaires pour accéder à Active Directory avec un compte de service géré de groupe sans domaine.  |  [Utilisation de conteneurs Windows Amazon ECS avec des conteneurs sans domaine à gMSA l'aide du AWS CLI](tutorial-gmsa-windows.md)  | 

# Création d'une tâche Linux Amazon ECS pour le Fargate avec AWS CLI
<a name="ECS_AWSCLI_Fargate"></a>

Les étapes suivantes vous aideront à configurer un cluster, enregistrer une définition de tâche, exécuter une tâche Linux et effectuer d'autres scénarios courants dans Amazon ECS avec la AWS CLI. Utilisez la version la plus récente de l’ AWS CLI. Pour savoir comment opérer une mise à niveau vers la dernière version, consultez la section [Installation ou mise à jour vers la dernière version de l’ AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

**Note**  
Vous pouvez utiliser des points de terminaison de service à double pile pour interagir avec Amazon ECS à partir de AWS CLI SDKs, et de l'API Amazon ECS via les deux IPv4 et. IPv6 Pour de plus amples informations, veuillez consulter [Utilisation des points de terminaison à double pile Amazon ECS](dual-stack-endpoint.md).

**Topics**
+ [

## Conditions préalables
](#ECS_AWSCLI_Fargate_prereq)
+ [

## Étape 1 : Créer un cluster
](#ECS_AWSCLI_Fargate_create_cluster)
+ [

## Étape 2 : Enregistrer une définition de tâche Linux
](#ECS_AWSCLI_Fargate_register_task_definition)
+ [

## Étape 3 : Répertorier les définitions de tâche
](#ECS_AWSCLI_Fargate_list_task_definitions)
+ [

## Étape 4 : Créer un service
](#ECS_AWSCLI_Fargate_create_service)
+ [

## Étape 5 : Répertorier les services
](#ECS_AWSCLI_Fargate_list_services)
+ [

## Étape 6 : Décrire le service en cours d'exécution
](#ECS_AWSCLI_Fargate_describe_service)
+ [

## Étape 7 : Test
](#ECS_AWSCLI_Fargate_test)
+ [

## Étape 8 : Nettoyer
](#ECS_AWSCLI_Fargate_clean_up)

## Conditions préalables
<a name="ECS_AWSCLI_Fargate_prereq"></a>

Le didacticiel suppose de remplir les prérequis suivants.
+ La dernière version du AWS CLI est installée et configurée. Pour plus d'informations sur l'installation ou la mise à niveau de votre AWS CLI, [Installation ou mise à jour vers la dernière version du AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Vous devez avoir suivi les étapes de [Configurer l'utilisation d'Amazon ECS](get-set-up-for-amazon-ecs.md).
+ Votre utilisateur IAM dispose des autorisations requises spécifiées dans l’exemple de politique IAM [Amazon ECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess).
+ Vous avez un créé un VPC et un groupe de sécurité prêts à être utilisés. Ce didacticiel utilise une image de conteneur hébergée sur Amazon ECR Public afin que votre tâche ait accès à Internet. Pour donner à votre tâche un itinéraire vers Internet, utilisez l'une des options suivantes.
  + Utilisez un sous-réseau privé avec une passerelle NAT dotée d'une adresse IP Elastic.
  + Utilisez un sous-réseau public et affectez une adresse IP publique à la tâche.

  Pour de plus amples informations, veuillez consulter [Créer un Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).

  Pour plus d'informations sur les groupes de sécurité et les règles, consultez les sections [Groupes de sécurité par défaut pour vous VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#DefaultSecurityGroup) et [Exemples de règles](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#security-group-rule-examples) dans le *guide de l'utilisateur d'Amazon Virtual Private Cloud*.
+  Si vous suivez ce didacticiel en utilisant un sous-réseau privé, vous pouvez utiliser Amazon ECS Exec pour interagir directement avec votre conteneur et tester le déploiement. Vous devez créer un rôle IAM de tâche pour utiliser ECS Exec. Pour plus d’informations sur le rôle IAM de tâche et les autres prérequis, consultez la section [Surveillance des conteneurs Amazon ECS avec Amazon ECS Exec](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-exec.html).
+ (Facultatif) AWS CloudShell est un outil qui fournit aux clients une ligne de commande sans avoir à créer leur propre instance EC2. Pour plus d'informations, voir [Qu'est-ce que c'est AWS CloudShell ?](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) dans le *guide de AWS CloudShell l'utilisateur*.

## Étape 1 : Créer un cluster
<a name="ECS_AWSCLI_Fargate_create_cluster"></a>

Par défaut, votre compte reçoit un cluster `default`.

**Note**  
L'utilisation du cluster `default` qui vous est fourni présente l'avantage que vous n'avez pas besoin de spécifier l'option `--cluster cluster_name` dans les commandes suivantes. Si vous créez votre propre cluster, sans valeur par défaut, vous devez spécifier `--cluster cluster_name` pour chaque commande que vous prévoyez d'utiliser avec ce cluster.

Créez votre propre cluster avec un nom unique à l'aide de la commande suivante :

```
aws ecs create-cluster --cluster-name fargate-cluster
```

Sortie :

```
{
    "cluster": {
        "status": "ACTIVE", 
        "defaultCapacityProviderStrategy": [], 
        "statistics": [], 
        "capacityProviders": [], 
        "tags": [], 
        "clusterName": "fargate-cluster", 
        "settings": [
            {
                "name": "containerInsights", 
                "value": "disabled"
            }
        ], 
        "registeredContainerInstancesCount": 0, 
        "pendingTasksCount": 0, 
        "runningTasksCount": 0, 
        "activeServicesCount": 0, 
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster"
    }
}
```

## Étape 2 : Enregistrer une définition de tâche Linux
<a name="ECS_AWSCLI_Fargate_register_task_definition"></a>

Avant de pouvoir exécuter une tâche sur votre cluster ECS, vous devez enregistrer une définition de tâche. Les définitions de tâches sont des listes de conteneurs regroupés ensemble. L'exemple suivant est une définition de tâche simple qui crée une application Web PHP à l'aide de l'image de conteneur httpd hébergée sur Docker Hub. Pour plus d'informations sur les paramètres de définition des tâches disponibles, consultez [Définitions de tâche Amazon ECS](task_definitions.md). Pour ce didacticiel, l'`taskRoleArn` n'est nécessaire que si vous déployez la tâche dans un sous-réseau privé et souhaitez tester le déploiement. Remplacez l'`taskRoleArn` par le rôle de tâche IAM que vous avez créé pour utiliser ECS Exec, comme indiqué dans [Conditions préalables](#ECS_AWSCLI_Fargate_prereq).

```
 {
        "family": "sample-fargate",
        "networkMode": "awsvpc",
        "taskRoleArn": "arn:aws:iam::aws_account_id:role/execCommandRole", 
        "containerDefinitions": [
            {
                "name": "fargate-app",
                "image": "public.ecr.aws/docker/library/httpd:latest",
                "portMappings": [
                    {
                        "containerPort": 80,
                        "hostPort": 80,
                        "protocol": "tcp"
                    }
                ],
                "essential": true,
                "entryPoint": [
                    "sh",
                    "-c"
                ],
                "command": [
                    "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
                ]
            }
        ],
        "requiresCompatibilities": [
            "FARGATE"
        ],
        "cpu": "256",
        "memory": "512"
}
```

Enregistrez la définition de tâche JSON sous forme de fichier et transmettez-la avec l'option `--cli-input-json file://path_to_file.json`. 

Pour utiliser un fichier JSON pour les définitions de conteneur :

```
aws ecs register-task-definition --cli-input-json file://$HOME/tasks/fargate-task.json
```

La commande **register-task-definition** renvoie une description de la définition de tâche une fois l'enregistrement terminé.

## Étape 3 : Répertorier les définitions de tâche
<a name="ECS_AWSCLI_Fargate_list_task_definitions"></a>

Vous pouvez répertorier les définitions de tâches de votre compte à tout moment à l'aide de la commande **list-task-definitions**. La sortie de cette commande affiche les valeurs `family` et `revision` que vous pouvez utiliser ensemble lorsque vous appelez **run-task** ou **start-task**.

```
aws ecs list-task-definitions
```

Sortie :

```
{
    "taskDefinitionArns": [
        "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1"
    ]
}
```

## Étape 4 : Créer un service
<a name="ECS_AWSCLI_Fargate_create_service"></a>

Une fois que vous avez enregistré une tâche pour votre compte, vous pouvez créer un service pour la tâche enregistrée dans votre cluster. Pour cet exemple, vous créez un service avec une instance de la définition de tâche `sample-fargate:1` exécutée dans votre cluster. La tâche nécessite un itinéraire vers Internet. Il y a deux façons d'y parvenir. Une façon consiste à utiliser un sous-réseau privé configuré avec une passerelle NAT avec une adresse IP Elastic dans un sous-réseau public. Une autre façon consiste à utiliser un sous-réseau public et à attribuer une adresse IP publique à votre tâche. Les deux exemples sont présentés ci-dessous. 

Exemple d'utilisation d'un sous-réseau privé. L'option ` enable-execute-command ` est nécessaire pour utiliser Amazon ECS Exec.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234]}" --enable-execute-command
```

Exemple d'utilisation d'un sous-réseau public.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234],assignPublicIp=ENABLED}"
```

La commande **create-service** renvoie une description de la définition de tâche une fois l'enregistrement terminé.

## Étape 5 : Répertorier les services
<a name="ECS_AWSCLI_Fargate_list_services"></a>

Affichez les services de votre cluster. Vous devriez voir le service que vous avez exécuté dans la section précédente. Vous pouvez noter le nom du service ou l'ARN complet qui est renvoyé par cette commande et l'utiliser pour décrire le service ultérieurement.

```
aws ecs list-services --cluster fargate-cluster
```

Sortie :

```
{
    "serviceArns": [
        "arn:aws:ecs:region:aws_account_id:service/fargate-cluster/fargate-service"
    ]
}
```

## Étape 6 : Décrire le service en cours d'exécution
<a name="ECS_AWSCLI_Fargate_describe_service"></a>

Décrivez le service à l'aide du nom de service récupéré précédemment afin d'obtenir plus d'informations sur la tâche.

```
aws ecs describe-services --cluster fargate-cluster --services fargate-service
```

En cas de réussite, une description des défaillances de service et des services est renvoyée. Par exemple, dans la section ` services `, vous trouverez des informations sur les déploiements, telles que le statut des tâches en cours d'exécution ou en attente. Vous trouverez également des informations sur la définition des tâches, la configuration réseau et les événements horodatés. Dans la section des défaillances, vous trouverez des informations sur les défaillances, le cas échéant, associées à l'appel. Pour le dépannage, consultez [Messages d'événements de service](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-event-messages.html). Pour de plus amples informations sur la description du service, consultez [Description des services](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeServices).

```
{
    "services": [
        {
            "networkConfiguration": {
                "awsvpcConfiguration": {
                    "subnets": [
                        "subnet-abcd1234"
                    ], 
                    "securityGroups": [
                        "sg-abcd1234"
                    ], 
                    "assignPublicIp": "ENABLED"
                }
            }, 
            "launchType": "FARGATE", 
            "enableECSManagedTags": false, 
            "loadBalancers": [], 
            "deploymentController": {
                "type": "ECS"
            }, 
            "desiredCount": 1, 
            "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster", 
            "serviceArn": "arn:aws:ecs:region:aws_account_id:service/fargate-service", 
            "deploymentConfiguration": {
                "maximumPercent": 200, 
                "minimumHealthyPercent": 100
            }, 
            "createdAt": 1692283199.771, 
            "schedulingStrategy": "REPLICA", 
            "placementConstraints": [], 
            "deployments": [
                {
                    "status": "PRIMARY", 
                    "networkConfiguration": {
                        "awsvpcConfiguration": {
                            "subnets": [
                                "subnet-abcd1234"
                            ], 
                            "securityGroups": [
                                "sg-abcd1234"
                            ], 
                            "assignPublicIp": "ENABLED"
                        }
                    }, 
                    "pendingCount": 0, 
                    "launchType": "FARGATE", 
                    "createdAt": 1692283199.771, 
                    "desiredCount": 1, 
                    "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1", 
                    "updatedAt": 1692283199.771, 
                    "platformVersion": "1.4.0", 
                    "id": "ecs-svc/9223370526043414679", 
                    "runningCount": 0
                }
            ], 
            "serviceName": "fargate-service", 
            "events": [
                {
                    "message": "(service fargate-service) has started 2 tasks: (task 53c0de40-ea3b-489f-a352-623bf1235f08) (task d0aec985-901b-488f-9fb4-61b991b332a3).", 
                    "id": "92b8443e-67fb-4886-880c-07e73383ea83", 
                    "createdAt": 1510811841.408
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task b4911bee-7203-4113-99d4-e89ba457c626) (task cc5853e3-6e2d-4678-8312-74f8a7d76474).", 
                    "id": "d85c6ec6-a693-43b3-904a-a997e1fc844d", 
                    "createdAt": 1510811601.938
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task cba86182-52bf-42d7-9df8-b744699e6cfc) (task f4c1ad74-a5c6-4620-90cf-2aff118df5fc).", 
                    "id": "095703e1-0ca3-4379-a7c8-c0f1b8b95ace", 
                    "createdAt": 1510811364.691
                }
            ], 
            "runningCount": 0, 
            "status": "ACTIVE", 
            "serviceRegistries": [], 
            "pendingCount": 0, 
            "createdBy": "arn:aws:iam::aws_account_id:user/user_name", 
            "platformVersion": "LATEST", 
            "placementStrategy": [], 
            "propagateTags": "NONE", 
            "roleArn": "arn:aws:iam::aws_account_id:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS", 
            "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1"
        }
    ], 
    "failures": []
}
```

## Étape 7 : Test
<a name="ECS_AWSCLI_Fargate_test"></a>

### Tâche de test déployée à l'aide d'un sous-réseau public
<a name="ECS_AWSCLI_Fargate_test_public"></a>

Décrivez la tâche dans le service afin que vous puissiez obtenir l'interface réseau Elastic (ENI) pour la tâche. 

Tout d'abord, obtenez l'ARN de la tâche.

```
aws ecs list-tasks --cluster fargate-cluster --service fargate-service
```

La sortie contient l'ARN de la tâche.

```
{
    "taskArns": [
        "arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE
    ]
}
```

Décrivez la tâche et localisez l'ID de l'ENI. Utilisez l'ARN de la tâche pour le paramètre `tasks`.

```
aws ecs describe-tasks --cluster fargate-cluster --tasks arn:aws:ecs:us-east-1:123456789012:task/service/EXAMPLE
```

Les informations concernant la pièce jointe sont répertoriées dans la sortie. 

```
{
    "tasks": [
        {
            "attachments": [
                {
                    "id": "d9e7735a-16aa-4128-bc7a-b2d5115029e9",
                    "type": "ElasticNetworkInterface",
                    "status": "ATTACHED",
                    "details": [
                        {
                            "name": "subnetId",
                            "value": "subnetabcd1234"
                        },
                        {
                            "name": "networkInterfaceId",
                            "value": "eni-0fa40520aeEXAMPLE"
                        },
                    ]
                }
…
}
```

Décrivez l'ENI pour obtenir l'adresse IP publique.

```
aws ec2 describe-network-interfaces --network-interface-id  eni-0fa40520aeEXAMPLE
```

L'adresse IP publique se trouve dans la sortie. 

```
{
    "NetworkInterfaces": [
        {
            "Association": {
                "IpOwnerId": "amazon",
                "PublicDnsName": "ec2-34-229-42-222.compute-1.amazonaws.com",
                "PublicIp": "198.51.100.2"
            },
…
}
```

Saisissez l'adresse IP publique dans votre navigateur web. Vous devriez voir une page web qui affiche l'exemple d'application **Amazon ECS**.

### Tâche de test déployée à l'aide d'un sous-réseau privé
<a name="ECS_AWSCLI_Fargate_test_private.title"></a>

 Décrivez la tâche et localisez `managedAgents` pour vérifier que `ExecuteCommandAgent` est en cours d'exécution. Notez `privateIPv4Address` pour une utilisation ultérieure.

```
aws ecs describe-tasks --cluster fargate-cluster --tasks arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE
```

 Les informations concernant l'agent géré sont répertoriées dans la sortie. 

```
{
     "tasks": [
        {
            "attachments": [
                {
                    "id": "d9e7735a-16aa-4128-bc7a-b2d5115029e9",
                    "type": "ElasticNetworkInterface",
                    "status": "ATTACHED",
                    "details": [
                        {
                            "name": "subnetId",
                            "value": "subnetabcd1234"
                        },
                        {
                            "name": "networkInterfaceId",
                            "value": "eni-0fa40520aeEXAMPLE"
                        },
                        {
                            "name": "privateIPv4Address",
                            "value": "10.0.143.156"
                        }
                    ]
                }
            ],
     ...  
     "containers": [
         {
         ...
        "managedAgents": [
                        {
                            "lastStartedAt": "2023-08-01T16:10:13.002000+00:00",
                            "name": "ExecuteCommandAgent",
                            "lastStatus": "RUNNING"
                        } 
                ],
        ...
    }
```

 Après avoir vérifié que ` ExecuteCommandAgent` est en cours d'exécution, vous pouvez exécuter la commande suivante pour exécuter un shell interactif sur le conteneur de la tâche. 

```
  aws ecs execute-command --cluster fargate-cluster \
      --task  arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE  \
      --container  fargate-app \
      --interactive \
      --command "/bin/sh"
```

 Une fois le shell interactif lancé, exécutez les commandes suivantes pour installer cURL. 

```
apt update 
```

```
apt install curl 
```

 Après avoir installé cURL, exécutez la commande suivante en utilisant l'adresse IP privée que vous avez obtenue précédemment.

```
 curl 10.0.143.156 
```

 Vous devriez voir l'équivalent HTML de la page Web d'exemple d'application **Amazon ECS**.

```
<html>
    <head> 
     <title>Amazon ECS Sample App</title> 
     <style>body {margin-top: 40px; background-color: #333;} </style>
    </head>
      <body> 
      <div style=color:white;text-align:center> 
      <h1>Amazon ECS Sample App</h1> 
      <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> 
      </div>
      </body>
</html>
```

## Étape 8 : Nettoyer
<a name="ECS_AWSCLI_Fargate_clean_up"></a>

Une fois que vous avez terminé ce didacticiel, vous devez nettoyer les ressources qui lui sont associées afin d'éviter la facturation de frais pour des ressources inutilisées.

Supprimez le service.

```
aws ecs delete-service --cluster fargate-cluster --service fargate-service --force
```

Supprimez le cluster.

```
aws ecs delete-cluster --cluster fargate-cluster
```

# Création d'une tâche Windows Amazon ECS pour le Fargate avec AWS CLI
<a name="ECS_AWSCLI_Fargate_windows"></a>

Les étapes suivantes vous aideront à configurer un cluster, enregistrer une définition de tâche, exécuter une tâche Windows et effectuer d'autres scénarios courants dans Amazon ECS avec la AWS CLI. Veillez à utiliser la dernière version de l' AWS CLI. Pour savoir comment opérer une mise à niveau vers la dernière version, consultez la section [Installation ou mise à jour vers la dernière version de l’ AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

**Note**  
Vous pouvez utiliser des points de terminaison de service à double pile pour interagir avec Amazon ECS à partir de AWS CLI SDKs, et de l'API Amazon ECS via les deux IPv4 et. IPv6 Pour de plus amples informations, veuillez consulter [Utilisation des points de terminaison à double pile Amazon ECS](dual-stack-endpoint.md).

**Topics**
+ [

## Conditions préalables
](#ECS_AWSCLI_Fargate_windows_prereq)
+ [

## Étape 1 : Créer un cluster
](#ECS_AWSCLI_Fargate_windows_create_cluster)
+ [

## Étape 2 : Enregistrement d'une définition de tâche Windows
](#ECS_AWSCLI_Fargate_windows_register_task_definition)
+ [

## Étape 3 : Répertorier les définitions de tâche
](#ECS_AWSCLI_Fargate_windows__list_task_definitions)
+ [

## Étape 4 : Créer un service
](#ECS_AWSCLI_Fargate_windows_create_service)
+ [

## Étape 5 : Répertorier les services
](#ECS_AWSCLI_Fargate_windows_list_services)
+ [

## Étape 6 : Décrire le service en cours d'exécution
](#ECS_AWSCLI_Fargate_windows_describe_service)
+ [

## Étape 7 : Nettoyer
](#ECS_AWSCLI_Fargate_windows_clean_up)

## Conditions préalables
<a name="ECS_AWSCLI_Fargate_windows_prereq"></a>

Le didacticiel suppose de remplir les prérequis suivants.
+ La dernière version du AWS CLI est installée et configurée. Pour plus d'informations sur l'[installation ou la mise à niveau de](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) votre AWS CLI AWS CLI.
+ Vous devez avoir suivi les étapes de [Configurer l'utilisation d'Amazon ECS](get-set-up-for-amazon-ecs.md).
+ Votre utilisateur IAM dispose des autorisations requises spécifiées dans l’exemple de politique IAM [Amazon ECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess).
+ Vous avez un créé un VPC et un groupe de sécurité prêts à être utilisés. Ce didacticiel utilise une image de conteneur hébergée sur Docker Hub afin que votre tâche ait accès à Internet. Pour donner à votre tâche un itinéraire vers Internet, utilisez l'une des options suivantes.
  + Utilisez un sous-réseau privé avec une passerelle NAT dotée d'une adresse IP Elastic.
  + Utilisez un sous-réseau public et affectez une adresse IP publique à la tâche.

  Pour de plus amples informations, veuillez consulter [Créer un Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).

  Pour plus d'informations sur les groupes de sécurité et les règles, consultez les sections [Groupes de sécurité par défaut pour vous VPCs](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#DefaultSecurityGroup) et [Exemples de règles](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#security-group-rule-examples) dans le *guide de l'utilisateur d'Amazon Virtual Private Cloud*.
+ (Facultatif) AWS CloudShell est un outil qui fournit aux clients une ligne de commande sans avoir à créer leur propre instance EC2. Pour plus d'informations, voir [Qu'est-ce que c'est AWS CloudShell ?](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) dans le *guide de AWS CloudShell l'utilisateur*.

## Étape 1 : Créer un cluster
<a name="ECS_AWSCLI_Fargate_windows_create_cluster"></a>

Par défaut, votre compte reçoit un cluster `default`.

**Note**  
L'utilisation du cluster `default` qui vous est fourni présente l'avantage que vous n'avez pas besoin de spécifier l'option `--cluster cluster_name` dans les commandes suivantes. Si vous créez votre propre cluster, sans valeur par défaut, vous devez spécifier `--cluster cluster_name` pour chaque commande que vous prévoyez d'utiliser avec ce cluster.

Créez votre propre cluster avec un nom unique à l'aide de la commande suivante :

```
aws ecs create-cluster --cluster-name fargate-cluster
```

Sortie :

```
{
    "cluster": {
        "status": "ACTIVE", 
        "statistics": [], 
        "clusterName": "fargate-cluster", 
        "registeredContainerInstancesCount": 0, 
        "pendingTasksCount": 0, 
        "runningTasksCount": 0, 
        "activeServicesCount": 0, 
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster"
    }
}
```

## Étape 2 : Enregistrement d'une définition de tâche Windows
<a name="ECS_AWSCLI_Fargate_windows_register_task_definition"></a>

Avant de pouvoir exécuter une tâche Windows sur votre cluster Amazon ECS, vous devez enregistrer une définition de tâche. Les définitions de tâches sont des listes de conteneurs regroupés ensemble. L'exemple suivant est une simple définition de tâche qui crée une application web. Pour plus d'informations sur les paramètres de définition des tâches disponibles, consultez [Définitions de tâche Amazon ECS](task_definitions.md).

```
{
    "containerDefinitions": [
        {
            "command": ["New-Item -Path C:\\inetpub\\wwwroot\\index.html -Type file -Value '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p>'; C:\\ServiceMonitor.exe w3svc"],
            "entryPoint": [
                "powershell",
                "-Command"
            ],
            "essential": true,
            "cpu": 2048,
            "memory": 4096,
            "image": "mcr.microsoft.com/windows/servercore/iis:windowsservercore-ltsc2019",
            "name": "sample_windows_app",
            "portMappings": [
                {
                    "hostPort": 80,
                    "containerPort": 80,
                    "protocol": "tcp"
                }
            ]
        }
    ],
    "memory": "4096",
    "cpu": "2048",
    "networkMode": "awsvpc",
    "family": "windows-simple-iis-2019-core",
    "executionRoleArn": "arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
    "runtimePlatform": {"operatingSystemFamily": "WINDOWS_SERVER_2019_CORE"},
    "requiresCompatibilities": ["FARGATE"]
}
```

L'exemple JSON ci-dessus peut être transmis AWS CLI au de deux manières : vous pouvez enregistrer la définition de tâche JSON sous forme de fichier et la transmettre avec l'`--cli-input-json file://path_to_file.json`option.

Pour utiliser un fichier JSON pour les définitions de conteneur :

```
aws ecs register-task-definition --cli-input-json file://$HOME/tasks/fargate-task.json
```

La commande **register-task-definition** renvoie une description de la définition de tâche une fois l'enregistrement terminé.

## Étape 3 : Répertorier les définitions de tâche
<a name="ECS_AWSCLI_Fargate_windows__list_task_definitions"></a>

Vous pouvez répertorier les définitions de tâches de votre compte à tout moment à l'aide de la commande **list-task-definitions**. La sortie de cette commande affiche les valeurs `family` et `revision` que vous pouvez utiliser ensemble lorsque vous appelez **run-task** ou **start-task**.

```
aws ecs list-task-definitions
```

Sortie :

```
{
    "taskDefinitionArns": [
        "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate-windows:1"
    ]
}
```

## Étape 4 : Créer un service
<a name="ECS_AWSCLI_Fargate_windows_create_service"></a>

Une fois que vous avez enregistré une tâche pour votre compte, vous pouvez créer un service pour la tâche enregistrée dans votre cluster. Pour cet exemple, vous créez un service avec une instance de la définition de tâche `sample-fargate:1` exécutée dans votre cluster. La tâche nécessite un itinéraire vers Internet. Il y a deux façons d'y parvenir. Une façon consiste à utiliser un sous-réseau privé configuré avec une passerelle NAT avec une adresse IP Elastic dans un sous-réseau public. Une autre façon consiste à utiliser un sous-réseau public et à attribuer une adresse IP publique à votre tâche. Les deux exemples sont présentés ci-dessous. 

Exemple d'utilisation d'un sous-réseau privé.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate-windows:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234]}"
```

Exemple d'utilisation d'un sous-réseau public.

```
aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate-windows:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234],assignPublicIp=ENABLED}"
```

La commande **create-service** renvoie une description de la définition de tâche une fois l'enregistrement terminé.

## Étape 5 : Répertorier les services
<a name="ECS_AWSCLI_Fargate_windows_list_services"></a>

Affichez les services de votre cluster. Vous devriez voir le service que vous avez exécuté dans la section précédente. Vous pouvez noter le nom du service ou l'ARN complet qui est renvoyé par cette commande et l'utiliser pour décrire le service ultérieurement.

```
aws ecs list-services --cluster fargate-cluster
```

Sortie :

```
{
    "serviceArns": [
        "arn:aws:ecs:region:aws_account_id:service/fargate-service"
    ]
}
```

## Étape 6 : Décrire le service en cours d'exécution
<a name="ECS_AWSCLI_Fargate_windows_describe_service"></a>

Décrivez le service à l'aide du nom de service récupéré précédemment afin d'obtenir plus d'informations sur la tâche.

```
aws ecs describe-services --cluster fargate-cluster --services fargate-service
```

En cas de réussite, une description des défaillances de service et des services est renvoyée. Par exemple, dans la section des services, vous trouverez des informations sur les déploiements, telles que le statut des tâches en cours d'exécution ou en attente. Vous trouverez également des informations sur la définition des tâches, la configuration réseau et les événements horodatés. Dans la section des défaillances, vous trouverez des informations sur les défaillances, le cas échéant, associées à l'appel. Pour le dépannage, consultez [Messages d'événements de service](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-event-messages.html). Pour de plus amples informations sur la description du service, consultez [Description des services](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeServices). 

```
{
    "services": [
        {
            "status": "ACTIVE", 
            "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate-windows:1", 
            "pendingCount": 2, 
            "launchType": "FARGATE", 
            "loadBalancers": [], 
            "roleArn": "arn:aws:iam::aws_account_id:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS", 
            "placementConstraints": [], 
            "createdAt": 1510811361.128, 
            "desiredCount": 2, 
            "networkConfiguration": {
                "awsvpcConfiguration": {
                    "subnets": [
                        "subnet-abcd1234"
                    ], 
                    "securityGroups": [
                        "sg-abcd1234"
                    ], 
                    "assignPublicIp": "DISABLED"
                }
            }, 
            "platformVersion": "LATEST", 
            "serviceName": "fargate-service", 
            "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster", 
            "serviceArn": "arn:aws:ecs:region:aws_account_id:service/fargate-service", 
            "deploymentConfiguration": {
                "maximumPercent": 200, 
                "minimumHealthyPercent": 100
            }, 
            "deployments": [
                {
                    "status": "PRIMARY", 
                    "networkConfiguration": {
                        "awsvpcConfiguration": {
                            "subnets": [
                                "subnet-abcd1234"
                            ], 
                            "securityGroups": [
                                "sg-abcd1234"
                            ], 
                            "assignPublicIp": "DISABLED"
                        }
                    }, 
                    "pendingCount": 2, 
                    "launchType": "FARGATE", 
                    "createdAt": 1510811361.128, 
                    "desiredCount": 2, 
                    "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate-windows:1", 
                    "updatedAt": 1510811361.128, 
                    "platformVersion": "0.0.1", 
                    "id": "ecs-svc/9223370526043414679", 
                    "runningCount": 0
                }
            ], 
            "events": [
                {
                    "message": "(service fargate-service) has started 2 tasks: (task 53c0de40-ea3b-489f-a352-623bf1235f08) (task d0aec985-901b-488f-9fb4-61b991b332a3).", 
                    "id": "92b8443e-67fb-4886-880c-07e73383ea83", 
                    "createdAt": 1510811841.408
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task b4911bee-7203-4113-99d4-e89ba457c626) (task cc5853e3-6e2d-4678-8312-74f8a7d76474).", 
                    "id": "d85c6ec6-a693-43b3-904a-a997e1fc844d", 
                    "createdAt": 1510811601.938
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task cba86182-52bf-42d7-9df8-b744699e6cfc) (task f4c1ad74-a5c6-4620-90cf-2aff118df5fc).", 
                    "id": "095703e1-0ca3-4379-a7c8-c0f1b8b95ace", 
                    "createdAt": 1510811364.691
                }
            ], 
            "runningCount": 0, 
            "placementStrategy": []
        }
    ], 
    "failures": []
}
```

## Étape 7 : Nettoyer
<a name="ECS_AWSCLI_Fargate_windows_clean_up"></a>

Une fois que vous avez terminé ce didacticiel, vous devez nettoyer les ressources qui lui sont associées afin d'éviter la facturation de frais pour des ressources inutilisées.

Supprimez le service.

```
aws ecs delete-service --cluster fargate-cluster --service fargate-service --force
```

Supprimez le cluster.

```
aws ecs delete-cluster --cluster fargate-cluster
```

# Création d'une tâche Amazon ECS pour EC2 avec AWS CLI
<a name="ECS_AWSCLI_EC2"></a>

Les étapes suivantes vous aideront à configurer un cluster, enregistrer une définition de tâche, exécuter une tâche et effectuer d'autres scénarios courants dans Amazon ECS avec la AWS CLI. Utilisez la version la plus récente de l’ AWS CLI. Pour savoir comment opérer une mise à niveau vers la dernière version, consultez la section [Installation ou mise à jour vers la dernière version de l’ AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

**Note**  
Vous pouvez utiliser des points de terminaison de service à double pile pour interagir avec Amazon ECS à partir de AWS CLI SDKs, et de l'API Amazon ECS via les deux IPv4 et. IPv6 Pour de plus amples informations, veuillez consulter [Utilisation des points de terminaison à double pile Amazon ECS](dual-stack-endpoint.md).

**Topics**
+ [

## Conditions préalables
](#AWSCLI_EC2_prereq)
+ [

## Créer un cluster
](#AWSCLI_EC2_create_cluster)
+ [

## Lancement d’une instance de conteneur avec l’AMI Amazon ECS
](#AWSCLI_EC2_launch_container_instance)
+ [

## Liste des instances de conteneur
](#AWSCLI_EC2_list_container_instances)
+ [

## Description de votre instance de conteneur
](#AWSCLI_EC2_describe_container_instance)
+ [

## Enregistrement d’une définition de tâche
](#AWSCLI_EC2_register_task_definition)
+ [

## Liste des définitions de tâche
](#AWSCLI_EC2_list_task_definitions)
+ [

## Créer un service
](#AWSCLI_EC2_run_task)
+ [

## Liste des services
](#AWSCLI_EC2_list_tasks)
+ [

## Description des services
](#AWSCLI_EC2_describe_service)
+ [

## Description de la tâche en cours d’exécution
](#AWSCLI_EC2_describe_task)
+ [

## Test du service Web
](#AWSCLI_EC2_test_web_server)
+ [

## nettoyer des ressources ;
](#AWSCLI_EC2_clean_up_resources)

## Conditions préalables
<a name="AWSCLI_EC2_prereq"></a>

Le didacticiel suppose de remplir les prérequis suivants :
+ La dernière version du AWS CLI est installée et configurée. Pour plus d'informations sur l'[installation ou la mise à niveau de](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) votre AWS CLI AWS CLI.
+ Vous devez avoir suivi les étapes de [Configurer l'utilisation d'Amazon ECS](get-set-up-for-amazon-ecs.md).
+ Votre utilisateur IAM dispose des autorisations requises spécifiées dans l’exemple de politique IAM [Amazon ECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess).
+ Un rôle IAM d’instance de conteneur a été créé pour être utilisé. Pour en savoir plus, consultez[Rôle IAM d'instance de conteneur Amazon ECS](instance_IAM_role.md).
+ Vous disposez d’un VPC créé pour être utilisé. Pour de plus amples informations, veuillez consulter [Créer un Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ (Facultatif) AWS CloudShell est un outil qui fournit aux clients une ligne de commande sans avoir à créer leur propre instance EC2. Pour plus d'informations, voir [Qu'est-ce que c'est AWS CloudShell ?](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) dans le *guide de AWS CloudShell l'utilisateur*.

## Créer un cluster
<a name="AWSCLI_EC2_create_cluster"></a>

Par défaut, votre compte reçoit un cluster `default` lorsque vous lancez votre première instance de conteneur.

**Note**  
L'utilisation du cluster `default` qui vous est fourni présente l'avantage que vous n'avez pas besoin de spécifier l'option `--cluster cluster_name` dans les commandes suivantes. Si vous créez votre propre cluster, sans valeur par défaut, vous devez spécifier `--cluster cluster_name` pour chaque commande que vous prévoyez d'utiliser avec ce cluster.

Créez votre propre cluster avec un nom unique à l'aide de la commande suivante :

```
aws ecs create-cluster --cluster-name MyCluster
```

Sortie :

```
{
    "cluster": {
        "clusterName": "MyCluster",
        "status": "ACTIVE",
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/MyCluster"
    }
}
```

## Lancement d’une instance de conteneur avec l’AMI Amazon ECS
<a name="AWSCLI_EC2_launch_container_instance"></a>

Les instances de conteneur sont des instances EC2 qui exécutent l’agent de conteneur Amazon ECS et ont été enregistrées dans un cluster. Dans cette section, vous allez lancer une instance EC2 à l’aide de l’AMI optimisée pour ECS.

**Pour lancer une instance de conteneur avec AWS CLI**

1. Récupérez le dernier ID AMI Amazon Linux 2 optimisé pour ECS à Région AWS l'aide de la commande suivante. Cette commande utilise le AWS Systems Manager Parameter Store pour obtenir le dernier ID d'AMI optimisé pour ECS. L’AMI inclut l’agent de conteneur Amazon ECS et l’exécution Docker préinstallés.

   ```
   aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2/recommended --query 'Parameters[0].Value' --output text | jq -r '.image_id'
   ```

   Sortie :

   ```
   ami-abcd1234
   ```

1. Créez un groupe de sécurité qui autorise l’accès SSH pour gérer votre instance de conteneur et l’accès HTTP pour le serveur Web.

   ```
   aws ec2 create-security-group --group-name ecs-tutorial-sg --description "ECS tutorial security group"
   ```

   Sortie :

   ```
   {
       "GroupId": "sg-abcd1234"
   }
   ```

1. Ajoutez une règle entrante au groupe de sécurité en exécutant la commande suivante.

   ```
   aws ec2 authorize-security-group-ingress --group-id sg-abcd1234 --protocol tcp --port 80 --cidr 0.0.0.0/0
   ```

   Sortie :

   ```
   {
       "Return": true,
       "SecurityGroupRules": [
           {
               "SecurityGroupRuleId": "sgr-efgh5678",
               "GroupId": "sg-abcd1234",
               "GroupOwnerId": "123456789012",
               "IsEgress": false,
               "IpProtocol": "tcp",
               "FromPort": 80,
               "ToPort": 80,
               "CidrIpv4": "0.0.0.0/0"
           }
       ]
   }
   ```

   Le groupe de sécurité autorise désormais l’accès SSH depuis la plage d’adresses IP spécifiée et l’accès HTTP depuis n’importe où. Dans un environnement de production, vous devez restreindre l’accès SSH à votre adresse IP spécifique et envisager de limiter l’accès HTTP selon les besoins.

1. Créez une paire de clés EC2 pour l’accès SSH à votre instance de conteneur.

   ```
   aws ec2 create-key-pair --key-name ecs-tutorial-key --query 'KeyMaterial' --output text > ecs-tutorial-key.pem
   chmod 400 ecs-tutorial-key.pem
   ```

   La clé privée est enregistrée sur votre ordinateur local avec les autorisations d’accès SSH appropriées.

1. Lancez une instance EC2 à l’aide de l’AMI optimisée pour ECS et configurez-la pour rejoindre votre cluster.

   ```
   aws ec2 run-instances --image-id ami-abcd1234 --instance-type t3.micro --key-name ecs-tutorial-key --security-group-ids sg-abcd1234 --iam-instance-profile Name=ecsInstanceRole --user-data '#!/bin/bash
   echo ECS_CLUSTER=MyCluster >> /etc/ecs/ecs.config'
   {
       "Instances": [
           {
               "InstanceId": "i-abcd1234",
               "ImageId": "ami-abcd1234",
               "State": {
                   "Code": 0,
                   "Name": "pending"
               },
               "PrivateDnsName": "",
               "PublicDnsName": "",
               "StateReason": {
                   "Code": "pending",
                   "Message": "pending"
               },
               "InstanceType": "t3.micro",
               "KeyName": "ecs-tutorial-key",
               "LaunchTime": "2025-01-13T10:30:00.000Z"
           }
       ]
   }
   ```

   Le script de données utilisateur configure l’agent Amazon ECS pour enregistrer l’instance auprès de votre `MyCluster`. L’instance utilise le rôle IAM `ecsInstanceRole`, qui fournit les autorisations nécessaires à l’agent.

## Liste des instances de conteneur
<a name="AWSCLI_EC2_list_container_instances"></a>

Quelques minutes après le lancement de votre instance de conteneur, l'agent Amazon ECS enregistre l'instance auprès de votre MyCluster cluster. Vous pouvez afficher les instances de conteneur d'un cluster en exécutant la commande suivante :

```
aws ecs list-container-instances --cluster MyCluster
```

Sortie :

```
{
    "containerInstanceArns": [
        "arn:aws:ecs:us-east-1:aws_account_id:container-instance/container_instance_ID"
    ]
}
```

## Description de votre instance de conteneur
<a name="AWSCLI_EC2_describe_container_instance"></a>

Après avoir obtenu l'ARN ou l'ID d'une instance de conteneur, vous pouvez utiliser la commande **describe-container-instances** pour obtenir des informations importantes sur l'instance, comme les ressources UC et de mémoire restantes et enregistrées.

```
aws ecs describe-container-instances --cluster MyCluster --container-instances container_instance_ID
```

Sortie :

```
{
    "failures": [],
    "containerInstances": [
        {
            "status": "ACTIVE",
            "registeredResources": [
                {
                    "integerValue": 1024,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "CPU",
                    "doubleValue": 0.0
                },
                {
                    "integerValue": 995,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "MEMORY",
                    "doubleValue": 0.0
                },
                {
                    "name": "PORTS",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [
                        "22",
                        "2376",
                        "2375",
                        "51678"
                    ],
                    "type": "STRINGSET",
                    "integerValue": 0
                },
                {
                    "name": "PORTS_UDP",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [],
                    "type": "STRINGSET",
                    "integerValue": 0
                }
            ],
            "ec2InstanceId": "instance_id",
            "agentConnected": true,
            "containerInstanceArn": "arn:aws:ecs:us-west-2:aws_account_id:container-instance/container_instance_ID",
            "pendingTasksCount": 0,
            "remainingResources": [
                {
                    "integerValue": 1024,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "CPU",
                    "doubleValue": 0.0
                },
                {
                    "integerValue": 995,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "MEMORY",
                    "doubleValue": 0.0
                },
                {
                    "name": "PORTS",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [
                        "22",
                        "2376",
                        "2375",
                        "51678"
                    ],
                    "type": "STRINGSET",
                    "integerValue": 0
                },
                {
                    "name": "PORTS_UDP",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [],
                    "type": "STRINGSET",
                    "integerValue": 0
                }
            ],
            "runningTasksCount": 0,
            "attributes": [
                {
                    "name": "com.amazonaws.ecs.capability.privileged-container"
                },
                {
                    "name": "com.amazonaws.ecs.capability.docker-remote-api.1.17"
                },
                {
                    "name": "com.amazonaws.ecs.capability.docker-remote-api.1.18"
                },
                {
                    "name": "com.amazonaws.ecs.capability.docker-remote-api.1.19"
                },
                {
                    "name": "com.amazonaws.ecs.capability.logging-driver.json-file"
                },
                {
                    "name": "com.amazonaws.ecs.capability.logging-driver.syslog"
                }
            ],
            "versionInfo": {
                "agentVersion": "1.5.0",
                "agentHash": "b197edd",
                "dockerVersion": "DockerVersion: 1.7.1"
            }
        }
    ]
}
```

Vous pouvez également trouver l'ID d'instance Amazon EC2 que vous pouvez utiliser pour surveiller l'instance dans la console Amazon EC2 ou avec la commande **aws ec2 describe-instances --instance-id *instance\$1id***.

## Enregistrement d’une définition de tâche
<a name="AWSCLI_EC2_register_task_definition"></a>

Avant de pouvoir exécuter une tâche sur votre cluster Amazon ECS, vous devez enregistrer une définition de tâche. Les définitions de tâches sont des listes de conteneurs regroupés ensemble. L’exemple suivant est une définition de tâche simple qui utilise une image `nginx`. Pour plus d'informations sur les paramètres de définition des tâches disponibles, consultez [Définitions de tâche Amazon ECS](task_definitions.md).

```
{
    "family": "nginx-task",
    "containerDefinitions": [
        {
            "name": "nginx",
            "image": "public.ecr.aws/ecs-sample-image/amazon-ecs-sample:latest",
            "cpu": 256,
            "memory": 512,
            "essential": true,
            "portMappings": [
                {
                    "containerPort": 80,
                    "hostPort": 80,
                    "protocol": "tcp"
                }
            ]
        }
    ],
    "requiresCompatibilities": ["EC2"],
    "networkMode": "bridge"
}
```

L'exemple JSON ci-dessus peut être transmis AWS CLI au de deux manières : vous pouvez enregistrer la définition de tâche JSON sous forme de fichier et la transmettre avec l'`--cli-input-json file://path_to_file.json`option. Vous pouvez également utiliser un caractère d’échappement pour les guillemets dans le fichier JSON et transmettre les définitions de conteneur JSON sur la ligne de commande. Si vous choisissez de transmettre les définitions de conteneur sur la ligne de commande, votre commande nécessite également un paramètre `--family` qui permet de conserver plusieurs versions de votre définition de tâche associées les unes aux autres.

Pour utiliser un fichier JSON pour les définitions de conteneur :

```
aws ecs register-task-definition --cli-input-json file://$HOME/tasks/nginx.json
```

La commande **register-task-definition** renvoie une description de la définition de tâche une fois l'enregistrement terminé.

```
{
    "taskDefinition": {
        "taskDefinitionArn": "arn:aws:ecs:us-east-1:123456789012:task-definition/nginx-task:1",
        "family": "nginx-task",
        "revision": 1,
        "status": "ACTIVE",
        "containerDefinitions": [
            {
                "name": "nginx",
                "image": "public.ecr.aws/docker/library/nginx:latest",
                "cpu": 256,
                "memory": 512,
                "essential": true,
                "portMappings": [
                    {
                        "containerPort": 80,
                        "hostPort": 80,
                        "protocol": "tcp"
                    }
                ],
                "environment": [],
                "mountPoints": [],
                "volumesFrom": []
            }
        ],
        "volumes": [],
        "networkMode": "bridge",
        "compatibilities": [
            "EC2"
        ],
        "requiresCompatibilities": [
            "EC2"
        ]
    }
}
```

## Liste des définitions de tâche
<a name="AWSCLI_EC2_list_task_definitions"></a>

Vous pouvez répertorier les définitions de tâches de votre compte à tout moment à l'aide de la commande **list-task-definitions**. La sortie de cette commande affiche les valeurs `family` et `revision` que vous pouvez utiliser ensemble lorsque vous appelez **create-service**.

```
aws ecs list-task-definitions
```

Sortie :

```
{
    "taskDefinitionArns": [
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/sleep360:1",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/sleep360:2",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/nginx-task:1",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:3",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:4",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:5",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:6"
    ]
}
```

## Créer un service
<a name="AWSCLI_EC2_run_task"></a>

Après avoir enregistré une tâche pour votre compte et lancé une instance de conteneur enregistrée dans votre cluster, vous pouvez créer un service Amazon ECS qui exécute et gère le nombre souhaité de tâches simultanément à l’aide de la définition de tâche que vous avez enregistrée. Dans cet exemple, vous placez une seule instance de la définition de `nginx:1` tâche dans votre MyCluster cluster.

```
aws ecs create-service --cluster MyCluster --service-name nginx-service --task-definition nginx-task:1 --desired-count 1
```

Sortie :

```
{
    "service": {
        "serviceArn": "arn:aws:ecs:us-east-1:aws_account_id:service/MyCluster/nginx-service",
        "serviceName": "nginx-service",
        "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
        "taskDefinition": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
        "desiredCount": 1,
        "runningCount": 0,
        "pendingCount": 0,
        "launchType": "EC2",
        "status": "ACTIVE",
        "createdAt": "2025-01-13T10:45:00.000Z"
    }
}
```

## Liste des services
<a name="AWSCLI_EC2_list_tasks"></a>

Affichez les services de votre cluster. Vous devriez voir le service que vous avez exécuté dans la section précédente. Vous pouvez noter l’ID du service ou l’ARN complet qui est renvoyé par cette commande et l’utiliser pour décrire le service ultérieurement.

```
aws ecs list-services --cluster MyCluster
```

Sortie :

```
{
    "taskArns": [
        "arn:aws:ecs:us-east-1:aws_account_id:task/task_ID"
    ]
}
```

## Description des services
<a name="AWSCLI_EC2_describe_service"></a>

Décrivez le service à l’aide de la commande suivante pour obtenir plus d’informations sur le service.

```
aws ecs describe-services --cluster MyCluster --services nginx-service
```

Sortie :

```
{
    "services": [
        {
            "serviceArn": "arn:aws:ecs:us-east-1:aws_account_id:service/MyCluster/nginx-service",
            "serviceName": "nginx-service",
            "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
            "taskDefinition": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
            "desiredCount": 1,
            "runningCount": 1,
            "pendingCount": 0,
            "launchType": "EC2",
            "status": "ACTIVE",
            "createdAt": "2025-01-13T10:45:00.000Z",
            "events": [
                {
                    "id": "abcd1234-5678-90ab-cdef-1234567890ab",
                    "createdAt": "2025-01-13T10:45:30.000Z",
                    "message": "(service nginx-service) has started 1 tasks: (task abcd1234-5678-90ab-cdef-1234567890ab)."
                }
            ]
        }
    ]
}
```

## Description de la tâche en cours d’exécution
<a name="AWSCLI_EC2_describe_task"></a>

Après avoir décrit le service, exécutez la commande suivante pour obtenir plus d’informations sur la tâche en cours d’exécution dans le cadre de votre service.

```
aws ecs list-tasks --cluster MyCluster --service-name nginx-service
```

 Sortie : 

```
{
    "tasks": [
        {
            "taskArn": "arn:aws:ecs:us-east-1:aws_account_id:task/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
            "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
            "taskDefinitionArn": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
            "containerInstanceArn": "arn:aws:ecs:us-east-1:aws_account_id:container-instance/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
            "lastStatus": "RUNNING",
            "desiredStatus": "RUNNING",
            "containers": [
                {
                    "containerArn": "arn:aws:ecs:us-east-1:aws_account_id:container/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab/abcd1234-5678-90ab-cdef-1234567890ab",
                    "taskArn": "arn:aws:ecs:us-east-1:aws_account_id:task/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
                    "name": "nginx",
                    "lastStatus": "RUNNING",
                    "networkBindings": [
                        {
                            "bindIP": "0.0.0.0",
                            "containerPort": 80,
                            "hostPort": 80,
                            "protocol": "tcp"
                        }
                    ]
                }
            ],
            "createdAt": "2025-01-13T10:45:00.000Z",
            "startedAt": "2025-01-13T10:45:30.000Z"
        }
    ]
}
```

## Test du service Web
<a name="AWSCLI_EC2_test_web_server"></a>

**Pour tester le serveur Web**

1. Récupérez l’adresse IP publique de votre instance de conteneur en exécutant la commande suivante.

   ```
   aws ec2 describe-instances --instance-ids i-abcd1234 --query 'Reservations[0].Instances[0].PublicIpAddress' --output text
   ```

   Sortie :

   ```
   203.0.113.25
   ```

1. Après avoir récupéré l’adresse IP, exécutez la commande `curl` suivante avec l’adresse IP.

   ```
   curl http://203.0.113.25
   ```

   Sortie :

   ```
   <!DOCTYPE html>
   <html>
   <head>
   <title>Welcome to nginx!</title>
   ...
   </head>
   <body>
   <h1>Welcome to nginx!</h1>
   <p>If you can see this page, the nginx web server is successfully installed and working.</p>
   ...
   </body>
   </html>
   ```

   La page d’accueil de nginx confirme que votre service fonctionne correctement et est accessible depuis Internet.

## nettoyer des ressources ;
<a name="AWSCLI_EC2_clean_up_resources"></a>

Pour éviter des frais supplémentaires, supprimez les ressources que vous avez créées dans ce didacticiel.

**Pour nettoyer des ressources**

1. Mettez à jour le service pour qu’il n’y ait aucune tâche souhaitée, puis supprimez-le.

   ```
   aws ecs update-service --cluster MyCluster --service nginx-service --desired-count 0
   {
       "service": {
           "serviceArn": "arn:aws:ecs:us-east-1:123456789012:service/MyCluster/nginx-service",
           "serviceName": "nginx-service",
           "desiredCount": 0,
           "runningCount": 1,
           "pendingCount": 0,
           "status": "ACTIVE"
       }
   }
   ```

1. Attendez que les tâches en cours d’exécution s’arrêtent, puis supprimez le service.

   ```
   aws ecs delete-service --cluster MyCluster --service nginx-service
   {
       "service": {
           "serviceArn": "arn:aws:ecs:us-east-1:123456789012:service/MyCluster/nginx-service",
           "serviceName": "nginx-service",
           "status": "DRAINING"
       }
   }
   ```

1. Résiliez l’instance de conteneur que vous avez créée.

   ```
   aws ec2 terminate-instances --instance-ids i-abcd1234
   {
       "TerminatingInstances": [
           {
               "InstanceId": "i-abcd1234",
               "CurrentState": {
                   "Code": 32,
                   "Name": "shutting-down"
               },
               "PreviousState": {
                   "Code": 16,
                   "Name": "running"
               }
           }
       ]
   }
   ```

1. Nettoyez le groupe de sécurité et la paire de clés que vous avez créés.

   ```
   aws ec2 delete-security-group --group-id sg-abcd1234
   aws ec2 delete-key-pair --key-name ecs-tutorial-key
   rm ecs-tutorial-key.pem
   ```

1. Supprimez le cluster Amazon ECS.

   ```
   aws ecs delete-cluster --cluster MyCluster
   {
       "cluster": {
           "clusterArn": "arn:aws:ecs:us-east-1:123456789012:cluster/MyCluster",
           "clusterName": "MyCluster",
           "status": "INACTIVE"
       }
   }
   ```

# Configuration d'Amazon ECS pour écouter CloudWatch les événements
<a name="ecs_cwet"></a>

Découvrez comment configurer une fonction Lambda simple qui écoute les événements des tâches et les enregistre dans un flux de CloudWatch journal des journaux.

## Prérequis : Configuration d'un cluster test
<a name="cwet_step_1"></a>

Si vous ne possédez pas de cluster en cours d'exécution à partir duquel capturer des événements, suivez les étapes dans [Création d’un cluster Amazon ECS pour les charges de travail Fargate](create-cluster-console-v2.md) pour en créer un. À la fin de ce didacticiel, vous exécutez une tâche sur ce cluster pour tester que la configuration de votre fonction Lambda est correcte. 

## Étape 1 : Créer la fonction Lambda
<a name="cwet_step_2"></a>

Au cours de cette procédure, vous allez créer une fonction Lambda simple à utiliser comme cible pour les messages de flux d'événements Amazon ECS. 

1. Ouvrez la AWS Lambda console à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. Sélectionnez **Create function** (Créer une fonction). 

1. Dans l'écran **Author from scratch** (Créer à partir de zéro), procédez comme suit :

   1. Pour **Name** (Nom), saisissez une valeur. 

   1. Pour **Runtime** (Exécution), choisissez votre version de Python, par exemple, **Python 3.9**.

   1. Pour **Role** (Rôle), choisissez **Create a new role with basic Lambda permissions** (Créer un nouveau rôle avec les autorisations Lambda de base).

1. Sélectionnez **Create function** (Créer une fonction).

1. Dans la section **Code de fonction**, modifiez l'exemple de code selon l'exemple suivant :

   ```
   import json
   
   def lambda_handler(event, context):
       if event["source"] != "aws.ecs":
          raise ValueError("Function only supports input from events with a source type of: aws.ecs")
          
       print('Here is the event:')
       print(json.dumps(event))
   ```

   Il s'agit d'une fonction Python 3.9 simple qui imprime les événements envoyés par Amazon ECS. Si tout est correctement configuré, à la fin de ce didacticiel, vous verrez que les détails de l'événement apparaissent dans le flux de log CloudWatch Logs associé à cette fonction Lambda.

1. Choisissez **Enregistrer**.

## Étape 2 : Enregistrer une règle d'événement
<a name="cwet_step_3"></a>

 Ensuite, vous créez une règle d' CloudWatch événements qui capture les événements de tâches provenant de vos clusters Amazon ECS. Cette règle capture tous les événements provenant de tous les clusters du compte dans lequel il est défini. Les messages de tâche eux-mêmes contiennent des informations sur la source de l'événement, y compris le cluster sur lequel elle réside, que vous pouvez utiliser pour filtrer et trier les événements par programmation. 

**Note**  
Lorsque vous utilisez la règle AWS Management Console pour créer un événement, la console ajoute automatiquement les autorisations IAM nécessaires pour autoriser CloudWatch Events à appeler votre fonction Lambda. Si vous créez une règle d'événement à l'aide du AWS CLI, vous devez accorder cette autorisation de manière explicite. Pour plus d'informations, consultez les [sections Événements sur Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events.html) [et Modèles d' EventBridge événements](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-patterns.html) Amazon dans le *guide de EventBridge l'utilisateur Amazon*.

**Pour acheminer des événements vers votre fonction Lambda**

1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Dans le panneau de navigation, choisissez **Events** (Événements), **Rules** (Règles), **Create rule** (Créer une règle).

1. Pour **Event Source** (Source de l'événement), choisissez **ECS** comme source d'événement. Par défaut, la règle s'applique à tous les événements Amazon ECS pour tous vos groupes Amazon ECS. Sinon, vous pouvez sélectionner des événements spécifiques ou un groupe Amazon ECS spécifique.

1. Pour **Targets** (Cibles), choisissez **Add target** (Ajouter une cible), pour **Target type** (Type de cible), choisissez **Lambda function** (Fonction Lambda), puis sélectionnez votre fonction Lambda.

1. Choisissez **Configure details** (Configurer les détails).

1. Pour **Rule definition** (Définition de règle), saisissez un nom et une description pour la règle, puis choisissez **Create rule** (Créer une règle).

## Étape 3 : Créer une définition de tâche
<a name="cwet_step_task-def"></a>

Créez une définition de tâche.

1. Ouvrez la console à la [https://console.aws.amazon.com/ecs/version 2](https://console.aws.amazon.com/ecs/v2).

1. Dans le panneau de navigation, sélectionnez **Task Definitions** (Définition des tâches).

1. Choisissez **Create new Task Definition** (Créer une nouvelle définition de tâche), puis **Create new revision with JSON** (Créer une nouvelle révision avec JSON).

1. Copiez et collez l'exemple de définition de tâche suivant dans la zone, puis choisissez **Save** (Enregistrer).

   ```
   {
      "containerDefinitions": [ 
         { 
            "command": [
               "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
            ],
            "entryPoint": [
               "sh",
               "-c"
            ],
            "essential": true,
            "image": "public.ecr.aws/docker/library/httpd:2.4",
            "logConfiguration": { 
               "logDriver": "awslogs",
               "options": { 
                  "awslogs-group" : "/ecs/fargate-task-definition",
                  "awslogs-region": "us-east-1",
                  "awslogs-stream-prefix": "ecs"
               }
            },
            "name": "sample-fargate-app",
            "portMappings": [ 
               { 
                  "containerPort": 80,
                  "hostPort": 80,
                  "protocol": "tcp"
               }
            ]
         }
      ],
      "cpu": "256",
      "executionRoleArn": "arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
      "family": "fargate-task-definition",
      "memory": "512",
      "networkMode": "awsvpc",
      "runtimePlatform": {
           "operatingSystemFamily": "LINUX"
       },
      "requiresCompatibilities": [ 
          "FARGATE" 
       ]
   }
   ```

1. Choisissez **Créer**.

## Étape 4 : Test de la règle
<a name="cwet_step_4"></a>

 Enfin, vous créez une règle d' CloudWatch événements qui capture les événements de tâches provenant de vos clusters Amazon ECS. Cette règle capture tous les événements provenant de tous les clusters du compte dans lequel il est défini. Les messages de tâche eux-mêmes contiennent des informations sur la source de l'événement, y compris le cluster sur lequel elle réside, que vous pouvez utiliser pour filtrer et trier les événements par programmation. 

**Pour tester la règle**

1. Ouvrez la console à la [https://console.aws.amazon.com/ecs/version 2](https://console.aws.amazon.com/ecs/v2).

1. Choisissez **Task definitions** (Définitions des tâches).

1. Choisissez **console-sample-app-static**, puis choisissez **Déployer**, **Exécuter une nouvelle tâche**.

1. Pour **Cluster**, choisissez par défaut, puis choisissez **Deploy** (Déployer).

1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Dans le volet de navigation, choisissez **Logs et sélectionnez le groupe de journaux** pour votre fonction Lambda (par exemple, ***my-function*/aws/lambda/**).

1. Sélectionnez un flux de journaux pour afficher les données d'événement. 

# Envoi d’alertes Amazon Simple Notification Service pour les événements de tâche Amazon ECS arrêtés
<a name="ecs_cwet2"></a>

Configurez une règle d' EventBridge événement Amazon qui capture uniquement les événements de tâche lorsque la tâche a cessé de s'exécuter parce que l'un de ses conteneurs essentiels s'est arrêté. L'événement envoie uniquement les événements de tâche ayant une propriété spécifique `stoppedReason` à la rubrique Amazon SNS désignée.

## Prérequis : Configuration d'un cluster test
<a name="cwet2_step_1"></a>

 Si vous ne possédez pas de cluster en cours d'exécution à partir duquel capturer des événements, suivez les étapes dans [Mise en route avec la console à l'aide de conteneurs Linux sur AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/getting-started-fargate.html#get-started-fargate-cluster) pour en créer un. À la fin de ce didacticiel, vous exécuterez une tâche sur ce cluster pour vérifier que vous avez correctement configuré votre rubrique et votre EventBridge règle Amazon SNS. 

## Prérequis : configurer les autorisations pour Amazon SNS
<a name="cwet2_step_1a"></a>

 EventBridge Pour autoriser la publication sur une rubrique Amazon SNS, utilisez les commandes aws sns get-topic-attributes et aws sns. set-topic-attributes 

Pour obtenir des informations sur l’ajout de l’autorisation, consultez [Autorisations Amazon SNS](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-resource-based.html#eb-sns-permissions) dans le *Guide du développeur Amazon Simple Notification Service*.

Ajoutez les autorisations suivantes :

```
{
  "Sid": "PublishEventsToMyTopic",
  "Effect": "Allow",
  "Principal": {
     "Service": "events.amazonaws.com"
  },
  "Action": "sns: Publish",
  "Resource": "arn:aws:sns:region:account-id:TaskStoppedAlert",
}
```

## Étape 1 : Créer une rubrique Amazon SNS et s'y abonner
<a name="cwet2_step_2"></a>

 Pour ce didacticiel, vous configurez une rubrique Amazon SNS à utiliser comme une cible de l'événement pour votre nouvelle règle d'événement. 

Pour plus d'informations sur la façon de créer et de s'abonner à une rubrique Amazon SNS, consultez [Démarrer avec Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-getting-started.html#step-create-queue) dans le *Guide du développeur Amazon Simple Notification Service* et utilisez le tableau suivant pour déterminer les options à sélectionner.


| Option | Valeur | 
| --- | --- | 
|  Type  | Standard | 
| Nom |  TaskStoppedAlert  | 
|  Protocole | E-mail | 
| Endpoint |  Une adresse e-mail à laquelle vous avez actuellement accès  | 

## Étape 2 : Enregistrer une règle d'événement
<a name="cwet2_step_3"></a>

 Ensuite, vous enregistrez une règle d'événement qui capture uniquement les événements d'arrêt de la tâche pour les tâches avec des conteneurs arrêtés. 

Pour plus d'informations sur la création et l'abonnement à une rubrique Amazon SNS, consultez la section [Créer une règle EventBridge dans Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-get-started.html) dans le *guide de EventBridge l'utilisateur Amazon* et utilisez le tableau suivant pour déterminer les options à sélectionner.


| Option | Value | 
| --- | --- | 
|  Type de règle  |  Règle avec un modèle d'événement  | 
| Source de l’événement | AWS événements ou événements EventBridge partenaires | 
| Modèle d’événement |  Modèle personnalisé (éditeur JSON)  | 
| Modèle d’événement |  <pre>{<br />   "source":[<br />      "aws.ecs"<br />   ],<br />   "detail-type":[<br />      "ECS Task State Change"<br />   ],<br />   "detail":{<br />      "lastStatus":[<br />         "STOPPED"<br />      ],<br />      "stoppedReason":[<br />         "Essential container in task exited"<br />      ]<br />   }<br />}</pre> | 
| Type de cible |  AWS service  | 
| Cible | Rubrique SNS | 
| Rubrique |  TaskStoppedAlert (Le sujet que vous avez créé à l'étape 1)  | 

## Étape 3 : Test de la règle
<a name="cwet2_step_4"></a>

Vérifiez que la règle fonctionne en exécutant une tâche qui se ferme peu après son démarrage. Si votre règle d'événement est configurée correctement, vous recevez un message électronique en quelques minutes avec le texte de l'événement. Si vous disposez d'une définition de tâche existante qui peut satisfaire aux exigences de la règle, exécutez une tâche à l'aide de celle-ci. Si vous ne le faites pas, les étapes suivantes vous permettront d'enregistrer une définition de tâche Fargate et de l'exécuter.

1. Ouvrez la console à la [https://console.aws.amazon.com/ecs/version 2](https://console.aws.amazon.com/ecs/v2).

1. Dans le panneau de navigation, choisissez **Task definitions** (Définition des tâches).

1. Choisissez **Create new task definition** (Créer une nouvelle définition de tâche), puis **Create new task definition with JSON** (Créer une nouvelle définition de tâche avec JSON).

1. Dans la zone de l'éditeur JSON, modifiez votre fichier JSON, copiez ce qui suit dans l'éditeur.

   ```
   {
      "containerDefinitions":[
         {
            "command":[
               "sh",
               "-c",
               "sleep 5"
            ],
            "essential":true,
            "image":"public.ecr.aws/amazonlinux/amazonlinux:latest",
            "name":"test-sleep"
         }
      ],
      "cpu":"256",
      "executionRoleArn":"arn:aws:iam::012345678910:role/ecsTaskExecutionRole",
      "family":"fargate-task-definition",
      "memory":"512",
      "networkMode":"awsvpc",
      "requiresCompatibilities":[
         "FARGATE"
      ]
   }
   ```

1. Choisissez **Créer**.

**Pour exécuter une tâche à partir de la console**

1. Ouvrez la console à la [https://console.aws.amazon.com/ecs/version 2](https://console.aws.amazon.com/ecs/v2).

1. Sur la page **Clusters**, choisissez le cluster que vous avez créé dans les conditions préalables.

1. Sous l'onglet **Tasks (Tâches)**, choisissez **Run new task (Exécuter une nouvelle tâche)**.

1. Pour **Application type (Type d'application)**, choisissez **Task (Tâche)**.

1. Pour **Définition de la tâche**, sélectionnez **fargate-task-definition**.

1. Pour **Desired tasks** (Tâches souhaitées), saisissez le nombre de tâches à lancer.

1. Choisissez **Créer**.

# Concaténation des messages du journal Amazon ECS multiligne ou de suivi de pile
<a name="firelens-concatanate-multiline"></a>

À partir de AWS la version 2.22.0 de Fluent Bit, un filtre multiligne est inclus. Le filtre multiligne aide à concaténer les messages de journaux qui appartiennent à l'origine à un seul contexte, mais qui ont été divisés en plusieurs enregistrements ou lignes de journal. Pour plus d'informations sur le filtre multiligne, consultez la [ documentation de Fluent Bit](https://docs.fluentbit.io/manual/pipeline/filters/multiline-stacktrace). 

Voici des exemples courants de messages de journaux divisés :
+ Suivis de pile. 
+ Applications qui impriment des journaux sur plusieurs lignes. 
+ Messages de journal qui ont été divisés, car ils étaient plus longs que la taille maximale de mémoire tampon d'exécution spécifiée. Vous pouvez concaténer les messages de journal divisés par le moteur d'exécution du conteneur en suivant l'exemple suivant GitHub : [FireLens Exemple : Partial/Split Concaténer](https://github.com/aws-samples/amazon-ecs-firelens-examples/tree/mainline/examples/fluent-bit/filter-multiline-partial-message-mode) les journaux de conteneur.

## Autorisations IAM requises
<a name="iam-permissions"></a>

Vous disposez des autorisations IAM nécessaires pour que l'agent du conteneur extrait les images du conteneur depuis Amazon ECR et pour que le conteneur achemine les journaux vers CloudWatch Logs.

Pour ces autorisations, vous devez disposer des rôles suivants : 
+ Un rôle IAM de tâche. 
+ Un rôle IAM d’exécution de tâche 

Vous avez besoin des autorisations suivantes :
+ `logs:CreateLogStream`
+ `logs:CreateLogGroup`
+ `logs:PutLogEvents`

## Déterminez à quel moment utiliser le paramètre de journal multiligne
<a name="determine-filter"></a>

Vous trouverez ci-dessous des exemples d'extraits de journal que vous pouvez voir dans la console CloudWatch Logs avec le paramètre de journal par défaut. Vous pouvez regarder la ligne qui commence par `log` pour déterminer si vous avez besoin du filtre multiligne. Lorsque le contexte est le même, vous pouvez utiliser le paramètre de journal multiligne. Dans cet exemple, le contexte est « com.myproject.model ». MyProject».

```
2022-09-20T15:47:56:595-05-00                           {"container_id": "82ba37cada1d44d389b03e78caf74faa-EXAMPLE", "container_name": "example-app", "source=": "stdout", "log": ": "     at com.myproject.modele.(MyProject.badMethod.java:22)",
    {
      "container_id":  "82ba37cada1d44d389b03e78caf74faa-EXAMPLE",
      "container_name: ": "example-app",
      "source": "stdout",
      "log": ": "     at com.myproject.model.MyProject.badMethod(MyProject.java:22)",
      "ecs_cluster": "default",
      "ecs_task_arn": "arn:aws:region:123456789012:task/default/b23c940d29ed4714971cba72cEXAMPLE",
      "ecs_task_definition": "firelense-example-multiline:3"
     }
```

```
2022-09-20T15:47:56:595-05-00                           {"container_id": "82ba37cada1d44d389b03e78caf74faa-EXAMPLE", "container_name": "example-app", "stdout", "log": ": "     at com.myproject.modele.(MyProject.oneMoreMethod.java:18)",
    {
      "container_id":  "82ba37cada1d44d389b03e78caf74faa-EXAMPLE",
      "container_name: ": "example-app",
      "source": "stdout",
      "log": ": "     at com.myproject.model.MyProject.oneMoreMethod(MyProject.java:18)",
      "ecs_cluster": "default",
      "ecs_task_arn": "arn:aws:region:123456789012:task/default/b23c940d29ed4714971cba72cEXAMPLE,
      "ecs_task_definition": "firelense-example-multiline:3"
     }
```

Une fois que vous avez utilisé le paramètre de journal multiligne, la sortie ressemblera à l'exemple ci-dessous. 

```
2022-09-20T15:47:56:595-05-00                           {"container_id": "82ba37cada1d44d389b03e78caf74faa-EXAMPLE", "container_name": "example-app", "stdout",...
    {
      "container_id":  "82ba37cada1d44d389b03e78caf74faa-EXAMPLE",
      "container_name: ": "example-app",
      "source": "stdout",
      "log:    "September 20, 2022 06:41:48 Exception in thread \"main\" java.lang.RuntimeException: Something has gone wrong, aborting!\n    
    at com.myproject.module.MyProject.badMethod(MyProject.java:22)\n    at   
    at com.myproject.model.MyProject.oneMoreMethod(MyProject.java:18) com.myproject.module.MyProject.main(MyProject.java:6)",
      "ecs_cluster": "default",
      "ecs_task_arn": "arn:aws:region:123456789012:task/default/b23c940d29ed4714971cba72cEXAMPLE",
      "ecs_task_definition": "firelense-example-multiline:2"
     }
```

## Options d'analyse et de concaténation
<a name="parse-multiline-log"></a>

Pour analyser les journaux et concaténer des lignes qui ont été divisées en raison de sauts de lignes, vous pouvez utiliser l'une de ces deux options.
+ Utiliser votre propre fichier d'analyseur qui contient les règles pour analyser et concaténer les lignes qui appartiennent au même message.
+ Utiliser un analyseur intégré de Fluent Bit. Pour une liste des langues supportées par les analyseurs intégrés de Fluent Bit, consultez la [documentation de Fluent Bit](https://docs.fluentbit.io/manual/pipeline/filters/multiline-stacktrace).

Le didacticiel suivant vous guide à travers les étapes pour chaque cas d'utilisation. Les étapes vous montrent comment concaténer des lignes multiples et envoyer les journaux à Amazon. CloudWatch Vous pouvez spécifier une destination différente pour vos journaux.

### Exemple : Utiliser un analyseur que vous créez
<a name="customer-parser"></a>

Dans cet exemple, vous allez réaliser les étapes suivantes : 

1. Créer et charger l'image d'un conteneur Fluent Bit. 

1. Créer et charger l'image d'une application multiligne de démonstration qui s'exécute, échoue, et génère un suivi de pile multiligne.

1. Créer la définition de tâche et exécuter la tâche. 

1. Afficher les journaux pour vérifier que les messages qui couvrent plusieurs lignes apparaissent concaténés. 

**Création et chargement de l'image d'un conteneur Fluent Bit**

Cette image inclura le fichier d'analyseur où vous spécifiez l'expression régulière et un fichier de configuration qui fait référence au fichier d'analyseur. 

1. Créez un dossier avec le nom `FluentBitDockerImage`. 

1. Dans ce dossier, créez un fichier d'analyseur qui contient les règles pour analyser le journal et concaténer les lignes qui appartiennent au même message.

   1. Collez le contenu suivant dans le fichier d'analyseur :

      ```
      [MULTILINE_PARSER]
          name          multiline-regex-test
          type          regex
          flush_timeout 1000
          #
          # Regex rules for multiline parsing
          # ---------------------------------
          #
          # configuration hints:
          #
          #  - first state always has the name: start_state
          #  - every field in the rule must be inside double quotes
          #
          # rules |   state name  | regex pattern                  | next state
          # ------|---------------|--------------------------------------------
          rule      "start_state"   "/(Dec \d+ \d+\:\d+\:\d+)(.*)/"  "cont"
          rule      "cont"          "/^\s+at.*/"                     "cont"
      ```

      Lorsque vous personnalisez votre modèle d'expression régulière, nous vous recommandons d'utiliser un éditeur d'expressions régulières pour tester l'expression.

   1. Enregistrez le fichier sous le nom `parsers_multiline.conf`. 

1. Dans le dossier `FluentBitDockerImage`, créez un fichier de configuration personnalisé qui fait référence au fichier d'analyseur que vous avez créé à l'étape précédente.

   Pour plus d'informations sur le fichier de configuration personnalisé, consultez [Spécification d'un fichier de configuration personnalisé](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-taskdef.html#firelens-taskdef-customconfig) dans le *Guide du développeur Amazon Elastic Container Service* 

   1. Collez le contenu suivant dans le fichier :

      ```
      [SERVICE]
          flush                 1
          log_level             info
          parsers_file          /parsers_multiline.conf
          
      [FILTER]
          name                  multiline
          match                 *
          multiline.key_content log
          multiline.parser      multiline-regex-test
      ```
**Note**  
Vous devez utiliser le chemin absolu de l'analyseur. 

   1. Enregistrez le fichier sous le nom `extra.conf`. 

1. Dans le dossier `FluentBitDockerImage`, créez le Dockerfile avec l'image Fluent Bit, l'analyseur et les fichiers de configuration que vous avez créés.

   1. Collez le contenu suivant dans le fichier :

      ```
      FROM public.ecr.aws/aws-observability/aws-for-fluent-bit:latest
      
      ADD parsers_multiline.conf /parsers_multiline.conf
      ADD extra.conf /extra.conf
      ```

   1. Enregistrez le fichier sous le nom `Dockerfile`.

1. En utilisant le Dockerfile, créez une image Fluent Bit personnalisée avec l'analyseur et les fichiers de configuration personnalisés inclus.
**Note**  
Vous pouvez placer le fichier d'analyseur et le fichier de configuration n'importe où dans l'image Docker, sauf lorsque `/fluent-bit/etc/fluent-bit.conf` ce chemin de fichier est utilisé par. FireLens

   1. Créez l'image : `docker build -t fluent-bit-multiline-image.`

      Où : `fluent-bit-multiline-image` est le nom de l'image dans cet exemple.

   1. Vérifiez que l'image a été créée correctement : `docker images —filter reference=fluent-bit-multiline-image` 

      En cas de succès, la sortie montre l'image et l'identification `latest`.

1. Chargez l'image personnalisée Fluent Bit dans Amazon Elastic Container Registry.

   1. Créez un référentiel Amazon ECR pour stocker l'image : `aws ecr create-repository --repository-name fluent-bit-multiline-repo --region us-east-1`

      Où : `fluent-bit-multiline-repo` est le nom du référentiel et `us-east-1` est la région dans cet exemple. 

      La sortie vous donne les détails du nouveau référentiel. 

   1. Étiquetez votre image avec la valeur `repositoryUri` de la sortie précédente : `docker tag fluent-bit-multiline-image repositoryUri` 

      Exemple : `docker tag fluent-bit-multiline-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo` 

   1. Exécutez l'image docker pour vérifier qu'elle s'est exécutée correctement :`docker images —filter reference=repositoryUri`

      Dans le résultat, le nom du référentiel passe de fluent-bit-multiline-repo à`repositoryUri`.

   1. Authentifiez-vous auprès d'Amazon ECR en exécutant la commande `aws ecr get-login-password` et en spécifiant l'ID de registre auquel vous voulez vous authentifier : `aws ecr get-login-password | docker login --username AWS --password-stdin registry ID.dkr.ecr.region.amazonaws.com` 

      Exemple : `ecr get-login-password | docker login --username AWS --password-stdin xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com`

      Un message de connexion réussie apparaît.

   1. Envoyez (push) l'image vers Amazon ECR : `docker push registry ID.dkr.ecr.region.amazonaws.com/repository name` 

      Exemple : `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo`

**Création et chargement de l'image pour une application multiligne de démonstration**

Cette image comprendra un fichier script Python qui exécute l'application et un exemple de fichier journal. 

Lorsque vous exécutez la tâche, l'application simule l'exécution, puis échoue et crée un suivi de pile. 

1. Créez un dossier nommé `multiline-app` : `mkdir multiline-app` 

1. Créez un fichier script Python.

   1. Dans le dossier `multiline-app`, créez un fichier et nommez-le `main.py`.

   1. Collez le contenu suivant dans le fichier :

      ```
      import os
      import time
      file1 = open('/test.log', 'r')
      Lines = file1.readlines()
       
      count = 0
      
      for i in range(10):
          print("app running normally...")
          time.sleep(1)
      
      # Strips the newline character
      for line in Lines:
          count += 1
          print(line.rstrip())
      print(count)
      print("app terminated.")
      ```

   1. Enregistrez le fichier `main.py`.

1. Créez un fichier journal d'exemple. 

   1. Dans le dossier `multiline-app`, créez un fichier et nommez-le `test.log`.

   1. Collez le contenu suivant dans le fichier :

      ```
      single line...
      Dec 14 06:41:08 Exception in thread "main" java.lang.RuntimeException: Something has gone wrong, aborting!
          at com.myproject.module.MyProject.badMethod(MyProject.java:22)
          at com.myproject.module.MyProject.oneMoreMethod(MyProject.java:18)
          at com.myproject.module.MyProject.anotherMethod(MyProject.java:14)
          at com.myproject.module.MyProject.someMethod(MyProject.java:10)
          at com.myproject.module.MyProject.main(MyProject.java:6)
      another line...
      ```

   1. Enregistrez le fichier `test.log`.

1. Dans le dossier `multiline-app`, créez le Dockerfile.

   1. Collez le contenu suivant dans le fichier :

      ```
      FROM public.ecr.aws/amazonlinux/amazonlinux:latest
      ADD test.log /test.log
      
      RUN yum upgrade -y && yum install -y python3
      
      WORKDIR /usr/local/bin
      
      COPY main.py .
      
      CMD ["python3", "main.py"]
      ```

   1. Enregistrez le fichier `Dockerfile`.

1. À l'aide du Dockerfile, créez une image.

   1. Créez l'image : `docker build -t multiline-app-image `

      Où : `multiline-app-image` est le nom de l'image dans cet exemple.

   1. Vérifiez que l'image a été créée correctement : `docker images —filter reference=multiline-app-image` 

      En cas de succès, la sortie montre l'image et l'identification `latest`.

1. Chargez l'image dans Amazon Elastic Container Registry.

   1. Créez un référentiel Amazon ECR pour stocker l'image : `aws ecr create-repository --repository-name multiline-app-repo --region us-east-1`

      Où : `multiline-app-repo` est le nom du référentiel et `us-east-1` est la région dans cet exemple. 

      La sortie vous donne les détails du nouveau référentiel. Notez la valeur de `repositoryUri`, car vous en aurez besoin dans les étapes suivantes. 

   1. Étiquetez votre image avec la valeur `repositoryUri` de la sortie précédente : `docker tag multiline-app-image repositoryUri` 

      Exemple : `docker tag multiline-app-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo` 

   1. Exécutez l'image docker pour vérifier qu'elle s'est exécutée correctement :`docker images —filter reference=repositoryUri`

      Dans la sortie, le nom du référentiel passe de `multiline-app-repo` à la valeur de `repositoryUri`.

   1. Envoyez (push) l'image vers Amazon ECR : `docker push aws_account_id.dkr.ecr.region.amazonaws.com/repository name` 

      Exemple : `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo`

**Création de la définition de tâche et exécution de la tâche**

1. Créez un fichier de définition de tâche avec le nom de fichier `multiline-task-definition.json`. 

1. Collez le contenu suivant dans le fichier `multiline-task-definition.json` : 

   ```
   {
       "family": "firelens-example-multiline",
       "taskRoleArn": "task role ARN,
       "executionRoleArn": "execution role ARN",
       "containerDefinitions": [
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-image:latest",
               "name": "log_router",
               "firelensConfiguration": {
                   "type": "fluentbit",
                   "options": {
                       "config-file-type": "file",
                       "config-file-value": "/extra.conf"
                   }
               },
               "memoryReservation": 50
           },
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/multiline-app-image:latest",
               "name": "app",
               "logConfiguration": {
                   "logDriver": "awsfirelens",
                   "options": {
                       "Name": "cloudwatch_logs",
                       "region": "us-east-1",
                       "log_group_name": "multiline-test/application",
                       "auto_create_group": "true",
                       "log_stream_prefix": "multiline-"
                   }
               },
               "memoryReservation": 100
           }
       ],
       "requiresCompatibilities": ["FARGATE"],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512"
   }
   ```

   Remplacez les éléments suivants dans la définition de tâche `multiline-task-definition.json` :

   1. `task role ARN`

      Pour trouver l'ARN du rôle de la tâche, allez dans la console IAM. Choisissez **Roles** (Rôles) et trouvez le rôle de tâche `ecs-task-role-for-firelens` que vous avez créé. Choisissez le rôle et copiez l'**ARN** qui apparaît dans la section **Summary** (Résumé).

   1. `execution role ARN`

      Pour trouver l'ARN du rôle d'exécution, allez dans la console IAM. Choisissez **Roles** (Rôles) et trouvez le rôle `ecsTaskExecutionRole`. Choisissez le rôle et copiez l'**ARN** qui apparaît dans la section **Summary** (Résumé).

   1. `aws_account_id`

      Pour trouver votre `aws_account_id`, connectez-vous à la AWS Management Console. Choisissez votre nom d'utilisateur en haut à droite et copiez votre ID de compte.

   1. `us-east-1`

      Remplacez la région si nécessaire.

1. Enregistrez le fichier de définition de tâche : `aws ecs register-task-definition --cli-input-json file://multiline-task-definition.json --region region` 

1. Ouvrez la console à la [https://console.aws.amazon.com/ecs/version 2](https://console.aws.amazon.com/ecs/v2).

1. Dans le panneau de navigation, choisissez **Task Definitions** (Définitions de tâches), puis la famille `firelens-example-multiline`, car nous avons enregistré la définition de tâche à cette famille dans la première ligne de la définition de tâche ci-dessus.

1. Choisissez la dernière version. 

1. Choisissez **Déployer**, **Exécuter la tâche**. 

1. Sur la page **Exécuter la tâche**, pour **Cluster**, choisissez le cluster, puis sous **Mise en réseau**, pour **Sous-réseaux**, choisissez les sous-réseaux disponibles pour votre tâche. 

1. Choisissez **Créer**. 

**Vérifiez que les messages de journal multilignes dans Amazon CloudWatch apparaissent concaténés**

1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Dans le panneau de navigation, développez **Logs** (Journaux) et choisissez **Log groups** (Groupes de journaux). 

1. Choisissez le groupe de journaux `multiline-test/applicatio`. 

1. Choisissez le journal. Affichez les messages. Les lignes qui correspondent aux règles du fichier analyseur sont concaténées et apparaissent comme un seul message. 

   L'extrait de journal suivant montre les lignes concaténées dans un seul événement de suivi de pile Java : 

   ```
   {
       "container_id": "xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "log": "Dec 14 06:41:08 Exception in thread \"main\" java.lang.RuntimeException: Something has gone wrong, aborting!\n    at com.myproject.module.MyProject.badMethod(MyProject.java:22)\n    at com.myproject.module.MyProject.oneMoreMethod(MyProject.java:18)\n    at com.myproject.module.MyProject.anotherMethod(MyProject.java:14)\n    at com.myproject.module.MyProject.someMethod(MyProject.java:10)\n    at com.myproject.module.MyProject.main(MyProject.java:6)",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:2"
   }
   ```

   L'extrait de journal suivant montre comment le même message apparaît avec une seule ligne si vous exécutez un conteneur Amazon ECS qui n'est pas configuré pour concaténer les messages de journaux multilignes. 

   ```
   {
       "log": "Dec 14 06:41:08 Exception in thread \"main\" java.lang.RuntimeException: Something has gone wrong, aborting!",
       "container_id": "xxxxxx-xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:3"
   }
   ```

### Exemple : Utilisation d'un analyseur intégré de Fluent Bit
<a name="fluent-bit-parser"></a>

Dans cet exemple, vous allez réaliser les étapes suivantes : 

1. Créer et charger l'image d'un conteneur Fluent Bit. 

1. Créer et charger l'image d'une application multiligne de démonstration qui s'exécute, échoue, et génère un suivi de pile multiligne.

1. Créer la définition de tâche et exécuter la tâche. 

1. Afficher les journaux pour vérifier que les messages qui couvrent plusieurs lignes apparaissent concaténés. 

**Création et chargement de l'image d'un conteneur Fluent Bit**

Cette image comprendra un fichier de configuration qui fait référence à l'analyseur de Fluent Bit. 

1. Créez un dossier avec le nom `FluentBitDockerImage`. 

1. Dans le dossier `FluentBitDockerImage`, créez un fichier de configuration personnalisé qui fait référence au fichier d'analyseur intégré de Fluent Bit.

   Pour plus d'informations sur le fichier de configuration personnalisé, consultez [Spécification d'un fichier de configuration personnalisé](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-taskdef.html#firelens-taskdef-customconfig) dans le *Guide du développeur Amazon Elastic Container Service* 

   1. Collez le contenu suivant dans le fichier :

      ```
      [FILTER]
          name                  multiline
          match                 *
          multiline.key_content log
          multiline.parser      go
      ```

   1. Enregistrez le fichier sous le nom `extra.conf`. 

1. Dans le dossier `FluentBitDockerImage`, créez le Dockerfile avec l'image Fluent Bit, l'analyseur et les fichiers de configuration que vous avez créés.

   1. Collez le contenu suivant dans le fichier :

      ```
      FROM public.ecr.aws/aws-observability/aws-for-fluent-bit:latest
      ADD extra.conf /extra.conf
      ```

   1. Enregistrez le fichier sous le nom `Dockerfile`.

1. En utilisant le Dockerfile, créez une image Fluent Bit personnalisée avec le fichier de configuration personnalisé inclus.
**Note**  
Vous pouvez placer le fichier de configuration n'importe où dans l'image Docker, sauf si `/fluent-bit/etc/fluent-bit.conf` ce chemin de fichier est utilisé par FireLens.

   1. Créez l'image : `docker build -t fluent-bit-multiline-image.`

      Où : `fluent-bit-multiline-image` est le nom de l'image dans cet exemple.

   1. Vérifiez que l'image a été créée correctement : `docker images —filter reference=fluent-bit-multiline-image` 

      En cas de succès, la sortie montre l'image et l'identification `latest`.

1. Chargez l'image personnalisée Fluent Bit dans Amazon Elastic Container Registry.

   1. Créez un référentiel Amazon ECR pour stocker l'image : `aws ecr create-repository --repository-name fluent-bit-multiline-repo --region us-east-1`

      Où : `fluent-bit-multiline-repo` est le nom du référentiel et `us-east-1` est la région dans cet exemple. 

      La sortie vous donne les détails du nouveau référentiel. 

   1. Étiquetez votre image avec la valeur `repositoryUri` de la sortie précédente : `docker tag fluent-bit-multiline-image repositoryUri` 

      Exemple : `docker tag fluent-bit-multiline-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo` 

   1. Exécutez l'image docker pour vérifier qu'elle s'est exécutée correctement :`docker images —filter reference=repositoryUri`

      Dans le résultat, le nom du référentiel passe de fluent-bit-multiline-repo à`repositoryUri`.

   1. Authentifiez-vous auprès d'Amazon ECR en exécutant la commande `aws ecr get-login-password` et en spécifiant l'ID de registre auquel vous voulez vous authentifier : `aws ecr get-login-password | docker login --username AWS --password-stdin registry ID.dkr.ecr.region.amazonaws.com` 

      Exemple : `ecr get-login-password | docker login --username AWS --password-stdin xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com`

      Un message de connexion réussie apparaît.

   1. Envoyez (push) l'image vers Amazon ECR : `docker push registry ID.dkr.ecr.region.amazonaws.com/repository name` 

      Exemple : `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-repo`

**Création et chargement de l'image pour une application multiligne de démonstration**

Cette image comprendra un fichier script Python qui exécute l'application et un exemple de fichier journal. 

1. Créez un dossier nommé `multiline-app` : `mkdir multiline-app` 

1. Créez un fichier script Python.

   1. Dans le dossier `multiline-app`, créez un fichier et nommez-le `main.py`.

   1. Collez le contenu suivant dans le fichier :

      ```
      import os
      import time
      file1 = open('/test.log', 'r')
      Lines = file1.readlines()
       
      count = 0
      
      for i in range(10):
          print("app running normally...")
          time.sleep(1)
      
      # Strips the newline character
      for line in Lines:
          count += 1
          print(line.rstrip())
      print(count)
      print("app terminated.")
      ```

   1. Enregistrez le fichier `main.py`.

1. Créez un fichier journal d'exemple. 

   1. Dans le dossier `multiline-app`, créez un fichier et nommez-le `test.log`.

   1. Collez le contenu suivant dans le fichier :

      ```
      panic: my panic
      
      goroutine 4 [running]:
      panic(0x45cb40, 0x47ad70)
        /usr/local/go/src/runtime/panic.go:542 +0x46c fp=0xc42003f7b8 sp=0xc42003f710 pc=0x422f7c
      main.main.func1(0xc420024120)
        foo.go:6 +0x39 fp=0xc42003f7d8 sp=0xc42003f7b8 pc=0x451339
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003f7e0 sp=0xc42003f7d8 pc=0x44b4d1
      created by main.main
        foo.go:5 +0x58
      
      goroutine 1 [chan receive]:
      runtime.gopark(0x4739b8, 0xc420024178, 0x46fcd7, 0xc, 0xc420028e17, 0x3)
        /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc420053e30 sp=0xc420053e00 pc=0x42503c
      runtime.goparkunlock(0xc420024178, 0x46fcd7, 0xc, 0x1000f010040c217, 0x3)
        /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc420053e70 sp=0xc420053e30 pc=0x42512e
      runtime.chanrecv(0xc420024120, 0x0, 0xc420053f01, 0x4512d8)
        /usr/local/go/src/runtime/chan.go:506 +0x304 fp=0xc420053f20 sp=0xc420053e70 pc=0x4046b4
      runtime.chanrecv1(0xc420024120, 0x0)
        /usr/local/go/src/runtime/chan.go:388 +0x2b fp=0xc420053f50 sp=0xc420053f20 pc=0x40439b
      main.main()
        foo.go:9 +0x6f fp=0xc420053f80 sp=0xc420053f50 pc=0x4512ef
      runtime.main()
        /usr/local/go/src/runtime/proc.go:185 +0x20d fp=0xc420053fe0 sp=0xc420053f80 pc=0x424bad
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc420053fe8 sp=0xc420053fe0 pc=0x44b4d1
      
      goroutine 2 [force gc (idle)]:
      runtime.gopark(0x4739b8, 0x4ad720, 0x47001e, 0xf, 0x14, 0x1)
        /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003e768 sp=0xc42003e738 pc=0x42503c
      runtime.goparkunlock(0x4ad720, 0x47001e, 0xf, 0xc420000114, 0x1)
        /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003e7a8 sp=0xc42003e768 pc=0x42512e
      runtime.forcegchelper()
        /usr/local/go/src/runtime/proc.go:238 +0xcc fp=0xc42003e7e0 sp=0xc42003e7a8 pc=0x424e5c
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003e7e8 sp=0xc42003e7e0 pc=0x44b4d1
      created by runtime.init.4
        /usr/local/go/src/runtime/proc.go:227 +0x35
      
      goroutine 3 [GC sweep wait]:
      runtime.gopark(0x4739b8, 0x4ad7e0, 0x46fdd2, 0xd, 0x419914, 0x1)
        /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003ef60 sp=0xc42003ef30 pc=0x42503c
      runtime.goparkunlock(0x4ad7e0, 0x46fdd2, 0xd, 0x14, 0x1)
        /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003efa0 sp=0xc42003ef60 pc=0x42512e
      runtime.bgsweep(0xc42001e150)
        /usr/local/go/src/runtime/mgcsweep.go:52 +0xa3 fp=0xc42003efd8 sp=0xc42003efa0 pc=0x419973
      runtime.goexit()
        /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003efe0 sp=0xc42003efd8 pc=0x44b4d1
      created by runtime.gcenable
        /usr/local/go/src/runtime/mgc.go:216 +0x58
      one more line, no multiline
      ```

   1. Enregistrez le fichier `test.log`.

1. Dans le dossier `multiline-app`, créez le Dockerfile.

   1. Collez le contenu suivant dans le fichier :

      ```
      FROM public.ecr.aws/amazonlinux/amazonlinux:latest
      ADD test.log /test.log
      
      RUN yum upgrade -y && yum install -y python3
      
      WORKDIR /usr/local/bin
      
      COPY main.py .
      
      CMD ["python3", "main.py"]
      ```

   1. Enregistrez le fichier `Dockerfile`.

1. À l'aide du Dockerfile, créez une image.

   1. Créez l'image : `docker build -t multiline-app-image `

      Où : `multiline-app-image` est le nom de l'image dans cet exemple.

   1. Vérifiez que l'image a été créée correctement : `docker images —filter reference=multiline-app-image` 

      En cas de succès, la sortie montre l'image et l'identification `latest`.

1. Chargez l'image dans Amazon Elastic Container Registry.

   1. Créez un référentiel Amazon ECR pour stocker l'image : `aws ecr create-repository --repository-name multiline-app-repo --region us-east-1`

      Où : `multiline-app-repo` est le nom du référentiel et `us-east-1` est la région dans cet exemple. 

      La sortie vous donne les détails du nouveau référentiel. Notez la valeur de `repositoryUri`, car vous en aurez besoin dans les étapes suivantes. 

   1. Étiquetez votre image avec la valeur `repositoryUri` de la sortie précédente : `docker tag multiline-app-image repositoryUri` 

      Exemple : `docker tag multiline-app-image xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo` 

   1. Exécutez l'image docker pour vérifier qu'elle s'est exécutée correctement :`docker images —filter reference=repositoryUri`

      Dans la sortie, le nom du référentiel passe de `multiline-app-repo` à la valeur de `repositoryUri`.

   1. Envoyez (push) l'image vers Amazon ECR : `docker push aws_account_id.dkr.ecr.region.amazonaws.com/repository name` 

      Exemple : `docker push xxxxxxxxxxxx.dkr.ecr.us-east-1.amazonaws.com/multiline-app-repo`

**Création de la définition de tâche et exécution de la tâche**

1. Créez un fichier de définition de tâche avec le nom de fichier `multiline-task-definition.json`. 

1. Collez le contenu suivant dans le fichier `multiline-task-definition.json` : 

   ```
   {
       "family": "firelens-example-multiline",
       "taskRoleArn": "task role ARN,
       "executionRoleArn": "execution role ARN",
       "containerDefinitions": [
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/fluent-bit-multiline-image:latest",
               "name": "log_router",
               "firelensConfiguration": {
                   "type": "fluentbit",
                   "options": {
                       "config-file-type": "file",
                       "config-file-value": "/extra.conf"
                   }
               },
               "memoryReservation": 50
           },
           {
               "essential": true,
               "image": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/multiline-app-image:latest",
               "name": "app",
               "logConfiguration": {
                   "logDriver": "awsfirelens",
                   "options": {
                       "Name": "cloudwatch_logs",
                       "region": "us-east-1",
                       "log_group_name": "multiline-test/application",
                       "auto_create_group": "true",
                       "log_stream_prefix": "multiline-"
                   }
               },
               "memoryReservation": 100
           }
       ],
       "requiresCompatibilities": ["FARGATE"],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512"
   }
   ```

   Remplacez les éléments suivants dans la définition de tâche `multiline-task-definition.json` :

   1. `task role ARN`

      Pour trouver l'ARN du rôle de la tâche, allez dans la console IAM. Choisissez **Roles** (Rôles) et trouvez le rôle de tâche `ecs-task-role-for-firelens` que vous avez créé. Choisissez le rôle et copiez l'**ARN** qui apparaît dans la section **Summary** (Résumé).

   1. `execution role ARN`

      Pour trouver l'ARN du rôle d'exécution, allez dans la console IAM. Choisissez **Roles** (Rôles) et trouvez le rôle `ecsTaskExecutionRole`. Choisissez le rôle et copiez l'**ARN** qui apparaît dans la section **Summary** (Résumé).

   1. `aws_account_id`

      Pour trouver votre `aws_account_id`, connectez-vous à la AWS Management Console. Choisissez votre nom d'utilisateur en haut à droite et copiez votre ID de compte.

   1. `us-east-1`

      Remplacez la région si nécessaire.

1. Enregistrez le fichier de définition de tâche : `aws ecs register-task-definition --cli-input-json file://multiline-task-definition.json --region us-east-1` 

1. Ouvrez la console à la [https://console.aws.amazon.com/ecs/version 2](https://console.aws.amazon.com/ecs/v2).

1. Dans le panneau de navigation, choisissez **Task Definitions** (Définitions de tâches), puis la famille `firelens-example-multiline`, car nous avons enregistré la définition de tâche à cette famille dans la première ligne de la définition de tâche ci-dessus.

1. Choisissez la dernière version. 

1. Choisissez **Déployer**, **Exécuter la tâche**. 

1. Sur la page **Exécuter la tâche**, pour **Cluster**, choisissez le cluster, puis sous **Mise en réseau**, pour **Sous-réseaux**, choisissez les sous-réseaux disponibles pour votre tâche. 

1. Choisissez **Créer**. 

**Vérifiez que les messages de journal multilignes dans Amazon CloudWatch apparaissent concaténés**

1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Dans le panneau de navigation, développez **Logs** (Journaux) et choisissez **Log groups** (Groupes de journaux). 

1. Choisissez le groupe de journaux `multiline-test/applicatio`. 

1. Choisissez le journal et affichez les messages. Les lignes qui correspondent aux règles du fichier analyseur sont concaténées et apparaissent comme un seul message. 

   L'extrait de journal suivant montre un suivi de pile Go qui est concaténé en un seul événement : 

   ```
   {
       "log": "panic: my panic\n\ngoroutine 4 [running]:\npanic(0x45cb40, 0x47ad70)\n  /usr/local/go/src/runtime/panic.go:542 +0x46c fp=0xc42003f7b8 sp=0xc42003f710 pc=0x422f7c\nmain.main.func1(0xc420024120)\n  foo.go:6 +0x39 fp=0xc42003f7d8 sp=0xc42003f7b8 pc=0x451339\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003f7e0 sp=0xc42003f7d8 pc=0x44b4d1\ncreated by main.main\n  foo.go:5 +0x58\n\ngoroutine 1 [chan receive]:\nruntime.gopark(0x4739b8, 0xc420024178, 0x46fcd7, 0xc, 0xc420028e17, 0x3)\n  /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc420053e30 sp=0xc420053e00 pc=0x42503c\nruntime.goparkunlock(0xc420024178, 0x46fcd7, 0xc, 0x1000f010040c217, 0x3)\n  /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc420053e70 sp=0xc420053e30 pc=0x42512e\nruntime.chanrecv(0xc420024120, 0x0, 0xc420053f01, 0x4512d8)\n  /usr/local/go/src/runtime/chan.go:506 +0x304 fp=0xc420053f20 sp=0xc420053e70 pc=0x4046b4\nruntime.chanrecv1(0xc420024120, 0x0)\n  /usr/local/go/src/runtime/chan.go:388 +0x2b fp=0xc420053f50 sp=0xc420053f20 pc=0x40439b\nmain.main()\n  foo.go:9 +0x6f fp=0xc420053f80 sp=0xc420053f50 pc=0x4512ef\nruntime.main()\n  /usr/local/go/src/runtime/proc.go:185 +0x20d fp=0xc420053fe0 sp=0xc420053f80 pc=0x424bad\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc420053fe8 sp=0xc420053fe0 pc=0x44b4d1\n\ngoroutine 2 [force gc (idle)]:\nruntime.gopark(0x4739b8, 0x4ad720, 0x47001e, 0xf, 0x14, 0x1)\n  /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003e768 sp=0xc42003e738 pc=0x42503c\nruntime.goparkunlock(0x4ad720, 0x47001e, 0xf, 0xc420000114, 0x1)\n  /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003e7a8 sp=0xc42003e768 pc=0x42512e\nruntime.forcegchelper()\n  /usr/local/go/src/runtime/proc.go:238 +0xcc fp=0xc42003e7e0 sp=0xc42003e7a8 pc=0x424e5c\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003e7e8 sp=0xc42003e7e0 pc=0x44b4d1\ncreated by runtime.init.4\n  /usr/local/go/src/runtime/proc.go:227 +0x35\n\ngoroutine 3 [GC sweep wait]:\nruntime.gopark(0x4739b8, 0x4ad7e0, 0x46fdd2, 0xd, 0x419914, 0x1)\n  /usr/local/go/src/runtime/proc.go:280 +0x12c fp=0xc42003ef60 sp=0xc42003ef30 pc=0x42503c\nruntime.goparkunlock(0x4ad7e0, 0x46fdd2, 0xd, 0x14, 0x1)\n  /usr/local/go/src/runtime/proc.go:286 +0x5e fp=0xc42003efa0 sp=0xc42003ef60 pc=0x42512e\nruntime.bgsweep(0xc42001e150)\n  /usr/local/go/src/runtime/mgcsweep.go:52 +0xa3 fp=0xc42003efd8 sp=0xc42003efa0 pc=0x419973\nruntime.goexit()\n  /usr/local/go/src/runtime/asm_amd64.s:2337 +0x1 fp=0xc42003efe0 sp=0xc42003efd8 pc=0x44b4d1\ncreated by runtime.gcenable\n  /usr/local/go/src/runtime/mgc.go:216 +0x58",
       "container_id": "xxxxxx-xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:2"
   }
   ```

   L'extrait de journal suivant montre comment le même événement apparaît si vous exécutez un conteneur ECS qui n'est pas configuré pour concaténer les messages de journaux multilignes. Le champ du journal contient une seule ligne.

   ```
   {
       "log": "panic: my panic",
       "container_id": "xxxxxx-xxxxxx",
       "container_name": "app",
       "source": "stdout",
       "ecs_cluster": "default",
       "ecs_task_arn": "arn:aws:ecs:us-east-1:xxxxxxxxxxxx:task/default/xxxxxx",
       "ecs_task_definition": "firelens-example-multiline:3"
   ```

**Note**  
Si vos journaux sont envoyés dans des fichiers journaux au lieu de la sortie standard, nous vous recommandons de spécifier les paramètres de configuration `multiline.parser` et `multiline.key_content` dans le [plugin d'entrée Tail](https://docs.fluentbit.io/manual/pipeline/inputs/tail#multiline-support) au lieu du filtre.

# Déploiement de Fluent Bit sur Amazon ECS pour des conteneurs Windows
<a name="tutorial-deploy-fluentbit-on-windows"></a>

Fluent Bit est un processeur et un routeur de journaux rapides et flexibles pris en charge par différents systèmes d'exploitation. Il peut être utilisé pour acheminer les journaux vers diverses AWS destinations telles qu'Amazon CloudWatch Logs, Firehose, Amazon S3 et Amazon OpenSearch Service. Fluent Bit prend en charge des solutions partenaires courantes, comme [Datadog](https://www.datadoghq.com/), [Splunk](https://www.splunk.com/) et les serveurs HTTP personnalisés. Pour plus d'informations sur Fluent Bit, consultez le site web [https://fluentbit.io/](https://fluentbit.io/).

L'image **AWS pour Fluent Bit** est disponible sur Amazon ECR à la fois sur la galerie publique Amazon ECR et dans un référentiel Amazon ECR dans la plupart des Régions pour une haute disponibilité. Pour plus d'informations, consultez [https://github.com/aws/aws-for-fluent-bit](https://github.com/aws/aws-for-fluent-bit)le GitHub site Web.

Ce didacticiel explique comment déployer des conteneurs Fluent Bit sur leurs instances Windows exécutées dans Amazon ECS afin de diffuser les journaux générés par les tâches Windows vers Amazon CloudWatch pour une journalisation centralisée. 

Ce didacticiel utilise l'approche suivante :
+ Fluent Bit fonctionne comme un service avec la stratégie de planification du démon. Cette stratégie garantit qu'une seule instance de Fluent Bit s'exécute toujours sur les instances de conteneur du cluster.
  + Écoute sur le port 24224 à l'aide du plug-in d'entrée directe.
  + Expose le port 24224 à l'hôte afin que le moteur d'exécution du docker puisse envoyer des journaux à Fluent Bit en utilisant ce port exposé.
  + Dispose d'une configuration qui permet à Fluent Bit d'envoyer les enregistrements des journaux vers des destinations spécifiées.
+ Lancement de tous les autres conteneurs de tâches Amazon ECS à l'aide du pilote de journalisation Fluentd. Pour plus d'informations, consultez [Fluentd logging drive](https://docs.docker.com/engine/logging/drivers/fluentd/) (Pilote de journalisation Fluentd) sur le site Web de la documentation de Docker.
  + Docker se connecte au socket TCP 24224 sur localhost dans l'espace de noms de l'hôte.
  + L'agent Amazon ECS ajoute des étiquettes aux conteneurs, notamment le nom du cluster, le nom de famille de la définition de la tâche, le numéro de révision de la définition de la tâche, l'ARN de la tâche et le nom du conteneur. Les mêmes informations sont ajoutées à l'enregistrement du journal à l'aide de l'option labels du pilote de journalisation fluentd de Docker. Pour de plus amples informations, veuillez consulter [labels, labels-regex, env, and env-regex](https://docs.docker.com/config/containers/logging/fluentd/#labels-labels-regex-env-and-env-regex) sur le site web de la documentation de Docker.
  + Comme l'option `async` du pilote de journalisation Fluentd est définie sur `true`, lorsque le conteneur Fluent Bit est redémarré, Docker met les journaux en mémoire tampon jusqu'à ce que le conteneur Fluent Bit soit redémarré. Vous pouvez augmenter la limite de mémoire tampon en définissant fluentd-buffer-limit cette option. Pour plus d'informations, consultez [fluentd-buffer-limit](https://docs.docker.com/config/containers/logging/fluentd/#fluentd-buffer-limit)le site Web de documentation de Docker.

 Le flux de travail est le suivant :
+ Le conteneur Fluent Bit démarre et écoute sur le port 24224 qui est exposé à l'hôte.
+ Fluent Bit utilise les informations d'identification du rôle IAM de la tâche spécifiées dans sa définition de tâche.
+ Les autres tâches lancées sur la même instance utilisent le pilote de journalisation fluentd de Docker pour se connecter au conteneur Fluent Bit sur le port 24224. 
+ Lorsque les conteneurs d'applications génèrent des journaux, le moteur d'exécution de Docker étiquette ces enregistrements, ajoute des métadonnées supplémentaires spécifiées dans les étiquettes, puis les transmet sur le port 24224 de l'espace de noms de l'hôte. 
+ Fluent Bit reçoit l'enregistrement du journal sur le port 24224 car il est exposé à l'espace de noms de l'hôte.
+ Fluent Bit effectue son traitement interne et achemine les journaux comme spécifié.

Ce didacticiel utilise la configuration CloudWatch Fluent Bit par défaut qui effectue les opérations suivantes :
+ Crée un nouveau groupe de journaux pour chaque cluster et chaque famille de définitions de tâches.
+ Crée un nouveau flux de journaux pour chaque conteneur de tâches du groupe de journaux généré ci-dessus chaque fois qu'une nouvelle tâche est lancée. Chaque flux sera marqué avec l'identifiant de tâche à laquelle le conteneur appartient.
+ Ajoute des métadonnées supplémentaires, notamment le nom du cluster, l'ARN de la tâche, le nom du conteneur de la tâche, la famille de définitions de la tâche et le numéro de révision de la définition de la tâche dans chaque entrée du journal.

  Par exemple, si vous avez `task_1` with `container_1` `container_2` et t `ask_2` with`container_3`, les flux de CloudWatch log sont les suivants :
  + `/aws/ecs/windows.ecs_task_1`

    `task-out.TASK_ID.container_1`

    `task-out.TASK_ID.container_2`
  + `/aws/ecs/windows.ecs_task_2`

    `task-out.TASK_ID.container_3`

**Note**  
Vous pouvez utiliser des points de terminaison de service à double pile pour interagir avec Amazon ECS à partir de AWS CLI SDKs, et de l'API Amazon ECS via les deux IPv4 et. IPv6 Pour de plus amples informations, veuillez consulter [Utilisation des points de terminaison à double pile Amazon ECS](dual-stack-endpoint.md).

**Topics**
+ [

## Conditions préalables
](#tutorial-deploy-fluentbit-on-windows-prereqs)
+ [

## Étape 1 : Créer les rôles IAM d'accès
](#tutorial-deploy-fluentbit-on-windows-iam-access-role)
+ [

## Étape 2 : Créer une instance de conteneur Windows Amazon ECS
](#tutorial-deploy-fluentbit-on-windows-instance)
+ [

## Étape 3 : Configurer Fluent Bit
](#tutorial-deploy-fluentbit-on-windows-configure-fluentbit)
+ [

## Étape 4 : enregistrer une définition de tâche Windows Fluent Bit qui achemine les journaux vers CloudWatch
](#tutorial-deploy-fluentbit-on-windows-register-task-definition)
+ [

## Étape 5 : Exécuter la définition de tâche `ecs-windows-fluent-bit` en tant que service Amazon ECS en utilisant la stratégie de planification du démon
](#tutorial-deploy-fluentbit-on-windows-run-task)
+ [

## Étape 6 : Enregistrer une définition de tâche Windows qui génère les journaux
](#tutorial-deploy-fluentbit-on-windows-register-task-def-logs)
+ [

## Étape 7 : Créer la définition de tâche `windows-app-task`
](#tutorial-deploy-fluentbit-on-windows-run-task-fluentbit)
+ [

## Étape 8 : Vérifiez les connexions CloudWatch
](#tutorial-deploy-fluentbit-on-windows-verify)
+ [

## Étape 9 : nettoyer
](#tutorial-deploy-fluentbit-on-windows-cleanup)

## Conditions préalables
<a name="tutorial-deploy-fluentbit-on-windows-prereqs"></a>

Le didacticiel suppose de remplir les prérequis suivants :
+ La dernière version du AWS CLI est installée et configurée. Pour plus d’informations, consultez la section [Installation ou mise à jour de la version la plus récente de l’ AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ L'image du conteneur `aws-for-fluent-bit` est disponible pour les systèmes d'exploitation Windows suivants :
  + Windows Server 2019 Core
  + Windows Server 2019 Full
  + Windows Server 2022 Core
  + Windows Server 2022 Full
+ Vous devez avoir suivi les étapes de [Configurer l'utilisation d'Amazon ECS](get-set-up-for-amazon-ecs.md).
+ Vous avez un cluster. Dans ce didacticiel, le nom du cluster est **FluentBit-cluster**.
+ Vous disposez d'un VPC doté d'un sous-réseau public sur lequel l'instance EC2 sera lancée. Vous pouvez utiliser votre VPC par défaut. Vous pouvez également utiliser un sous-réseau privé qui permet aux CloudWatch points de terminaison Amazon d'accéder au sous-réseau. Pour plus d'informations sur les CloudWatch points de terminaison Amazon, consultez la section [ CloudWatch Points de terminaison et quotas Amazon](https://docs.aws.amazon.com/general/latest/gr/cw_region.html) dans le. *Références générales AWS* Pour plus d'informations sur la manière d'utiliser l'assistant Amazon VPC pour créer un VPC, consultez [Créer un Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).

## Étape 1 : Créer les rôles IAM d'accès
<a name="tutorial-deploy-fluentbit-on-windows-iam-access-role"></a>

Créez les rôles IAM Amazon ECS.

1.  Créez le rôle d'instance de conteneur Amazon ECS nommé « ecsInstanceRole ». Pour plus d'informations, consultez [Rôle IAM d'instance de conteneur Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/instance_IAM_role.html).

1. Créez un rôle IAM pour la tâche Fluent Bit intitulée `fluentTaskRole`. Pour de plus amples informations, veuillez consulter [rôle IAM de tâche Amazon ECS](task-iam-roles.md).

    Les autorisations IAM accordées dans ce rôle IAM sont prises en charge par les conteneurs de tâches. Pour autoriser Fluent Bit à envoyer des journaux CloudWatch, vous devez associer les autorisations suivantes au rôle IAM de la tâche.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
       {
           "Effect": "Allow",
           "Action": [
               "logs:CreateLogStream",
               "logs:CreateLogGroup",
               "logs:DescribeLogStreams",
               "logs:PutLogEvents"
           ],
           "Resource": "*"
       }
       ]
   }
   ```

------

1. Attachez la stratégie au rôle.

   1. Enregistrez le contenu ci-dessus dans un fichier nommé `fluent-bit-policy.json`.

   1. Exécutez la commande suivante pour associer la politique en ligne au rôle IAM `fluentTaskRole`.

      ```
      aws iam put-role-policy --role-name fluentTaskRole --policy-name fluentTaskPolicy --policy-document file://fluent-bit-policy.json
      ```

## Étape 2 : Créer une instance de conteneur Windows Amazon ECS
<a name="tutorial-deploy-fluentbit-on-windows-instance"></a>

Créez une instance de conteneur Windows Amazon ECS.

**Pour créer une instance Amazon ECS**

1. Utilisez la commande `aws ssm get-parameters` pour récupérer l'ID AMI de la région qui héberge votre VPC. Pour plus d'informations, consultez [Extraction des métadonnées d'AMI optimisée pour Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/retrieve-ecs-optimized_windows_AMI.html).

1. Utilisez la console Amazon EC2 pour lancer l'instance.

   1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

   1. Dans la barre de navigation, sélectionnez la région à utiliser.

   1. Sur le **tableau de bord EC2**, sélectionnez **Launch instance (Lancer une instance)**.

   1. Pour **Name (Nom)**, saisissez un nom unique.

   1. Pour **Application and OS Images (Amazon Machine Image)** (Images de l'application et du SE (Amazon Machine Image)), choisissez l'AMI que vous avez récupérée lors de la première étape.

   1. Concernant l'option **Instance type (Type d'instance)**, choisissez `t3.xlarge`.

   1. Pour **Key pair (login)** (Paire de clés (connexion)), choisissez une paire de clés. 

   1. Sous **Network Settings** (Paramètres réseau), pour **Security group** (Groupe de sécurité), choisissez un groupe de sécurité existant ou créez-en un nouveau.

   1. Sous **Network settings** (Paramètres réseau), pour **Auto-assign Public IP** (Attribuer automatiquement l'adresse IP publique), sélectionnez **Enable** (Activer). 

   1. Sous **Détails avancés**, pour le **profil d'instance IAM**, sélectionnez **ecsInstanceRole**.

   1. Configurez votre instance de conteneur Amazon ECS avec les données utilisateur suivantes. Sous **Détails avancés**, collez le script suivant dans le champ **Données utilisateur**, en le *cluster\$1name* remplaçant par le nom de votre cluster.

      ```
      <powershell>
      Import-Module ECSTools
      Initialize-ECSAgent -Cluster cluster-name -EnableTaskENI -EnableTaskIAMRole -LoggingDrivers '["awslogs","fluentd"]'
      </powershell>
      ```

   1. Lorsque vous êtes prêt, cochez la case de confirmation, puis sélectionnez **Launch Instances** (Lancer des instances). 

   1. Une page de confirmation indique que l'instance est en cours de lancement. Sélectionnez **View Instances** (Afficher les instances) pour fermer la page de confirmation et revenir à la console.

## Étape 3 : Configurer Fluent Bit
<a name="tutorial-deploy-fluentbit-on-windows-configure-fluentbit"></a>

Vous pouvez utiliser la configuration par défaut suivante fournie par AWS pour démarrer rapidement :
+ [Amazon CloudWatch](https://github.com/aws/aws-for-fluent-bit/blob/mainline/ecs_windows_forward_daemon/cloudwatch.conf), qui est basé sur le plug-in Fluent Bit pour [Amazon figurant](https://docs.fluentbit.io/manual/v/1.9-pre/pipeline/outputs/cloudwatch) dans CloudWatch le *manuel officiel de Fluent Bit*.

Vous pouvez également utiliser d'autres configurations par défaut fournies par AWS. Pour plus d'informations, consultez la section [Overriding the entrypoint for the Windows image](https://github.com/aws/aws-for-fluent-bit/tree/mainline/ecs_windows_forward_daemon#overriding-the-entrypoint-for-the-windows-image) (Ignorer le point d'entrée de l'image Windows) sur le site Web `aws-for-fluent-bit` de Github.

La configuration par défaut d'Amazon CloudWatch Fluent Bit est illustrée ci-dessous.

Remplacez les variables suivantes :
+ *region*avec la région dans laquelle vous souhaitez envoyer les CloudWatch journaux Amazon.

```
[SERVICE]
    Flush               5
    Log_Level           info
    Daemon              off

[INPUT]
    Name                forward
    Listen              0.0.0.0
    Port                24224
    Buffer_Chunk_Size   1M
    Buffer_Max_Size     6M
    Tag_Prefix          ecs.

# Amazon ECS agent adds the following log keys as labels to the docker container.
# We would use fluentd logging driver to add these to log record while sending it to Fluent Bit.
[FILTER]
    Name                modify
    Match               ecs.*
    Rename              com.amazonaws.ecs.cluster ecs_cluster
    Rename              com.amazonaws.ecs.container-name ecs_container_name
    Rename              com.amazonaws.ecs.task-arn ecs_task_arn
    Rename              com.amazonaws.ecs.task-definition-family ecs_task_definition_family
    Rename              com.amazonaws.ecs.task-definition-version ecs_task_definition_version

[FILTER]
    Name                rewrite_tag
    Match               ecs.*
    Rule                $ecs_task_arn ^([a-z-:0-9]+)/([a-zA-Z0-9-_]+)/([a-z0-9]+)$  out.$3.$ecs_container_name false
    Emitter_Name        re_emitted

[OUTPUT]
    Name                cloudwatch_logs
    Match               out.*
    region              region
    log_group_name      fallback-group
    log_group_template  /aws/ecs/$ecs_cluster.$ecs_task_definition_family
    log_stream_prefix   task-
    auto_create_group   On
```

Chaque journal qui entre dans Fluent Bit possède une étiquette que vous spécifiez. Si vous n'en fournissez pas, elle est générée automatiquement. Les étiquettes peuvent être utilisées pour acheminer différents journaux vers différentes destinations. Pour plus d'informations, voir [Tag](https://docs.fluentbit.io/manual/concepts/key-concepts#tag) (Étiquette) dans le *manuel officiel de Fluent Bit*. 

La configuration Fluent Bit décrite ci-dessus possède les propriétés suivantes :
+ Le plug-in d'entrée directe écoute le trafic entrant sur le port TCP 24224. 
+ Chaque entrée de journal reçue sur ce port possède une étiquette que le plug-in d'entrée directe modifie pour préfixer l'enregistrement avec une chaîne `ecs.`. 
+ Le pipeline interne de Fluent Bit achemine l'entrée du journal pour modifier le filtre à l'aide d'une correspondance d'expression régulière (regex). Ce filtre remplace les clés dans l'enregistrement de journal au format JSON par le format que Fluent Bit peut utiliser. 
+ L'entrée de journal modifiée est ensuite utilisée par le filtre rewrite\$1tag. Ce filtre remplace la balise de l'enregistrement du journal par le format out. *TASK\$1ID*. *CONTAINER\$1NAME*. 
+ La nouvelle balise sera acheminée vers le plug-in de sortie cloudwatch\$1logs qui crée les groupes de journaux et les flux comme décrit précédemment en utilisant les `log_stream_prefix` options `log_group_template` et du plug-in de sortie. CloudWatch Pour plus d'informations, voir [Configuration parameters](https://docs.fluentbit.io/manual/v/1.9-pre/pipeline/outputs/cloudwatch#configuration-parameters) (Paramètres de configuration) dans le *manuel officiel de Fluent Bit*. 

## Étape 4 : enregistrer une définition de tâche Windows Fluent Bit qui achemine les journaux vers CloudWatch
<a name="tutorial-deploy-fluentbit-on-windows-register-task-definition"></a>

Enregistrez une définition de tâche Windows Fluent Bit vers laquelle les journaux sont acheminés CloudWatch.

**Note**  
Cette définition de tâche expose le port 24224 du conteneur Fluent Bit au port hôte 24224. Vérifiez que ce port n'est pas ouvert dans le groupe de sécurité de votre instance EC2 pour empêcher tout accès depuis l'extérieur.

**Pour enregistrer une définition de tâche**

1. Créez un fichier nommé `fluent-bit.json` avec les contenus suivants.

   Remplacez les variables suivantes :
   + *task-iam-role*avec le nom de ressource Amazon (ARN) de votre tâche (rôle IAM)
   + *region*avec la région dans laquelle s'exécute votre tâche

   ```
   {
     "family": "ecs-windows-fluent-bit",
     "taskRoleArn": "task-iam-role",
     "containerDefinitions": [
       {
         "name": "fluent-bit",
         "image": "public.ecr.aws/aws-observability/aws-for-fluent-bit:windowsservercore-latest",
         "cpu": 512,
         "portMappings": [
           {
             "hostPort": 24224,
             "containerPort": 24224,
             "protocol": "tcp"
           }
         ],
         "entryPoint": [
           "Powershell",
           "-Command"
         ],
         "command": [
           "C:\\entrypoint.ps1 -ConfigFile C:\\ecs_windows_forward_daemon\\cloudwatch.conf"
         ],
         "environment": [
           {
             "name": "AWS_REGION",
             "value": "region"
           }
         ],
         "memory": 512,
         "essential": true,
         "logConfiguration": {
           "logDriver": "awslogs",
           "options": {
             "awslogs-group": "/ecs/fluent-bit-logs",
             "awslogs-region": "region",
             "awslogs-stream-prefix": "flb",
             "awslogs-create-group": "true"
           }
         }
       }
     ],
     "memory": "512",
     "cpu": "512"
   }
   ```

1. Utilisez la commande suivante pour enregistrer la définition de tâche.

   ```
   aws ecs register-task-definition --cli-input-json file://fluent-bit.json --region region
   ```

   Vous pouvez répertorier les définitions de tâche de votre compte en exécutant la commande `list-task-definitions`. La sortie affiche les valeurs de famille et de révision que vous pouvez utiliser conjointement avec `run-task` ou `start-task`.

## Étape 5 : Exécuter la définition de tâche `ecs-windows-fluent-bit` en tant que service Amazon ECS en utilisant la stratégie de planification du démon
<a name="tutorial-deploy-fluentbit-on-windows-run-task"></a>

Après avoir enregistré une définition de tâche pour votre compte, vous pouvez exécuter une tâche dans le cluster. Pour ce didacticiel, vous exécutez une instance de la définition de tâche `ecs-windows-fluent-bit:1` de votre cluster `FluentBit-cluster`. Exécutez la tâche dans un service qui utilise la stratégie de planification du démon, qui garantit qu'une seule instance de Fluent Bit s'exécute toujours sur chacune de vos instances de conteneur.

**Pour exécuter une tâche**

1. Exécutez la commande suivante pour démarrer la définition de la tâche `ecs-windows-fluent-bit:1` (enregistrée à l'étape précédente) en tant que service.
**Note**  
Cette définition de tâche utilise le pilote de journalisation `awslogs`. Votre instance de conteneur doit disposer des autorisations nécessaires.

   Remplacez les variables suivantes :
   + *region*avec la région où fonctionne votre service

   ```
   aws ecs create-service \
       --cluster FluentBit-cluster \
       --service-name FluentBitForwardDaemonService \
       --task-definition ecs-windows-fluent-bit:1 \
       --launch-type EC2 \
       --scheduling-strategy DAEMON \
       --region region
   ```

1. Exécutez la commande suivante pour répertorier vos tâches.

   Remplacez les variables suivantes :
   + *region*avec la région dans laquelle s'exécutent vos tâches de service

   ```
   aws ecs list-tasks --cluster FluentBit-cluster --region region
   ```

## Étape 6 : Enregistrer une définition de tâche Windows qui génère les journaux
<a name="tutorial-deploy-fluentbit-on-windows-register-task-def-logs"></a>

Enregistrez une définition de tâche qui génère les journaux. Cette définition de tâche déploie une image de conteneur Windows qui écrira un nombre incrémentiel à `stdout` toutes les secondes.

La définition de la tâche utilise le pilote de journalisation Fluentd qui se connecte au port 24224 que le plug-in Fluent Bit écoute. L'agent Amazon ECS met des étiquettes à chaque conteneur ECS qui incluent le nom du cluster, l'ARN de la tâche, le nom de famille de la définition de la tâche, le numéro de révision de la définition de la tâche et le nom du conteneur de la tâche. Ces étiquettes clé-valeur sont transmises à Fluent Bit.

**Note**  
Cette tâche utilise également le mode réseau `default`. Toutefois, vous pouvez aussi utiliser le mode réseau `awsvpc` avec la tâche.

**Pour enregistrer une définition de tâche**

1. Créez un fichier nommé `windows-app-task.json` avec les contenus suivants.

   ```
   {
     "family": "windows-app-task",
     "containerDefinitions": [
       {
         "name": "sample-container",
         "image": "mcr.microsoft.com/windows/servercore:ltsc2019",
         "cpu": 512,
         "memory": 512,
         "essential": true,
         "entryPoint": [
           "Powershell",
           "-Command"
         ],
         "command": [
           "$count=1;while(1) { Write-Host $count; sleep 1; $count=$count+1;}"
         ],
         "logConfiguration": {
           "logDriver": "fluentd",
           "options": {
             "fluentd-address": "localhost:24224",
             "tag": "{{ index .ContainerLabels \"com.amazonaws.ecs.task-definition-family\" }}",
             "fluentd-async": "true",
             "labels": "com.amazonaws.ecs.cluster,com.amazonaws.ecs.container-name,com.amazonaws.ecs.task-arn,com.amazonaws.ecs.task-definition-family,com.amazonaws.ecs.task-definition-version"
           }
         }
       }
     ],
     "memory": "512",
     "cpu": "512"
   }
   ```

1. Utilisez la commande suivante pour enregistrer la définition de tâche.

   Remplacez les variables suivantes :
   + *region*avec la région dans laquelle s'exécute votre tâche

   ```
   aws ecs register-task-definition --cli-input-json file://windows-app-task.json --region region
   ```

   Vous pouvez répertorier les définitions de tâche de votre compte en exécutant la commande `list-task-definitions`. La sortie affiche les valeurs de famille et de révision que vous pouvez utiliser conjointement avec `run-task` ou `start-task`.

## Étape 7 : Créer la définition de tâche `windows-app-task`
<a name="tutorial-deploy-fluentbit-on-windows-run-task-fluentbit"></a>

Après avoir enregistré la définition de tâche `windows-app-task`, exécutez-la dans votre cluster `FluentBit-cluster`.

**Pour exécuter une tâche**

1. Exécutez la définition de tâche `windows-app-task:1` que vous avez enregistrée à l'étape précédente.

   Remplacez les variables suivantes :
   + *region*avec la région dans laquelle s'exécute votre tâche

   ```
   aws ecs run-task --cluster FluentBit-cluster --task-definition windows-app-task:1 --count 2 --region region
   ```

1. Exécutez la commande suivante pour répertorier vos tâches.

   ```
   aws ecs list-tasks --cluster FluentBit-cluster
   ```

## Étape 8 : Vérifiez les connexions CloudWatch
<a name="tutorial-deploy-fluentbit-on-windows-verify"></a>

Afin de vérifier votre configuration Fluent Bit, vérifiez les groupes de journaux suivants dans la CloudWatch console :
+ `/ecs/fluent-bit-logs` : il s'agit du groupe de journaux qui correspond au conteneur de démon Fluent Bit qui s'exécute sur l'instance de conteneur.
+ `/aws/ecs/FluentBit-cluster.windows-app-task` : il s'agit du groupe de journaux qui correspond à toutes les tâches lancées pour la famille de définition de tâche `windows-app-task` au sein du cluster `FluentBit-cluster`.

   `task-out.FIRST_TASK_ID.sample-container` : ce flux de journaux contient tous les journaux générés par la première instance de la tâche dans le conteneur de tâches sample-container. 

  `task-out.SECOND_TASK_ID.sample-container` : ce flux de journaux contient tous les journaux générés par la seconde instance de la tâche dans le conteneur de tâches sample-container. 

 Le flux de journaux `task-out.TASK_ID.sample-container` contient des champs similaires aux suivants :

```
{
    "source": "stdout",
    "ecs_task_arn": "arn:aws:ecs:region:0123456789012:task/FluentBit-cluster/13EXAMPLE",
    "container_name": "/ecs-windows-app-task-1-sample-container-cEXAMPLE",
    "ecs_cluster": "FluentBit-cluster",
    "ecs_container_name": "sample-container",
    "ecs_task_definition_version": "1",
    "container_id": "61f5e6EXAMPLE",
    "log": "10",
    "ecs_task_definition_family": "windows-app-task"
}
```

**Pour vérifier la configuration Fluent Bit**

1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Dans le panneau de navigation, choisissez **Groupes de journaux**. Assurez-vous que vous êtes dans la région où vous avez déployé Fluent Bit sur vos conteneurs.

   Dans la liste des groupes de journaux du Région AWS, vous devriez voir ce qui suit :
   + `/ecs/fluent-bit-logs`
   + `/aws/ecs/FluentBit-cluster.windows-app-task`

   Si vous voyez ces groupes de journaux, la vérification de la configuration Fluent Bit est terminée.

## Étape 9 : nettoyer
<a name="tutorial-deploy-fluentbit-on-windows-cleanup"></a>

Lorsque vous avez terminé ce didacticiel, nettoyez les ressources qui lui sont associées afin d'éviter la facturation de frais pour des ressources que vous n'utilisez pas. 

**Pour nettoyer les ressources du didacticiel**

1. Arrêtez la tâche `windows-simple-task` et la tâche `ecs-fluent-bit`. Pour de plus amples informations, veuillez consulter [Arrêt d’une tâche Amazon ECS](standalone-task-stop.md).

1. Utilisez la commande suivante pour supprimer le groupe de journaux `/ecs/fluent-bit-logs`. Pour plus d'informations, sur la suppression de groupes de journaux [delete-log-group](https://docs.aws.amazon.com/cli/latest/reference/logs/delete-log-group.html), voir la *AWS Command Line Interface référence*.

   ```
   aws logs delete-log-group --log-group-name /ecs/fluent-bit-logs
   aws logs delete-log-group --log-group-name /aws/ecs/FluentBit-cluster.windows-app-task
   ```

1. Exécutez la commande suivante pour mettre fin à l'instance.

   ```
   aws ec2 terminate-instances --instance-ids instance-id
   ```

1. Exécutez les commandes suivantes pour supprimer les rôles IAM. 

   ```
   aws iam delete-role --role-name ecsInstanceRole
   aws iam delete-role --role-name fluentTaskRole
   ```

1. Exécutez la commande suivante pour supprimer le cluster Amazon ECS.

   ```
   aws ecs delete-cluster --cluster FluentBit-cluster
   ```

# Utilisation de gMSA pour les conteneurs Linux EC2 sur Amazon ECS
<a name="linux-gmsa"></a>

Amazon ECS prend en charge l’authentification Active Directory pour les conteneurs Linux sur EC2 par l’intermédiaire d’un type de compte de service spécial appelé *group Managed Service Account* (gMSA).

Les applications réseau Linux, comme les applications .NET Core, peuvent faire appel à Active Directory pour faciliter la gestion de l'authentification et des autorisations entre les utilisateurs et les services. Vous pouvez utiliser cette fonctionnalité en concevant des applications qui s'intègrent à Active Directory et s'exécutent sur des serveurs joints à un domaine. Toutefois, comme les conteneurs Linux ne peuvent pas être joints à un domaine, vous devez configurer un conteneur Linux pour qu'il soit exécuté avec gMSA.

Un conteneur Linux qui s'exécute avec gMSA repose sur le démon `credentials-fetcher` qui s'exécute sur l'instance Amazon EC2 hôte du conteneur. En d'autres termes, le démon récupère les informations d'identification gMSA auprès du contrôleur de domaine Active Directory, puis les transfère à l'instance de conteneur. Pour plus d'informations sur les comptes de service, veuillez consulter [Créer des gMSAs pour des conteneurs Windows](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts) sur le site Web de Microsoft Learn.

## Considérations
<a name="linux-gmsa-considerations"></a>

Tenez compte des points suivants avant d'utiliser des gMSA pour les conteneurs Linux :
+ Si vos conteneurs fonctionnent sur EC2, vous pouvez utiliser des gMSA pour les conteneurs Windows et Linux. Pour plus d’informations sur l’utilisation de gMSA pour un conteneur Linux sur Fargate, consultez la section [Utilisation de gMSA pour les conteneurs Linux sur Fargate](fargate-linux-gmsa.md).
+ Vous aurez peut-être besoin d'un ordinateur Windows joint au domaine pour remplir les conditions requises. Par exemple, vous pourriez avoir besoin d'un ordinateur Windows joint au domaine pour créer le gMSA dans Active Directory avec PowerShell. Les PowerShell outils RSAT Active Director ne sont disponibles que pourWindows. Pour plus d'informations, veuillez consulter [Installation des outils d'administration Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_install_ad_tools.html) (langue française non garantie).
+ Vous avez choisi entre les **gMSA sans domaine** et **joindre chaque instance à un seul domaine**. En utilisant les gMSA sans domaine, l'instance de conteneur n'est pas jointe au domaine, les autres applications de l'instance ne peuvent pas utiliser les informations d'identification pour accéder au domaine et les tâches qui joignent différents domaines peuvent s'exécuter sur la même instance.

  Choisissez ensuite le stockage de données pour CredSpec et, éventuellement, pour les informations d'identification utilisateur Active Directory pour les gMSA sans domaine.

  Amazon ECS utilise un fichier de spécification des informations d'identification Active Directory (CredSpec). Ce fichier contient les métadonnées gMSA servant à propager le contexte du compte gMSA au conteneur. Vous générez le fichier CredSpec, puis vous le stockez dans l'une des options de stockage CredSpec du tableau suivant, spécifique au système d'exploitation des instances de conteneur. Pour utiliser la méthode sans domaine, une section facultative du fichier CredSpec peut spécifier les informations d'identification dans l'une des options de stockage *domainless user credentials* du tableau suivant, spécifiques au système d'exploitation des instances de conteneur.    
<a name="gmsa-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonECS/latest/developerguide/linux-gmsa.html)

## Conditions préalables
<a name="linux-gmsa-prerequisites"></a>

Avant d'utiliser la fonctionnalité gMSA pour les conteneurs Linux avec Amazon ECS, assurez-vous de remplir les conditions suivantes :
+ Vous configurez un domaine Active Directory avec les ressources auxquelles vous souhaitez que vos conteneurs accèdent. Amazon ECS prend en charge les configurations suivantes :
  + Un Directory Service Active Directory. Directory Service est un Active Directory AWS géré hébergé sur Amazon EC2. Pour plus d'informations, consultez [Getting Started with AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) dans le *Guide d'AWS Directory Service administration*.
  + Un répertoire Active Directory sur site. Vous devez vous assurer que l'instance de conteneur Linux Amazon ECS peut se joindre au domaine. Pour de plus amples informations, veuillez consulter [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect.html).
+ Vous disposez d'un compte gMSA existant dans l'Active Directory. Pour de plus amples informations, veuillez consulter [Utilisation de gMSA pour les conteneurs Linux EC2 sur Amazon ECS](#linux-gmsa).
+ Vous avez installé et vous exécutez le démon `credentials-fetcher` sur une instance de conteneur Linux Amazon ECS. Vous avez également ajouté un jeu initial d'informations d'identification au démon `credentials-fetcher` pour vous authentifier auprès d'Active Directory.
**Note**  
Le démon `credentials-fetcher` est uniquement disponible pour Amazon Linux 2023 et Fedora 37 et versions ultérieures. Le démon n'est pas disponible pour Amazon Linux 2. Pour plus d'informations, consultez [aws/credentials-fetcher](https://github.com/aws/credentials-fetcher) on. GitHub
+ Vous configurez les informations d'identification permettant au démon `credentials-fetcher` de s'authentifier auprès d'Active Directory. Les informations d'identification doivent être membres du groupe de sécurité Active Directory qui a accès au compte gMSA. Il existe plusieurs options dans [Décidez si vous souhaitez joindre les instances au domaine ou utiliser le gMSA sans domaine.](#linux-gmsa-initial-creds).
+ Vous avez ajouté les autorisations IAM requises. Les autorisations requises dépendent des méthodes que vous choisissez pour les informations d'identification initiales et pour le stockage de la spécification des informations d'identification :
  + Si vous utilisez *domainless gMSA* pour les informations d'identification initiales, les autorisations IAM pour AWS Secrets Manager sont requises pour le rôle d'exécution de la tâche.
  + Si vous stockez la spécification des informations d'identification dans SSM Parameter Store, les autorisations IAM d'Amazon EC2 Systems Manager Parameter Store sont requises pour le rôle d'exécution de la tâche.
  + Si vous stockez la spécification des informations d'identification dans Amazon S3, les autorisations IAM d'Amazon Simple Storage Service sont requises sur le rôle d'exécution de la tâche.

## Configuration de conteneurs Linux compatibles avec gMSA sur Amazon ECS
<a name="linux-gmsa-setup"></a>
<a name="linux-gmsa-setup-infra"></a>
**Préparation de l'infrastructure**  
Les étapes suivantes sont des considérations et une configuration qui ne sont effectuées qu'une seule fois. Après avoir terminé ces étapes, vous pouvez automatiser la création d'instances de conteneur afin de réutiliser cette configuration.

Décidez de la manière dont les informations d'identification initiales sont fournies et configurez les données utilisateur EC2 dans un modèle de lancement EC2 réutilisable pour installer le démon `credentials-fetcher`.

1. <a name="linux-gmsa-initial-creds"></a>

**Décidez si vous souhaitez joindre les instances au domaine ou utiliser le gMSA sans domaine.**
   + <a name="linux-gmsa-initial-join"></a>

**Jonction des instances EC2 au domaine Active Directory**

     
     + <a name="linux-gmsa-initial-join-userdata"></a>

**Jointure des instances par les données utilisateur**

       Ajoutez les étapes permettant de joindre le domaine Active Directory à vos données utilisateur EC2 dans un modèle de lancement EC2. Plusieurs groupes Amazon EC2 Auto Scaling peuvent utiliser le même modèle de lancement.

       Vous pouvez suivre ces étapes pour [Rejoindre un Active Directory ou un domaine FreeIPA](https://docs.fedoraproject.org/en-US/quick-docs/join-active-directory-freeipa/) dans les Fedora Docs (langue française non garantie).
   + <a name="linux-gmsa-initial-domainless"></a>

**Création d'un utilisateur Active Directory pour gMSA sans domaine**

     Le démon `credentials-fetcher` possède une fonctionnalité appelée *gMSA sans domaine*. Cette fonctionnalité nécessite un domaine, mais il n'est pas nécessaire que l'instance EC2 soit jointe au domaine. En utilisant les gMSA sans domaine, l'instance de conteneur n'est pas jointe au domaine, les autres applications de l'instance ne peuvent pas utiliser les informations d'identification pour accéder au domaine et les tâches qui joignent différents domaines peuvent s'exécuter sur la même instance. Vous devez plutôt fournir le nom d'un secret d' AWS Secrets Manager dans le fichier CredSpec. Le secret doit contenir un nom d'utilisateur, un mot de passe et le domaine auquel se connecter.

     Cette fonctionnalité est prise en charge et peut être utilisée avec les conteneurs Linux et Windows.

     Cette fonctionnalité est similaire à la fonctionnalité *gMSA support for non-domain-joined container hosts*. Pour plus d'informations sur la fonctionnalité Windows, veuillez consulter [Architecture et améliorations des gMSA](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#gmsa-architecture-and-improvements) sur le site Web de Microsoft Learn.

     1. Créez un utilisateur dans votre domaine Active Directory. L'utilisateur d'Active Directory doit être autorisé à accéder aux comptes de service gMSA que vous utilisez dans les tâches.

     1. Créez un secret dans AWS Secrets Manager, après avoir créé l'utilisateur dans Active Directory. Pour plus d'informations, voir [Création d'un AWS Secrets Manager secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).

     1. Saisissez respectivement le nom d'utilisateur, le mot de passe et le domaine de l'utilisateur dans les paires clé-valeur JSON appelées `username`, `password` et `domainName`.

        ```
        {"username":"username","password":"passw0rd", "domainName":"example.com"}
        ```

     1. Ajoutez la configuration au fichier CredSpec pour le compte de service. La `HostAccountConfig` supplémentaire contient l'Amazon Resource Name (ARN) du secret dans Secrets Manager.

        Sous Windows, le `PluginGUID` doit correspondre au GUID indiqué dans l'exemple de code suivant. Sous Linux, le `PluginGUID` est ignoré. Remplacez `MySecret` par l'exemple avec l'Amazon Resource Name (ARN) de votre secret.

        ```
            "ActiveDirectoryConfig": {
                "HostAccountConfig": {
                    "PortableCcgVersion": "1",
                    "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
                    "PluginInput": {
                        "CredentialArn": "arn:aws:secretsmanager:aws-region:111122223333:secret:MySecret"
                    }
                }
        ```

     1. La fonctionnalité *gMSA sans domaine* nécessite des autorisations supplémentaires dans le rôle d'exécution des tâches. Suivez l'étape [(Facultatif) secret gMSA sans domaine](#linux-gmsa-domainless-secret).

1. <a name="linux-gmsa-install"></a>

**Configurez des instances et installez le démon `credentials-fetcher`.**

   Vous pouvez installer le démon `credentials-fetcher` avec un script de données utilisateur dans votre modèle de lancement EC2. Les exemples suivants illustrent deux types de données utilisateur, `cloud-config` YAML ou le script bash. Ces exemples concernent Amazon Linux 2023 (AL2023). Remplacez `MyCluster` par le nom du cluster Amazon ECS que vous souhaitez que ces instances rejoignent.
   + <a name="linux-gmsa-install-yaml"></a>

**`cloud-config` YAML**

     ```
     Content-Type: text/cloud-config
     package_reboot_if_required: true
     packages:
       # prerequisites
       - dotnet
       - realmd
       - oddjob
       - oddjob-mkhomedir
       - sssd
       - adcli
       - krb5-workstation
       - samba-common-tools
       # https://github.com/aws/credentials-fetcher gMSA credentials management for containers
       - credentials-fetcher
     write_files:
     # configure the ECS Agent to join your cluster.
     # replace MyCluster with the name of your cluster.
     - path: /etc/ecs/ecs.config
       owner: root:root
       permissions: '0644'
       content: |
         ECS_CLUSTER=MyCluster
         ECS_GMSA_SUPPORTED=true
     runcmd:
     # start the credentials-fetcher daemon and if it succeeded, make it start after every reboot
     - "systemctl start credentials-fetcher"
     - "systemctl is-active credentials-fetcher && systemctl enable credentials-fetcher"
     ```
   + <a name="linux-gmsa-install-userdata"></a>

**Script bash**

     Si vous êtes plus à l'aise avec les scripts bash et que vous avez plusieurs variables à écrire dans `/etc/ecs/ecs.config`, utilisez le format `heredoc` suivant. Ce format écrit tout entre les lignes commençant par **cat** et `EOF` dans le fichier de configuration.

     ```
     #!/usr/bin/env bash
     set -euxo pipefail
     
     # prerequisites
     timeout 30 dnf install -y dotnet realmd oddjob oddjob-mkhomedir sssd adcli krb5-workstation samba-common-tools
     # install https://github.com/aws/credentials-fetcher gMSA credentials management for containers
     timeout 30 dnf install -y credentials-fetcher
     
     # start credentials-fetcher
     systemctl start credentials-fetcher
     systemctl is-active credentials-fetcher && systemctl enable credentials-fetcher
     
     cat <<'EOF' >> /etc/ecs/ecs.config
     ECS_CLUSTER=MyCluster
     ECS_GMSA_SUPPORTED=true
     EOF
     ```

   Il existe des variables de configuration facultatives pour le démon `credentials-fetcher` que vous pouvez définir dans `/etc/ecs/ecs.config`. Nous vous recommandons de définir les variables dans les données utilisateur du bloc YAML ou `heredoc` de manière similaire aux exemples précédents. Cela permet d'éviter les problèmes de configuration partielle qui peuvent survenir lors de la modification d'un fichier à plusieurs reprises. Pour plus d'informations sur la configuration de l'agent ECS, consultez [Amazon ECS Container Agent](https://github.com/aws/amazon-ecs-agent/blob/master/README.md#environment-variables) on GitHub.
   + Vous pouvez éventuellement utiliser la variable `CREDENTIALS_FETCHER_HOST` si vous modifiez la configuration du démon `credentials-fetcher` pour déplacer le socket vers un autre emplacement.

**Configuration des autorisations et des secrets**  
Effectuez les étapes suivantes une fois pour chaque application et chaque définition de tâche. Nous vous recommandons d'utiliser le principe de moindre privilège et d'affiner les autorisations utilisées dans la stratégie. Ainsi, chaque tâche ne peut lire que les secrets dont elle a besoin.

1. <a name="linux-gmsa-domainless-secret"></a>

**(Facultatif) secret gMSA sans domaine**

   Si vous utilisez la méthode sans domaine dans laquelle l'instance n'est pas jointe au domaine, procédez comme suit.

   Vous devez ajouter les autorisations suivantes sous forme de stratégie en ligne au rôle IAM d'exécution de tâche. Cela permet au démon `credentials-fetcher` d'accéder au secret Secrets Manager. Remplacez l'exemple `MySecret` par l'Amazon Resource Name (ARN) de votre secret dans la liste `Resource`.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:my-secret-AbCdEf"
           }
       ]
   }
   ```

------
**Note**  
Si vous utilisez votre propre clé KMS pour chiffrer votre secret, vous devez ajouter les autorisations nécessaires à ce rôle et ajouter ce rôle à la politique des AWS KMS clés.

1. 

**Décidez si vous utilisez SSM Parameter Store ou S3 pour stocker le CredSpec.**

   Amazon ECS permet de référencer le chemin du fichier dans le champ `credentialSpecs` d'une définition de tâche.

   Si vous joignez les instances à un seul domaine, utilisez le préfixe `credentialspec:` au début de l'ARN dans la chaîne. Si vous utilisez le gMSA sans domaine, utilisez `credentialspecdomainless:`.

   Pour en savoir plus sur CredSpec, consultez [Fichier de spécification des informations d'identification](#linux-gmsa-credentialspec).
   + <a name="linux-gmsa-credspec-s3"></a>

**Compartiment Amazon S3**

     Ajoutez la spécification d'informations d'identification à un compartiment Amazon S3. Référencez ensuite l'Amazon Resource Name (ARN) du compartiment Amazon S3 dans le champ `credentialSpecs` de la définition de tâche.

     ```
     {
         "family": "",
         "executionRoleArn": "",
         "containerDefinitions": [
             {
                 "name": "",
                 ...
                 "credentialSpecs": [
                     "credentialspecdomainless:arn:aws:s3:::${BucketName}/${ObjectName}"
                 ],
                 ...
             }
         ],
         ...
     }
     ```

     Pour permettre à vos tâches d'accéder au compartiment S3, ajoutez les autorisations suivantes sous forme de stratégie en ligne au rôle IAM d'exécution de tâche Amazon ECS.

------
#### [ JSON ]

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
         "Statement": [
             {
                 "Sid": "VisualEditor",
                 "Effect": "Allow",
                 "Action": [
                     "s3:Get*",
                     "s3:List*"
                 ],
                 "Resource": [
                     "arn:aws:s3:::amzn-s3-demo-bucket",
                     "arn:aws:s3:::amzn-s3-demo-bucket/{object}"
                 ]
             }
         ]
     }
     ```

------
   + <a name="linux-gmsa-credspec-ssm"></a>

**Paramètre SSM Parameter Store**

     Ajoutez la spécification d'informations d'identification à un paramètre de SSM Parameter Store. Référencez ensuite l'Amazon Resource Name (ARN) du paramètre de SSM Parameter Store dans le champ `credentialSpecs` de la définition de tâche.

     ```
     {
         "family": "",
         "executionRoleArn": "",
         "containerDefinitions": [
             {
                 "name": "",
                 ...
                 "credentialSpecs": [
                     "credentialspecdomainless:arn:aws:ssm:aws-region:111122223333:parameter/parameter_name"
                 ],
                 ...
             }
         ],
         ...
     }
     ```

     Pour permettre à vos tâches d'accéder au paramètre de SSM Parameter Store, ajoutez les autorisations suivantes sous forme de stratégie en ligne au rôle IAM d'exécution de tâche Amazon ECS.

------
#### [ JSON ]

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
         "Statement": [
             {
                 "Effect": "Allow",
                 "Action": [
                     "ssm:GetParameters"
                 ],
                 "Resource": "arn:aws:ssm:us-east-1:123456789012:parameter/my-parameter"
             }
         ]
     }
     ```

------

## Fichier de spécification des informations d'identification
<a name="linux-gmsa-credentialspec"></a>

Amazon ECS utilise un fichier de spécification des informations d'identification Active Directory (*CredSpec*). Ce fichier contient les métadonnées gMSA servant à propager le contexte du compte gMSA au conteneur Linux. Vous générez le CredSpec et le référencez dans le champ `credentialSpecs` de votre définition de tâche. Le fichier CredSpec ne contient aucun secret.

Voici un exemple de fichier CredSpec.

```
{
    "CmsPlugins": [
        "ActiveDirectory"
    ],
    "DomainJoinConfig": {
        "Sid": "S-1-5-21-2554468230-2647958158-2204241789",
        "MachineAccountName": "WebApp01",
        "Guid": "8665abd4-e947-4dd0-9a51-f8254943c90b",
        "DnsTreeName": "example.com",
        "DnsName": "example.com",
        "NetBiosName": "example"
    },
    "ActiveDirectoryConfig": {
        "GroupManagedServiceAccounts": [
            {
                "Name": "WebApp01",
                "Scope": "example.com"
            }
        ],
        "HostAccountConfig": {
            "PortableCcgVersion": "1",
            "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
            "PluginInput": {
                "CredentialArn": "arn:aws:secretsmanager:aws-region:111122223333:secret:MySecret"
            }
        }
    }
}
```
<a name="linux-gmsa-credentialspec-create"></a>
**Création d’un CredSpec**  
Vous créez un CredSpec en utilisant le module PowerShell CredSpec sur un ordinateur Windows joint au domaine. Suivez les étapes décrites dans [Créer une spécification d'informations d'identification](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#create-a-credential-spec) sur le site Web Microsoft Learn.

# Utilisation de gMSA pour les conteneurs Linux sur Fargate
<a name="fargate-linux-gmsa"></a>

Amazon ECS prend en charge l’authentification Active Directory pour les conteneurs Linux sur Fargate par l’intermédiaire d’un type de compte de service spécial appelé *compte de service géré de groupe* (gMSA).

Les applications réseau Linux, comme les applications .NET Core, peuvent faire appel à Active Directory pour faciliter la gestion de l'authentification et des autorisations entre les utilisateurs et les services. Vous pouvez utiliser cette fonctionnalité en concevant des applications qui s'intègrent à Active Directory et s'exécutent sur des serveurs joints à un domaine. Toutefois, comme les conteneurs Linux ne peuvent pas être joints à un domaine, vous devez configurer un conteneur Linux pour qu'il soit exécuté avec gMSA.

## Considérations
<a name="fargate-linux-gmsa-considerations"></a>

Tenez compte des points suivants avant d’utiliser gMSA pour les conteneurs Linux sur Fargate :
+ Vous devez exécuter la version de plateforme 1.4 ou ultérieure.
+ Vous aurez peut-être besoin d'un ordinateur Windows joint au domaine pour remplir les conditions requises. Par exemple, vous pourriez avoir besoin d'un ordinateur Windows joint au domaine pour créer le gMSA dans Active Directory avec PowerShell. Les PowerShell outils RSAT Active Director ne sont disponibles que pourWindows. Pour plus d'informations, veuillez consulter [Installation des outils d'administration Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_install_ad_tools.html) (langue française non garantie).
+ Vous devez utiliser l’option **gMSA sans domaine** 

  Amazon ECS utilise un fichier de spécification des informations d'identification Active Directory (CredSpec). Ce fichier contient les métadonnées gMSA servant à propager le contexte du compte gMSA au conteneur. Vous générez le fichier CredSpec, puis vous le stockez dans un compartiment Amazon S3.
+ Une tâche ne peut prendre en charge qu’un seul Active Directory.

## Conditions préalables
<a name="fargate-linux-gmsa-prerequisites"></a>

Avant d'utiliser la fonctionnalité gMSA pour les conteneurs Linux avec Amazon ECS, assurez-vous de remplir les conditions suivantes :
+ Vous configurez un domaine Active Directory avec les ressources auxquelles vous souhaitez que vos conteneurs accèdent. Amazon ECS prend en charge les configurations suivantes :
  + Un Directory Service Active Directory. Directory Service est un Active Directory AWS géré hébergé sur Amazon EC2. Pour plus d'informations, consultez [Getting Started with AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) dans le *Guide d'AWS Directory Service administration*.
  + Un répertoire Active Directory sur site. Vous devez vous assurer que l'instance de conteneur Linux Amazon ECS peut se joindre au domaine. Pour de plus amples informations, veuillez consulter [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect-network-to-amazon.html).
+ Vous disposez d’un compte gMSA existant dans Active Directory et d’un utilisateur autorisé à accéder au compte de service gMSA. Pour de plus amples informations, veuillez consulter [Création d'un utilisateur Active Directory pour gMSA sans domaine](#fargate-linux-gmsa-initial-domainless).
+ Vous disposez d’un compartiment Amazon S3. Pour plus d’informations, consultez la section [Création d’un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) dans le *Guide de l’utilisateur Amazon S3*.

## Configuration de conteneurs Linux compatibles avec gMSA sur Amazon ECS
<a name="fargate-linux-gmsa-setup"></a>
<a name="linux-gmsa-setup-infra"></a>
**Préparation de l'infrastructure**  
Les étapes suivantes sont des considérations et une configuration qui ne sont effectuées qu'une seule fois. 
+ <a name="fargate-linux-gmsa-initial-domainless"></a>

**Création d'un utilisateur Active Directory pour gMSA sans domaine**

  Lorsque vous utilisez l’option gMSA sans domaine, le conteneur n’est pas joint au domaine. Les autres applications qui s’exécutent sur le conteneur ne peuvent pas utiliser les informations d’identification pour accéder au domaine. Les tâches qui utilisent un domaine différent peuvent être exécutées sur le même conteneur. Vous indiquez le nom d'un secret AWS Secrets Manager dans le CredSpec fichier. Le secret doit contenir un nom d'utilisateur, un mot de passe et le domaine auquel se connecter.

  Cette fonctionnalité est similaire à la fonctionnalité *gMSA support for non-domain-joined container hosts*. Pour plus d'informations sur la fonctionnalité Windows, veuillez consulter [Architecture et améliorations des gMSA](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#gmsa-architecture-and-improvements) sur le site Web de Microsoft Learn.

  1. Configurez un utilisateur dans votre domaine Active Directory. L’utilisateur d’Active Directory doit être autorisé à accéder au compte de service gMSA que vous utilisez dans les tâches.

  1. Vous disposez d'un VPC et de sous-réseaux capables de résoudre le nom de domaine Active Directory. Configurez le VPC avec les options DHCP en utilisant le nom de domaine qui pointe vers le nom du service Active Directory. Pour plus d’informations sur les options DHCP, consultez la section [Utilisation des jeux d’options DHCP](https://docs.aws.amazon.com/vpc/latest/userguide/DHCPOptionSet.html) dans le *Guide de l’utilisateur Amazon Virtual Private Cloud*.

  1. Créez un secret dans AWS Secrets Manager. 

  1. Créez le fichier de spécification des informations d’identification.

**Configuration des autorisations et des secrets**  
Effectuez les étapes suivantes une fois pour chaque application et chaque définition de tâche. Nous vous recommandons d'utiliser le principe de moindre privilège et d'affiner les autorisations utilisées dans la stratégie. Ainsi, chaque tâche ne peut lire que les secrets dont elle a besoin.

1. Créez un utilisateur dans votre domaine Active Directory. L'utilisateur d'Active Directory doit être autorisé à accéder aux comptes de service gMSA que vous utilisez dans les tâches.

1. Après avoir créé l'utilisateur Active Directory, créez un secret dans AWS Secrets Manager. Pour plus d'informations, veuillez consulter [Créer un secret AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).

1. Saisissez respectivement le nom d'utilisateur, le mot de passe et le domaine de l'utilisateur dans les paires clé-valeur JSON appelées `username`, `password` et `domainName`.

   ```
   {"username":"username","password":"passw0rd", "domainName":"example.com"}
   ```

1. <a name="fargate-linux-gmsa-domainless-secret"></a>Vous devez ajouter les autorisations suivantes sous forme de stratégie en ligne au rôle IAM d'exécution de tâche. Cela permet au démon `credentials-fetcher` d'accéder au secret Secrets Manager. Remplacez l'exemple `MySecret` par l'Amazon Resource Name (ARN) de votre secret dans la liste `Resource`.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": [
               "arn:aws:secretsmanager:us-east-1:111122223333:secret:MySecret"
               ]
           }
       ]
   }
   ```

------
**Note**  
Si vous utilisez votre propre clé KMS pour chiffrer votre secret, vous devez ajouter les autorisations nécessaires à ce rôle et ajouter ce rôle à la politique des AWS KMS clés.

1. <a name="linux-gmsa-credspec-ssm"></a>Ajoutez la spécification d'informations d'identification à un compartiment Amazon S3. Référencez ensuite l'Amazon Resource Name (ARN) du compartiment Amazon S3 dans le champ `credentialSpecs` de la définition de tâche.

   ```
   {
       "family": "",
       "executionRoleArn": "",
       "containerDefinitions": [
           {
               "name": "",
               ...
               "credentialSpecs": [
                   "credentialspecdomainless:arn:aws:s3:::${BucketName}/${ObjectName}"
               ],
               ...
           }
       ],
       ...
   }
   ```

   Pour permettre à vos tâches d'accéder au compartiment S3, ajoutez les autorisations suivantes sous forme de stratégie en ligne au rôle IAM d'exécution de tâche Amazon ECS.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "VisualEditor",
               "Effect": "Allow",
               "Action": [
               "s3:GetObjectVersion",
               "s3:ListBucket"
               ],
               "Resource": [
                   "arn:aws:s3:::{bucket_name}",
                   "arn:aws:s3:::{bucket_name}/{object}"
               ]
           }
       ]
   }
   ```

------

## Fichier de spécification des informations d'identification
<a name="fargate-linux-gmsa-credentialspec"></a>

Amazon ECS utilise un fichier de spécification des informations d'identification Active Directory (*CredSpec*). Ce fichier contient les métadonnées gMSA servant à propager le contexte du compte gMSA au conteneur Linux. Vous générez le CredSpec et le référencez dans le champ `credentialSpecs` de votre définition de tâche. Le fichier CredSpec ne contient aucun secret.

Voici un exemple de fichier CredSpec.

```
{
    "CmsPlugins": [
        "ActiveDirectory"
    ],
    "DomainJoinConfig": {
        "Sid": "S-1-5-21-2554468230-2647958158-2204241789",
        "MachineAccountName": "WebApp01",
        "Guid": "8665abd4-e947-4dd0-9a51-f8254943c90b",
        "DnsTreeName": "example.com",
        "DnsName": "example.com",
        "NetBiosName": "example"
    },
    "ActiveDirectoryConfig": {
        "GroupManagedServiceAccounts": [
            {
                "Name": "WebApp01",
                "Scope": "example.com"
            }
        ],
        "HostAccountConfig": {
            "PortableCcgVersion": "1",
            "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
            "PluginInput": {
                "CredentialArn": "arn:aws:secretsmanager:aws-region:111122223333:secret:MySecret"
            }
        }
    }
}
```
<a name="fargate-linux-gmsa-credentialspec-create"></a>
**Création d’un CredSpec et chargement vers Amazon S3**  
Vous créez un CredSpec en utilisant le module PowerShell CredSpec sur un ordinateur Windows joint au domaine. Suivez les étapes décrites dans [Créer une spécification d'informations d'identification](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#create-a-credential-spec) sur le site Web Microsoft Learn.

Après avoir créé le fichier de spécification des informations d’identification, chargez-le dans un compartiment Amazon S3. Copiez le fichier CredSpec sur l'ordinateur ou l'environnement dans lequel vous exécutez les commandes AWS CLI .

Exécutez la AWS CLI commande suivante pour le CredSpec télécharger sur Amazon S3. Remplacez `amzn-s3-demo-bucket` par le nom de votre compartiment Simple Storage Service (Amazon S3). Vous pouvez stocker le fichier sous forme d'objet dans n'importe quel compartiment et à n'importe quel emplacement, mais vous devez autoriser l'accès à ce compartiment et à cet emplacement dans la stratégie que vous associez au rôle d'exécution des tâches.

Pour PowerShell, utilisez la commande suivante :

```
$ Write-S3Object -BucketName "amzn-s3-demo-bucket" -Key "ecs-domainless-gmsa-credspec" -File "gmsa-cred-spec.json"
```

La AWS CLI commande suivante utilise des barres obliques inverses qui sont utilisées par `sh` les interpréteurs de commandes compatibles. 

```
$ aws s3 cp gmsa-cred-spec.json \
s3://amzn-s3-demo-bucket/ecs-domainless-gmsa-credspec
```

# Utilisation de conteneurs Windows Amazon ECS avec des conteneurs sans domaine à gMSA l'aide du AWS CLI
<a name="tutorial-gmsa-windows"></a>

Le didacticiel suivant explique comment créer une tâche Amazon ECS qui exécute un conteneur Windows qui possède des informations d'identification pour accéder à Active Directory avec l' AWS CLI. En utilisant les gMSA sans domaine, l'instance de conteneur n'est pas jointe au domaine, les autres applications de l'instance ne peuvent pas utiliser les informations d'identification pour accéder au domaine et les tâches qui joignent différents domaines peuvent s'exécuter sur la même instance.

**Topics**
+ [

## Conditions préalables
](#tutorial-gmsa-windows-prerequisites)
+ [

## Étape 1 : créer et configurer le compte gMSA sur les services de domaine Active Directory (AD DS)
](#tutorial-gmsa-windows-step1)
+ [

## Étape 2 : charger les informations d'identification dans Secrets Manager
](#tutorial-gmsa-windows-step2)
+ [

## Étape 3 : modifier votre JSON CredSpec pour inclure des informations gMSA sans domaine
](#tutorial-gmsa-windows-step3)
+ [

## Étape 4 : charger CredSpec dans Amazon S3
](#tutorial-gmsa-windows-step4)
+ [

## Étape 5 (facultative) : créer un cluster Amazon ECS
](#tutorial-gmsa-windows-step5)
+ [

## Étape 6 : créer un rôle IAM pour les instances de conteneur
](#tutorial-gmsa-windows-step6)
+ [

## Étape 7 : créer un rôle d'exécution de tâche personnalisé
](#tutorial-gmsa-windows-step7)
+ [

## Étape 8 : créer un rôle de tâche pour Amazon ECS Exec
](#tutorial-gmsa-windows-step8)
+ [

## Étape 9 : enregistrer une définition de tâche qui utilise gMSA sans domaine
](#tutorial-gmsa-windows-step9)
+ [

## Étape 10 : enregistrer une instance de conteneur Windows dans le cluster
](#tutorial-gmsa-windows-step10)
+ [

## Étape 11 : vérifier l'instance de conteneur
](#tutorial-gmsa-windows-step11)
+ [

## Étape 12 : exécuter une tâche Windows
](#tutorial-gmsa-windows-step12)
+ [

## Étape 13 : vérifier que le conteneur possède les informations d'identification gMSA
](#tutorial-gmsa-windows-step13)
+ [

## Étape 14 : nettoyer
](#tutorial-gmsa-windows-step14)
+ [

## Débogage des gMSA Amazon ECS sans domaine pour les conteneurs Windows
](#tutorial-gmsa-windows-debugging)

## Conditions préalables
<a name="tutorial-gmsa-windows-prerequisites"></a>

Le didacticiel suppose de remplir les prérequis suivants :
+ Vous devez avoir suivi les étapes de [Configurer l'utilisation d'Amazon ECS](get-set-up-for-amazon-ecs.md).
+ Votre utilisateur IAM dispose des autorisations requises spécifiées dans l’exemple de politique IAM [Amazon ECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess).
+  La dernière version du AWS CLI est installée et configurée. Pour plus d'informations sur l'installation ou la mise à niveau [de](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) votre AWS CLI AWS Command Line Interface.
**Note**  
Vous pouvez utiliser des points de terminaison de service à double pile pour interagir avec Amazon ECS à partir de AWS CLI SDKs, et de l'API Amazon ECS via les deux IPv4 et. IPv6 Pour de plus amples informations, veuillez consulter [Utilisation des points de terminaison à double pile Amazon ECS](dual-stack-endpoint.md).
+ Vous configurez un domaine Active Directory avec les ressources auxquelles vous souhaitez que vos conteneurs accèdent. Amazon ECS prend en charge les configurations suivantes :
  + Un Directory Service Active Directory. Directory Service est un Active Directory AWS géré hébergé sur Amazon EC2. Pour plus d'informations, consultez [Getting Started with AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) dans le *Guide d'AWS Directory Service administration*.
  + Un répertoire Active Directory sur site. Vous devez vous assurer que l'instance de conteneur Linux Amazon ECS peut se joindre au domaine. Pour de plus amples informations, veuillez consulter [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect-network-to-amazon.html).
+ Vous disposez d'un VPC et de sous-réseaux capables de résoudre le nom de domaine Active Directory.
+ Vous avez choisi entre les **gMSA sans domaine** et **joindre chaque instance à un seul domaine**. En utilisant les gMSA sans domaine, l'instance de conteneur n'est pas jointe au domaine, les autres applications de l'instance ne peuvent pas utiliser les informations d'identification pour accéder au domaine et les tâches qui joignent différents domaines peuvent s'exécuter sur la même instance.

  Choisissez ensuite le stockage de données pour CredSpec et, éventuellement, pour les informations d'identification utilisateur Active Directory pour les gMSA sans domaine.

  Amazon ECS utilise un fichier de spécification des informations d'identification Active Directory (CredSpec). Ce fichier contient les métadonnées gMSA servant à propager le contexte du compte gMSA au conteneur. Vous générez le fichier CredSpec, puis vous le stockez dans l'une des options de stockage CredSpec du tableau suivant, spécifique au système d'exploitation des instances de conteneur. Pour utiliser la méthode sans domaine, une section facultative du fichier CredSpec peut spécifier les informations d'identification dans l'une des options de stockage *domainless user credentials* du tableau suivant, spécifiques au système d'exploitation des instances de conteneur.    
<a name="gmsa-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonECS/latest/developerguide/tutorial-gmsa-windows.html)
+ (Facultatif) AWS CloudShell est un outil qui fournit aux clients une ligne de commande sans avoir à créer leur propre instance EC2. Pour plus d'informations, voir [Qu'est-ce que c'est AWS CloudShell ?](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) dans le *guide de AWS CloudShell l'utilisateur*.

## Étape 1 : créer et configurer le compte gMSA sur les services de domaine Active Directory (AD DS)
<a name="tutorial-gmsa-windows-step1"></a>

Créez et configurez un compte gMSA sur le domaine Active Directory.

**Note**  
Cette étape crée deux comptes distincts : un compte de service géré de groupe (gMSA) qui fournit l’identité de vos conteneurs, et un compte utilisateur normal utilisé pour l’authentification de domaine. Ces comptes ont des objectifs différents et doivent porter des noms différents.

1. 

**Génération d'une clé racine du service de diffusion de clés**
**Note**  
Si vous utilisez Directory Service, vous pouvez ignorer cette étape.

   La clé racine KDS et les autorisations gMSA sont configurées avec votre AD Microsoft géré par AWS .

   Si vous n'avez pas encore créé de compte de service gMSA dans votre domaine, vous devez d'abord générer une clé racine du service de diffusion de clés (KDS). Le KDS est responsable de la création, de la rotation et de la diffusion du mot de passe gMSA aux hôtes autorisés. Lorsque `ccg.exe` a besoin de récupérer les informations d'identification gMSA, il contacte KDS pour récupérer le mot de passe actuel.

   Pour vérifier si la clé racine KDS a déjà été créée, exécutez l' PowerShellapplet de commande suivante avec les privilèges d'administrateur de domaine sur un contrôleur de domaine à l'aide du module. `ActiveDirectory` PowerShell Pour plus d'informations sur le module, voir [ActiveDirectory Module](https://learn.microsoft.com/en-us/powershell/module/activedirectory/?view=windowsserver2022-ps) sur le site Web de Microsoft Learn.

   ```
   PS C:\> Get-KdsRootKey
   ```

   Si la commande renvoie un ID de clé, vous pouvez ignorer le reste de cette étape. Dans le cas contraire, créez la clé racine KDS en exécutant la commande suivante :

   ```
   PS C:\> Add-KdsRootKey -EffectiveImmediately
   ```

   Bien que l'argument `EffectiveImmediately` de la commande implique que la clé est effective immédiatement, vous devez attendre 10 heures avant que la clé racine KDS soit répliquée et puisse être utilisée sur tous les contrôleurs de domaine.

1. 

**Création du compte gMSA**

   Pour créer le gMSA compte et autoriser le `ccg.exe` à récupérer le gMSA mot de passe, exécutez les PowerShell commandes suivantes depuis un serveur ou un client Windows ayant accès au domaine. Remplacez `ExampleAccount` par le nom que vous souhaitez pour votre compte gMSA et remplacez `example-domain` par votre nom de domaine Active Directory (par exemple, si votre domaine est `contoso.com`, utilisez `contoso`).

   1. 

      ```
      PS C:\> Install-WindowsFeature RSAT-AD-PowerShell
      ```

   1. 

      ```
      PS C:\> New-ADGroup -Name "ExampleAccount Authorized Hosts" -SamAccountName "ExampleAccountHosts" -GroupScope DomainLocal
      ```

   1. 

      ```
      PS C:\> New-ADServiceAccount -Name "ExampleAccount" -DnsHostName "example-domain" -ServicePrincipalNames "host/ExampleAccount", "host/example-domain" -PrincipalsAllowedToRetrieveManagedPassword "ExampleAccountHosts"
      ```

   1. Créez un utilisateur avec un mot de passe permanent qui n'expire pas. Ces informations d'identification sont stockées AWS Secrets Manager et utilisées par chaque tâche pour rejoindre le domaine. Il s’agit d’un compte utilisateur distinct du compte gMSA créé ci-dessus. Remplacez `ExampleServiceUser` par le nom que vous souhaitez pour ce compte utilisateur de service.

      ```
      PS C:\> New-ADUser -Name "ExampleServiceUser" -AccountPassword (ConvertTo-SecureString -AsPlainText "Test123" -Force) -Enabled 1 -PasswordNeverExpires 1
      ```

   1. 

      ```
      PS C:\> Add-ADGroupMember -Identity "ExampleAccountHosts" -Members "ExampleServiceUser"
      ```

   1. Installez le PowerShell module de création d'CredSpecobjets dans Active Directory et générez le CredSpec JSON.

      ```
      PS C:\> Install-PackageProvider -Name NuGet -Force
      ```

      ```
      PS C:\> Install-Module CredentialSpec
      ```

   1. 

      ```
      PS C:\> New-CredentialSpec -AccountName ExampleAccount
      ```

1. Copiez le résultat JSON de la commande précédente dans un fichier appelé `gmsa-cred-spec.json`. Il s'agit du fichier CredSpec. Il est utilisé à l'étape 3, [Étape 3 : modifier votre JSON CredSpec pour inclure des informations gMSA sans domaine](#tutorial-gmsa-windows-step3).

## Étape 2 : charger les informations d'identification dans Secrets Manager
<a name="tutorial-gmsa-windows-step2"></a>

Copiez les informations d'identification Active Directory dans un système de stockage d'informations d'identification sécurisé, afin que chaque tâche les récupère. Il s'agit de la méthode gMSA sans domaine. En utilisant les gMSA sans domaine, l'instance de conteneur n'est pas jointe au domaine, les autres applications de l'instance ne peuvent pas utiliser les informations d'identification pour accéder au domaine et les tâches qui joignent différents domaines peuvent s'exécuter sur la même instance.

Cette étape utilise le AWS CLI. Vous pouvez exécuter ces commandes dans AWS CloudShell dans le shell par défaut, qui est `bash`.
+ Exécutez la AWS CLI commande suivante et remplacez le nom d'utilisateur, le mot de passe et le nom de domaine en fonction de votre environnement. Utilisez le nom du compte utilisateur du service (et non le nom du compte gMSA) comme nom d’utilisateur. Conservez l'ARN du secret pour l'utiliser à l'étape suivante, [Étape 3 : modifier votre JSON CredSpec pour inclure des informations gMSA sans domaine](#tutorial-gmsa-windows-step3).

  La commande suivante utilise des barres obliques inverses qui sont utilisées par `sh` et les shells compatibles. Cette commande n'est pas compatible avec PowerShell. Vous devez modifier la commande pour l'utiliser avec PowerShell.

  ```
  $ aws secretsmanager create-secret \
  --name gmsa-plugin-input \
  --description "Amazon ECS - gMSA Portable Identity." \
  --secret-string "{\"username\":\"ExampleServiceUser\",\"password\":\"Test123\",\"domainName\":\"contoso.com\"}"
  ```

## Étape 3 : modifier votre JSON CredSpec pour inclure des informations gMSA sans domaine
<a name="tutorial-gmsa-windows-step3"></a>

Avant de charger le CredSpec vers l'une des options de stockage, ajoutez des informations au CredSpec à l'aide de l'ARN du secret dans Secrets Manager provenant de l'étape précédente. Pour plus d'informations, consultez la section [Configuration des spécifications d'identification supplémentaires pour le cas d'utilisation d' non-domain-joinedun hôte de conteneur sur le site](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#additional-credential-spec-configuration-for-non-domain-joined-container-host-use-case) Web de Microsoft Learn.

1. Ajoutez les informations suivantes au fichier CredSpec contenu dans le `ActiveDirectoryConfig`. Remplacez l'ARN par le secret de l'étape précédente dans Secrets Manager.

   Veuillez noter que la valeur `PluginGUID` doit correspondre au GUID de l'extrait de code suivant et qu'elle est obligatoire.

   ```
   "HostAccountConfig": {
         "PortableCcgVersion": "1",
         "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
         "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
   ```

   Vous pouvez également utiliser un secret dans SSM Parameter Store en utilisant l'ARN au format suivant : `\"arn:aws:ssm:aws-region:111122223333:parameter/gmsa-plugin-input\"`.

1. Une fois le fichier CredSpec modifié, il doit ressembler à l'exemple suivant :

   ```
   {
     "CmsPlugins": [
       "ActiveDirectory"
     ],
     "DomainJoinConfig": {
       "Sid": "S-1-5-21-4066351383-705263209-1606769140",
       "MachineAccountName": "ExampleAccount",
       "Guid": "ac822f13-583e-49f7-aa7b-284f9a8c97b6",
       "DnsTreeName": "example-domain",
       "DnsName": "example-domain",
       "NetBiosName": "example-domain"
     },
     "ActiveDirectoryConfig": {
       "GroupManagedServiceAccounts": [
         {
           "Name": "ExampleAccount",
           "Scope": "example-domain"
         },
         {
           "Name": "ExampleAccount",
           "Scope": "example-domain"
         }
       ],
       "HostAccountConfig": {
         "PortableCcgVersion": "1",
         "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
         "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
     }
   }
   ```

## Étape 4 : charger CredSpec dans Amazon S3
<a name="tutorial-gmsa-windows-step4"></a>



Cette étape utilise le AWS CLI. Vous pouvez exécuter ces commandes dans AWS CloudShell dans le shell par défaut, qui est `bash`.

1. Copiez le fichier CredSpec sur l'ordinateur ou l'environnement dans lequel vous exécutez les commandes AWS CLI .

1. Exécutez la AWS CLI commande suivante pour le CredSpec télécharger sur Amazon S3. Remplacez `MyBucket` par le nom de votre compartiment Simple Storage Service (Amazon S3). Vous pouvez stocker le fichier sous forme d'objet dans n'importe quel compartiment et à n'importe quel emplacement, mais vous devez autoriser l'accès à ce compartiment et à cet emplacement dans la stratégie que vous associez au rôle d'exécution des tâches.

   La commande suivante utilise des barres obliques inverses qui sont utilisées par `sh` et les shells compatibles. Cette commande n'est pas compatible avec PowerShell. Vous devez modifier la commande pour l'utiliser avec PowerShell.

   ```
   $ aws s3 cp gmsa-cred-spec.json \
   s3://MyBucket/ecs-domainless-gmsa-credspec
   ```

## Étape 5 (facultative) : créer un cluster Amazon ECS
<a name="tutorial-gmsa-windows-step5"></a>

Par défaut, votre compte possède un cluster Amazon ECS nommé `default`. Ce cluster est utilisé par défaut dans CloudFormation les AWS CLI SDKs Vous pouvez utiliser des clusters supplémentaires pour regrouper et organiser les tâches et l'infrastructure, et attribuer des valeurs par défaut pour certaines configurations.

Vous pouvez créer un cluster à partir du AWS Management Console AWS CLI, SDKs, ou CloudFormation. Les paramètres et la configuration du cluster n'ont aucune incidence sur gMSA.

Cette étape utilise le AWS CLI. Vous pouvez exécuter ces commandes dans AWS CloudShell dans le shell par défaut, qui est `bash`.

```
$ aws ecs create-cluster --cluster-name windows-domainless-gmsa-cluster
```

**Important**  
Si vous choisissez de créer votre propre cluster, vous devez spécifier `--cluster clusterName` pour chaque commande que vous prévoyez d'utiliser avec ce cluster.

## Étape 6 : créer un rôle IAM pour les instances de conteneur
<a name="tutorial-gmsa-windows-step6"></a>

Une *instance de conteneur* est un ordinateur hôte permettant d'exécuter des conteneurs dans des tâches ECS, par exemple des instances Amazon EC2. Chaque instance de conteneur s'enregistre dans un cluster Amazon ECS. Avant de pouvoir lancer des instances Amazon EC2 et de les enregistrer dans un cluster, vous devez créer le rôle IAM que vos instances de conteneur utiliseront.

Pour créer le rôle d'instance de conteneur, veuillez consulter [Rôle IAM d'instance de conteneur Amazon ECS](instance_IAM_role.md). Le `ecsInstanceRole` par défaut dispose des autorisations suffisantes pour terminer ce didacticiel.

## Étape 7 : créer un rôle d'exécution de tâche personnalisé
<a name="tutorial-gmsa-windows-step7"></a>

Amazon ECS peut utiliser un rôle IAM différent pour les autorisations nécessaires au démarrage de chaque tâche, au lieu du rôle d'instance de conteneur. Il s'agit du *rôle d'exécution de tâche*. Nous recommandons de créer un rôle d'exécution de tâche avec uniquement les autorisations requises pour qu'ECS exécute la tâche, également appelées *autorisations de moindre privilège*. Pour plus d'informations sur le principe du moindre privilège, voir [SEC03- BP02 Accorder l'accès au moindre privilège](https://docs.aws.amazon.com/wellarchitected/latest/framework/sec_permissions_least_privileges.html) dans le *AWS Well-Architected Framework*.

1. Pour créer un rôle d'exécution de tâche, veuillez consulter [Création du rôle d'exécution de tâche](task_execution_IAM_role.md#create-task-execution-role). Les autorisations par défaut permettent à l'instance de conteneur d'extraire des images de conteneur d'Amazon Elastic Container Registry `stdout` et `stderr` de vos applications pour les connecter à Amazon CloudWatch Logs.

   Comme le rôle nécessite des autorisations personnalisées pour ce didacticiel, vous pouvez lui donner un nom différent de `ecsTaskExecutionRole`. Ce didacticiel utilise `ecsTaskExecutionRole` dans les étapes suivantes.

1. Ajoutez les autorisations suivantes en créant une stratégie personnalisée, soit une stratégie en ligne qui n'existe que pour ce rôle, soit une stratégie que vous pouvez réutiliser. Remplacez l'ARN de la `Resource` dans la première instruction par le compartiment et l'emplacement Amazon S3, et la seconde `Resource` par l'ARN du secret dans Secrets Manager.

   Si vous chiffrez le secret dans Secrets Manager avec une clé personnalisée, vous devez également autoriser `kms:Decrypt` pour la clé.

   Si vous utilisez SSM Parameter Store au lieu de Secrets Manager, vous devez autoriser `ssm:GetParameter` pour le paramètre, au lieu de `secretsmanager:GetSecretValue`.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject"
               ],
               "Resource": "arn:aws:s3:::MyBucket/ecs-domainless-gmsa-credspec/gmsa-cred-spec.json"
           },
           {
               "Effect": "Allow",
               "Action": [
                   "secretsmanager:GetSecretValue"
               ],
               "Resource": "arn:aws:secretsmanager:us-east-1:111122223333:secret:gmsa-plugin-AbCdEf"
           }
       ]
   }
   ```

------

## Étape 8 : créer un rôle de tâche pour Amazon ECS Exec
<a name="tutorial-gmsa-windows-step8"></a>

Ce didacticiel utilise Amazon ECS Exec pour vérifier le fonctionnement en exécutant une commande dans une tâche en cours d'exécution. Pour utiliser ECS Exec, le service ou la tâche doit activer ECS Exec, et le rôle de tâche (mais pas le rôle d'exécution de tâche) doit disposer d'autorisations `ssmmessages`. Pour la politique IAM requise, veuillez consulter [Autorisations ECS Exec](task-iam-roles.md#ecs-exec-required-iam-permissions).

Cette étape utilise le AWS CLI. Vous pouvez exécuter ces commandes dans AWS CloudShell dans le shell par défaut, qui est `bash`.

Pour créer un rôle de tâche à l'aide de AWS CLI, procédez comme suit.

1. Créez un fichier nommé `ecs-tasks-trust-policy.json` avec le contenu suivant :

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Principal": {
                   "Service": "ecs-tasks.amazonaws.com"
               },
               "Action": "sts:AssumeRole"
           }
       ]
   }
   ```

------

1. Créez un rôle IAM. Vous pouvez remplacer le nom `ecs-exec-demo-task-role` mais le conserver pour les étapes suivantes.

   La commande suivante utilise des barres obliques inverses qui sont utilisées par `sh` et les shells compatibles. Cette commande n'est pas compatible avec PowerShell. Vous devez modifier la commande pour l'utiliser avec PowerShell.

   ```
   $ aws iam create-role --role-name ecs-exec-demo-task-role \
   --assume-role-policy-document file://ecs-tasks-trust-policy.json
   ```

   Vous pouvez supprimer le fichier `ecs-tasks-trust-policy.json`.

1. Créez un fichier nommé `ecs-exec-demo-task-role-policy.json` avec le contenu suivant :

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "ssmmessages:CreateControlChannel",
                   "ssmmessages:CreateDataChannel",
                   "ssmmessages:OpenControlChannel",
                   "ssmmessages:OpenDataChannel"
               ],
               "Resource": "*"
           }
       ]
   }
   ```

------

1. Créez une politique IAM et attachez-la au rôle de l'étape précédente.

   La commande suivante utilise des barres obliques inverses qui sont utilisées par `sh` et les shells compatibles. Cette commande n'est pas compatible avec PowerShell. Vous devez modifier la commande pour l'utiliser avec PowerShell.

   ```
   $ aws iam put-role-policy \
       --role-name ecs-exec-demo-task-role \
       --policy-name ecs-exec-demo-task-role-policy \
       --policy-document file://ecs-exec-demo-task-role-policy.json
   ```

   Vous pouvez supprimer le fichier `ecs-exec-demo-task-role-policy.json`.

## Étape 9 : enregistrer une définition de tâche qui utilise gMSA sans domaine
<a name="tutorial-gmsa-windows-step9"></a>



Cette étape utilise le AWS CLI. Vous pouvez exécuter ces commandes dans AWS CloudShell dans le shell par défaut, qui est `bash`.

1. Créez un fichier nommé `windows-gmsa-domainless-task-def.json` avec le contenu suivant :

   ```
   {
     "family": "windows-gmsa-domainless-task",
     "containerDefinitions": [
       {
         "name": "windows_sample_app",
         "image": "mcr.microsoft.com/windows/servercore/iis",
         "cpu": 1024,
         "memory": 1024,
         "essential": true,
         "credentialSpecs": [
                   "credentialspecdomainless:arn:aws:s3:::ecs-domainless-gmsa-credspec/gmsa-cred-spec.json"
         ],
         "entryPoint": [
           "powershell",
           "-Command"
         ],
         "command": [
           "New-Item -Path C:\\inetpub\\wwwroot\\index.html -ItemType file -Value '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p>' -Force ; C:\\ServiceMonitor.exe w3svc"
         ],
         "portMappings": [
           {
             "protocol": "tcp",
             "containerPort": 80,
             "hostPort": 8080
           }
         ]
       }
     ],
     "taskRoleArn": "arn:aws:iam::111122223333:role/ecs-exec-demo-task-role",
     "executionRoleArn": "arn:aws:iam::111122223333:role/ecsTaskExecutionRole"
   }
   ```

1. Enregistrez la définition de tâche en exécutant la commande suivante :

   La commande suivante utilise des barres obliques inverses qui sont utilisées par `sh` et les shells compatibles. Cette commande n'est pas compatible avec PowerShell. Vous devez modifier la commande pour l'utiliser avec PowerShell.

   ```
   $ aws ecs register-task-definition \
   --cli-input-json file://windows-gmsa-domainless-task-def.json
   ```

## Étape 10 : enregistrer une instance de conteneur Windows dans le cluster
<a name="tutorial-gmsa-windows-step10"></a>

Lancez une instance Windows Amazon EC2 et exécutez l'agent de conteneur ECS pour l'enregistrer en tant qu'instance de conteneur dans le cluster. ECS exécute des tâches sur les instances de conteneur enregistrées dans le cluster dans lequel les tâches sont démarrées.

1. Pour lancer une instance Windows Amazon EC2 configurée pour Amazon ECS dans le AWS Management Console, consultez. [Lancement d'une instance de conteneur Amazon ECS Windows](launch_window-container_instance.md) Arrêtez-vous à l'étape des *données utilisateur*.

1. Pour gMSA, les données utilisateur doivent définir la variable d'environnement `ECS_GMSA_SUPPORTED` avant de démarrer l'agent de conteneur ECS.

   Pour ECS Exec, l'agent doit commencer par l'argument `-EnableTaskIAMRole`.

   Pour sécuriser le rôle IAM de l'instance en empêchant les tâches d'atteindre le service Web EC2 IMDS pour récupérer les informations d'identification du rôle, ajoutez l'argument `-AwsvpcBlockIMDS`. Cela s'applique uniquement aux tâches qui utilisent le mode réseau `awsvpc`.

   ```
   <powershell>
   [Environment]::SetEnvironmentVariable("ECS_GMSA_SUPPORTED", $TRUE, "Machine")
   Import-Module ECSTools
   Initialize-ECSAgent -Cluster windows-domainless-gmsa-cluster -EnableTaskIAMRole -AwsvpcBlockIMDS
   </powershell>
   ```

1. Consultez un résumé de la configuration de votre instance dans le panneau **Summary** (Récapitulatif) et, lorsque vous êtes prêt, choisissez **Launch instance** (Lancer l’instance).

## Étape 11 : vérifier l'instance de conteneur
<a name="tutorial-gmsa-windows-step11"></a>

Vous pouvez vérifier qu'il existe une instance de conteneur dans le cluster à l'aide de l' AWS Management Console. Cependant, gMSA nécessite des fonctionnalités supplémentaires indiquées sous forme d'*attributs*. Ces attributs ne sont pas visibles dans le AWS Management Console. Ce didacticiel utilise donc le AWS CLI.

Cette étape utilise le AWS CLI. Vous pouvez exécuter ces commandes dans AWS CloudShell dans le shell par défaut, qui est `bash`.

1. Répertoriez les instances de conteneur dans le cluster. Les instances de conteneur ont un ID différent de celui de l'instance EC2.

   ```
   $ aws ecs list-container-instances
   ```

   Sortie :

   ```
   {
       "containerInstanceArns": [
           "arn:aws:ecs:aws-region:111122223333:container-instance/default/MyContainerInstanceID"
       ]
   }
   ```

   Par exemple, `526bd5d0ced448a788768334e79010fd` est un ID d'instance de conteneur valide.

1. Utilisez l'ID d'instance de conteneur indiqué à l'étape précédente pour obtenir les détails de l'instance de conteneur. Remplacez `MyContainerInstanceID` par l'ID.

   La commande suivante utilise des barres obliques inverses qui sont utilisées par `sh` et les shells compatibles. Cette commande n'est pas compatible avec PowerShell. Vous devez modifier la commande pour l'utiliser avec PowerShell.

   ```
   $ aws ecs describe-container-instances \
        ----container-instances MyContainerInstanceID
   ```

   Veuillez noter que la sortie est très longue.

1. Vérifiez que la liste `attributes` contient un objet avec la clé appelée `name` et une valeur `ecs.capability.gmsa-domainless`. Voici un exemple de l'objet.

   Sortie :

   ```
   {
       "name": "ecs.capability.gmsa-domainless"
   }
   ```

## Étape 12 : exécuter une tâche Windows
<a name="tutorial-gmsa-windows-step12"></a>

Exécutez une tâche Amazon ECS. S'il n'y a qu'une seule instance de conteneur dans le cluster, vous pouvez utiliser `run-task`. S'il existe de nombreuses instances de conteneur différentes, il peut être plus facile d'utiliser `start-task` et de spécifier l'ID d'instance de conteneur sur lequel exécuter la tâche, plutôt que d'ajouter des contraintes de placement à la définition de la tâche pour contrôler le type d'instance de conteneur sur lequel exécuter cette tâche.

Cette étape utilise le AWS CLI. Vous pouvez exécuter ces commandes dans AWS CloudShell dans le shell par défaut, qui est `bash`.

1. 

   La commande suivante utilise des barres obliques inverses qui sont utilisées par `sh` et les shells compatibles. Cette commande n'est pas compatible avec PowerShell. Vous devez modifier la commande pour l'utiliser avec PowerShell.

   ```
   aws ecs run-task --task-definition windows-gmsa-domainless-task \
       --enable-execute-command --cluster windows-domainless-gmsa-cluster
   ```

   Notez l'ID de tâche qui est renvoyé par la commande.

1. Exécutez la commande suivante pour vérifier que la tâche a démarré. Cette commande attend et ne renvoie pas l'invite du shell tant que la tâche ne démarre pas. Remplacez `MyTaskID` par l'ID de tâche de l'étape précédente.

   ```
   $ aws ecs wait tasks-running --task MyTaskID
   ```

## Étape 13 : vérifier que le conteneur possède les informations d'identification gMSA
<a name="tutorial-gmsa-windows-step13"></a>

Vérifiez que le conteneur de la tâche possède un jeton Kerberos. gMSA 

Cette étape utilise le AWS CLI. Vous pouvez exécuter ces commandes dans AWS CloudShell dans le shell par défaut, qui est `bash`.

1. 

   La commande suivante utilise des barres obliques inverses qui sont utilisées par `sh` et les shells compatibles. Cette commande n'est pas compatible avec PowerShell. Vous devez modifier la commande pour l'utiliser avec PowerShell.

   ```
   $ aws ecs execute-command \
   --task MyTaskID \
   --container windows_sample_app \
   --interactive \
   --command powershell.exe
   ```

   Le résultat sera une PowerShell invite.

1. Exécutez la commande suivante dans le PowerShell terminal à l'intérieur du conteneur.

   ```
   PS C:\> klist get ExampleAccount$
   ```

   Dans la sortie, notez que le `Principal` est celui que vous avez créé précédemment.

## Étape 14 : nettoyer
<a name="tutorial-gmsa-windows-step14"></a>

Une fois que vous avez terminé ce didacticiel, vous devez nettoyer les ressources qui lui sont associées afin d'éviter la facturation de frais pour des ressources inutilisées.

Cette étape utilise le AWS CLI. Vous pouvez exécuter ces commandes dans AWS CloudShell dans le shell par défaut, qui est `bash`.

1. Arrêtez la tâche. Remplacez `MyTaskID` par l'ID de tâche de l'étape 12, [Étape 12 : exécuter une tâche Windows](#tutorial-gmsa-windows-step12).

   ```
   $ aws ecs stop-task --task MyTaskID
   ```

1. Résiliez l'instance Amazon EC2. Ensuite, l'instance de conteneur du cluster sera automatiquement supprimée au bout d'une heure.

   Vous pouvez détecter et résilier l'instance à l'aide de la console Amazon EC2. Vous pouvez également exécuter la commande suivante. Pour exécuter la commande, recherchez l'ID d'instance EC2 dans le résultat de la commande `aws ecs describe-container-instances` de l'étape 1, [Étape 11 : vérifier l'instance de conteneur](#tutorial-gmsa-windows-step11). i-10a64379 est un exemple d'ID d'instance EC2.

   ```
   $ aws ec2 terminate-instances --instance-ids MyInstanceID
   ```

1. Supprimez le fichier CredSpec dans Amazon S3. Remplacez `MyBucket` par le nom de votre compartiment Simple Storage Service (Amazon S3).

   ```
   $ aws s3api delete-object --bucket MyBucket --key ecs-domainless-gmsa-credspec/gmsa-cred-spec.json
   ```

1. Supprimez le secret dans Secrets Manager. Si vous avez plutôt utilisé SSM Parameter Store, supprimez le paramètre.

   La commande suivante utilise des barres obliques inverses qui sont utilisées par `sh` et les shells compatibles. Cette commande n'est pas compatible avec PowerShell. Vous devez modifier la commande pour l'utiliser avec PowerShell.

   ```
   $ aws secretsmanager delete-secret --secret-id gmsa-plugin-input \
        --force-delete-without-recovery
   ```

1. Annulez l'enregistrement et supprimez la définition de tâche. En annulant l'enregistrement de la définition de tâche, vous la marquez comme inactive afin qu'elle ne puisse pas être utilisée pour démarrer de nouvelles tâches. Ensuite, vous pouvez supprimer la définition de tâche.

   1. Annulez l'enregistrement de la définition de tâche en spécifiant la version. ECS crée automatiquement des versions des définitions de tâches, qui sont numérotées à partir de 1. Vous faites référence aux versions dans le même format que les étiquettes sur les images des conteneurs, telles que `:1`.

      ```
      $ aws ecs deregister-task-definition --task-definition windows-gmsa-domainless-task:1
      ```

   1. Supprimez la définition de tâche.

      ```
      $ aws ecs delete-task-definitions --task-definition windows-gmsa-domainless-task:1
      ```

1. (Facultatif) Supprimez le cluster ECS, si vous en avez créé un.

   ```
   $ aws ecs delete-cluster --cluster windows-domainless-gmsa-cluster
   ```

## Débogage des gMSA Amazon ECS sans domaine pour les conteneurs Windows
<a name="tutorial-gmsa-windows-debugging"></a>



Statut de tâche Amazon ECS  
ECS essaie de démarrer une tâche une seule fois. Toute tâche présentant un problème est arrêtée et définie sur le statut `STOPPED`. Il existe deux types courants de problèmes liés aux tâches. Premièrement, les tâches qui n'ont pas pu être démarrées. Deuxièmement, les tâches pour lesquelles l'application s'est arrêtée dans l'un des conteneurs. Dans le AWS Management Console champ **Motif de l'arrêt** de la tâche, recherchez la raison pour laquelle la tâche a été arrêtée. Dans l' AWS CLI, décrivez la tâche et examinez la `stoppedReason`. Pour les étapes à suivre dans AWS Management Console le AWS CLI sable, voir[Affichage des erreurs liées aux tâches Amazon ECS arrêtées](stopped-task-errors.md).

Événements Windows  
Les événements Windows pour gMSA dans les conteneurs sont enregistrés dans le fichier journal `Microsoft-Windows-Containers-CCG` et se trouvent dans l'Observateur d'événements, dans la section Applications et services de `Logs\Microsoft\Windows\Containers-CCG\Admin`. Pour obtenir d'autres conseils de débogage, consultez la section [Résoudre les problèmes liés aux conteneurs g MSAs pour Windows](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/gmsa-troubleshooting#non-domain-joined-container-hosts-use-event-logs-to-identify-configuration-issues) sur le site Web de Microsoft Learn.

Plug-in gMSA d'agent ECS  
La journalisation du plug-in gMSA pour l'agent ECS sur l'instance de conteneur Windows se trouve dans le répertoire suivant, `C:/ProgramData/Amazon/gmsa-plugin/`. Consultez ce journal pour voir si les informations d'identification de l'utilisateur sans domaine ont été téléchargées depuis l'emplacement de stockage, tel que Secrets Manager, et si le format des informations d'identification a été lu correctement.

# Utilisation des gMSA pour les conteneurs Windows EC2 pour Amazon ECS
<a name="windows-gmsa"></a>

Amazon ECS prend en charge l'authentification Active Directory pour les conteneurs Windows par l'intermédiaire d'un type de compte de service spécial appelé *gMSA (group Managed Service Account)*.

Les applications réseau Windows comme les applications .NET font souvent appel à Active Directory pour faciliter la gestion de l'authentification et des autorisations entre les utilisateurs et les services. Les développeurs conçoivent généralement leurs applications de façon qu'elles s'intègrent à Active Directory et s'exécutent à cette fin sur des serveurs joints à un domaine. Étant donné que les conteneurs Windows ne peuvent pas être joints à un domaine, vous devez configurer un conteneur Windows pour qu'il s'exécute avec un compte gMSA.

Un conteneur Windows s'exécutant avec un compte gMSA attend de son instance Amazon EC2 hôte qu'elle récupère les informations d'identification gMSA auprès du contrôleur de domaine Active Directory et qu'elle les communique à l'instance de conteneur. Pour plus d'informations, voir [Create g MSAs pour les conteneurs Windows](https://docs.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts).

**Note**  
Cette fonction n'est pas prise en charge par les conteneurs Windows sur Fargate.

**Topics**
+ [

## Considérations
](#windows-gmsa-considerations)
+ [

## Conditions préalables
](#windows-gmsa-prerequisites)
+ [

## Configuration de gMSA pour des conteneurs Windows sur Amazon ECS
](#windows-gmsa-setup)

## Considérations
<a name="windows-gmsa-considerations"></a>

Les points suivants doivent être pris en compte lors de l'utilisation de g MSAs pour les conteneurs Windows :
+ Lorsque vous utilisez l'AMI Windows Server 2016 Full optimisée pour Amazon ECS pour vos instances de conteneur, le nom d'hôte du conteneur doit être le même que le nom de compte gMSA défini dans le fichier de spécification des informations d'identification. Pour spécifier le nom d'hôte d'un conteneur, utilisez le paramètre de définition de conteneur `hostname`. Pour de plus amples informations, veuillez consulter [Paramètres réseau](task_definition_parameters.md#container_definition_network).
+ Vous avez choisi entre les **gMSA sans domaine** et **joindre chaque instance à un seul domaine**. En utilisant les gMSA sans domaine, l'instance de conteneur n'est pas jointe au domaine, les autres applications de l'instance ne peuvent pas utiliser les informations d'identification pour accéder au domaine et les tâches qui joignent différents domaines peuvent s'exécuter sur la même instance.

  Choisissez ensuite le stockage de données pour CredSpec et, éventuellement, pour les informations d'identification utilisateur Active Directory pour les gMSA sans domaine.

  Amazon ECS utilise un fichier de spécification des informations d'identification Active Directory (CredSpec). Ce fichier contient les métadonnées gMSA servant à propager le contexte du compte gMSA au conteneur. Vous générez le fichier CredSpec, puis vous le stockez dans l'une des options de stockage CredSpec du tableau suivant, spécifique au système d'exploitation des instances de conteneur. Pour utiliser la méthode sans domaine, une section facultative du fichier CredSpec peut spécifier les informations d'identification dans l'une des options de stockage *domainless user credentials* du tableau suivant, spécifiques au système d'exploitation des instances de conteneur.    
<a name="gmsa-table"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/AmazonECS/latest/developerguide/windows-gmsa.html)

## Conditions préalables
<a name="windows-gmsa-prerequisites"></a>

Avant d'utiliser la fonctionnalité gMSA pour les conteneurs Windows avec Amazon ECS, assurez-vous de remplir les conditions suivantes :
+ Vous configurez un domaine Active Directory avec les ressources auxquelles vous souhaitez que vos conteneurs accèdent. Amazon ECS prend en charge les configurations suivantes :
  + Un Directory Service Active Directory. Directory Service est un Active Directory AWS géré hébergé sur Amazon EC2. Pour plus d'informations, consultez [Getting Started with AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started.html) dans le *Guide d'AWS Directory Service administration*.
  + Un répertoire Active Directory sur site. Vous devez vous assurer que l'instance de conteneur Linux Amazon ECS peut se joindre au domaine. Pour de plus amples informations, veuillez consulter [AWS Direct Connect](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/aws-direct-connect-network-to-amazon.html).
+ Vous disposez d'un compte gMSA existant dans l'Active Directory. Pour plus d'informations, voir [Create g MSAs pour les conteneurs Windows](https://docs.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts).
+ **Vous avez choisi d'utiliser *gMSA sans domaine* ou l'instance de conteneur Amazon ECS Windows hébergeant la tâche Amazon ECS doit être *jointe au domaine* du répertoire Active Directory et être membre du groupe de sécurité Active Directory qui a accès au compte gMSA.**

  En utilisant les gMSA sans domaine, l'instance de conteneur n'est pas jointe au domaine, les autres applications de l'instance ne peuvent pas utiliser les informations d'identification pour accéder au domaine et les tâches qui joignent différents domaines peuvent s'exécuter sur la même instance.
+ Vous avez ajouté les autorisations IAM requises. Les autorisations requises dépendent des méthodes que vous choisissez pour les informations d'identification initiales et pour le stockage de la spécification des informations d'identification :
  + Si vous utilisez *domainless gMSA* pour les informations d'identification initiales, les autorisations IAM pour AWS Secrets Manager sont requises sur le rôle d'instance Amazon EC2.
  + Si vous stockez la spécification des informations d'identification dans SSM Parameter Store, les autorisations IAM d'Amazon EC2 Systems Manager Parameter Store sont requises pour le rôle d'exécution de la tâche.
  + Si vous stockez la spécification des informations d'identification dans Amazon S3, les autorisations IAM d'Amazon Simple Storage Service sont requises sur le rôle d'exécution de la tâche.

## Configuration de gMSA pour des conteneurs Windows sur Amazon ECS
<a name="windows-gmsa-setup"></a>

Pour configurer gMSA pour les conteneurs Windows sur Amazon ECS, vous pouvez suivre le didacticiel complet qui inclut la configuration des prérequis [Utilisation de conteneurs Windows Amazon ECS avec des conteneurs sans domaine à gMSA l'aide du AWS CLI](tutorial-gmsa-windows.md).

Les sections suivantes décrivent la configuration de CredSpec en détail.

**Topics**
+ [

### CredSpec exemple
](#windows-gmsa-example)
+ [

### Configuration de gMSA sans domaine
](#windows-gmsa-domainless)
+ [

### Référencement d'un fichier de spécification d'informations d'identification dans une définition de tâche
](#windows-gmsa-credentialspec)

### CredSpec exemple
<a name="windows-gmsa-example"></a>

Amazon ECS utilise un fichier de spécification d'informations d'identification qui contient les métadonnées gMSA servant à propager le contexte du compte gMSA au conteneur Windows. Vous pouvez générer le fichier de spécification d'informations d'identification et le référencer dans le champ `credentialSpec` de votre définition de tâche. Le fichier de spécification d'informations d'identification ne contient pas de secrets.

Voici un exemple de fichier de spécification d'informations d'identification :

```
{
    "CmsPlugins": [
        "ActiveDirectory"
    ],
    "DomainJoinConfig": {
        "Sid": "S-1-5-21-2554468230-2647958158-2204241789",
        "MachineAccountName": "WebApp01",
        "Guid": "8665abd4-e947-4dd0-9a51-f8254943c90b",
        "DnsTreeName": "contoso.com",
        "DnsName": "contoso.com",
        "NetBiosName": "contoso"
    },
    "ActiveDirectoryConfig": {
        "GroupManagedServiceAccounts": [
            {
                "Name": "WebApp01",
                "Scope": "contoso.com"
            }
        ]
    }
}
```

### Configuration de gMSA sans domaine
<a name="windows-gmsa-domainless"></a>

Nous recommandons gMSA sans domaine au lieu de joindre les instances de conteneur à un seul domaine. En utilisant les gMSA sans domaine, l'instance de conteneur n'est pas jointe au domaine, les autres applications de l'instance ne peuvent pas utiliser les informations d'identification pour accéder au domaine et les tâches qui joignent différents domaines peuvent s'exécuter sur la même instance.

1. Avant de charger CredSpec vers l'une des options de stockage, ajoutez des informations au CredSpec à l'aide de l'ARN du secret dans Secrets Manager ou SSM Parameter Store. Pour plus d'informations, consultez la section [Configuration des spécifications d'identification supplémentaires pour le cas d'utilisation d' non-domain-joinedun hôte de conteneur sur le site](https://learn.microsoft.com/en-us/virtualization/windowscontainers/manage-containers/manage-serviceaccounts#additional-credential-spec-configuration-for-non-domain-joined-container-host-use-case) Web de Microsoft Learn.

**Format d'informations d'identification gMSA sans domaine**  
Voici le format JSON pour les informations d'identification gMSA sans domaine pour votre Active Directory. Stockez les informations d'identification dans Secrets Manager ou SSM Parameter Store.

   ```
   {
       "username":"WebApp01",
       "password":"Test123!",
       "domainName":"contoso.com"
   }
   ```

1. Ajoutez les informations suivantes au fichier CredSpec contenu dans le `ActiveDirectoryConfig`. Remplacez l'ARN par le secret dans Secrets Manager ou SSM Parameter Store.

   Veuillez noter que la valeur `PluginGUID` doit correspondre au GUID de l'extrait de code suivant et qu'elle est obligatoire.

   ```
       "HostAccountConfig": {
           "PortableCcgVersion": "1",
           "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
           "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
   ```

   Vous pouvez également utiliser un secret dans SSM Parameter Store en utilisant l'ARN au format suivant : `\"arn:aws:ssm:aws-region:111122223333:parameter/gmsa-plugin-input\"`.

1. Une fois le fichier CredSpec modifié, il doit ressembler à l'exemple suivant :

   ```
   {
     "CmsPlugins": [
       "ActiveDirectory"
     ],
     "DomainJoinConfig": {
       "Sid": "S-1-5-21-4066351383-705263209-1606769140",
       "MachineAccountName": "WebApp01",
       "Guid": "ac822f13-583e-49f7-aa7b-284f9a8c97b6",
       "DnsTreeName": "contoso",
       "DnsName": "contoso",
       "NetBiosName": "contoso"
     },
     "ActiveDirectoryConfig": {
       "GroupManagedServiceAccounts": [
         {
           "Name": "WebApp01",
           "Scope": "contoso"
         },
         {
           "Name": "WebApp01",
           "Scope": "contoso"
         }
       ],
       "HostAccountConfig": {
         "PortableCcgVersion": "1",
         "PluginGUID": "{859E1386-BDB4-49E8-85C7-3070B13920E1}",
         "PluginInput": "{\"credentialArn\": \"arn:aws:secretsmanager:aws-region:111122223333:secret:gmsa-plugin-input\"}"
       }
     }
   }
   ```

### Référencement d'un fichier de spécification d'informations d'identification dans une définition de tâche
<a name="windows-gmsa-credentialspec"></a>

Amazon ECS permet de référencer le chemin du fichier dans le champ `credentialSpecs` d'une définition de tâche. Pour chacune de ces options, vous pouvez fournir `credentialspec:` ou `domainlesscredentialspec:`, selon que vous joignez les instances de conteneur à un seul domaine, ou que vous utilisez gMSA sans domaine, respectivement.

#### Compartiment Amazon S3
<a name="gmsa-credspec-s3"></a>

Ajoutez la spécification d'informations d'identification à un compartiment Amazon S3, puis référencez l'Amazon Resource Name (ARN) du compartiment Amazon S3 dans le champ `credentialSpecs` de la définition de tâche.

```
{
    "family": "",
    "executionRoleArn": "",
    "containerDefinitions": [
        {
            "name": "",
            ...
            "credentialSpecs": [
                "credentialspecdomainless:arn:aws:s3:::${BucketName}/${ObjectName}"
            ],
            ...
        }
    ],
    ...
}
```

Vous devez également ajouter les autorisations suivantes sous forme de stratégie en ligne au rôle IAM d'exécution de tâche Amazon ECS pour permettre à vos tâches d'accéder au compartiment Amazon S3.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Sid": "VisualEditor",
            "Effect": "Allow",
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Resource": [
                "arn:aws:s3:::{bucket_name}",
                "arn:aws:s3:::{bucket_name}/{object}"
            ]
        }
    ]
}
```

------

#### Paramètre SSM Parameter Store
<a name="gmsa-credspec-ssm"></a>

Ajoutez la spécification d'informations d'identification à un compartiment SSM Parameter Store, puis référencez l'Amazon Resource Name (ARN) du paramètre SSM Parameter Store dans le champ `credentialSpecs` de la définition de tâche.

```
{
    "family": "",
    "executionRoleArn": "",
    "containerDefinitions": [
        {
            "name": "",
            ...
            "credentialSpecs": [
                "credentialspecdomainless:arn:aws:ssm:region:111122223333:parameter/parameter_name"
            ],
            ...
        }
    ],
    ...
}
```

Vous devez également ajouter les autorisations suivantes sous forme de stratégie en ligne au rôle IAM d'exécution de tâche Amazon ECS pour permettre à vos tâches d'accéder au paramètre SSM Parameter Store.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ssm:GetParameters"
            ],
            "Resource": "arn:aws:ssm:*:111122223333:parameter/example*"
        }
    ]
}
```

------

#### Fichier local
<a name="gmsa-credspec-file"></a>

Référencez le chemin d'un fichier local qui contient les détails de la spécification d'informations d'identification dans le champ `credentialSpecs` de la définition de tâche. Le chemin de fichier référencé doit être relatif au répertoire `C:\ProgramData\Docker\CredentialSpecs` et utiliser la barre oblique inverse (« \$1 ») comme séparateur de chemin de fichier.

```
{
    "family": "",
    "executionRoleArn": "",
    "containerDefinitions": [
        {
            "name": "",
            ...
            "credentialSpecs": [
                "credentialspec:file://CredentialSpecDir\CredentialSpecFile.json"
            ],
            ...
        }
    ],
    ...
}
```

# Utilisation d'EC2 Image Builder pour créer une solution personnalisée optimisée pour Amazon ECS AMIs
<a name="image-builder-tutorial"></a>

AWS vous recommande d'utiliser les AMI optimisées pour Amazon ECS, car elles sont préconfigurées conformément aux exigences et aux recommandations pour exécuter vos charges de travail de conteneur. Il peut arriver que vous deviez personnaliser votre AMI pour ajouter des logiciels supplémentaires. Vous pouvez utiliser EC2 Image Builder pour la création, la gestion et le déploiement de vos images de serveur. Vous restez propriétaire des images personnalisées créées dans votre compte. Vous pouvez utiliser les pipelines EC2 Image Builder pour automatiser les mises à jour et les correctifs système pour vos images, ou utiliser une commande autonome pour créer une image avec les ressources de configuration que vous avez définies.

Vous créez une recette pour votre image. La recette inclut une image parent et tous les composants supplémentaires. Vous créez également un pipeline qui distribue votre AMI personnalisée.

Vous créez une recette pour votre image. Une recette Image Builder est un document qui définit l’image de base et les composants à appliquer à l’image de base pour produire la configuration souhaitée pour l’image AMI en sortie. Vous créez également un pipeline qui distribue votre AMI personnalisée. Pour plus d’informations, consultez la section [Fonctionnement d’EC2 Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/how-image-builder-works.html) dans le *Guide de l’utilisateur d’EC2 Image Builder*.

Nous vous recommandons d’utiliser l’une des AMI optimisées pour Amazon ECS suivantes comme « image parent » dans EC2 Image Builder :
+ Linux
  + x86 optimisé pour Amazon ECS AL2023 
  + AMI Amazon Linux 2023 (arm64) optimisée pour Amazon ECS
  + AMI Amazon Linux 2 noyau 5 optimisée pour Amazon ECS
  + AMI Amazon Linux 2 x86 optimisée pour Amazon ECS
+ Windows
  + Windows Server 2022 Full x86 optimisée pour Amazon ECS
  + Windows Server 2022 Core x86 optimisée pour Amazon ECS
  + Windows Server 2019 Full x86 optimisée pour Amazon ECS
  + Windows Server 2019 Core x86 optimisée pour Amazon ECS
  + Windows Server 2016 Full x86 optimisée pour Amazon ECS

Nous vous recommandons également de sélectionner « Utiliser la dernière version disponible du système d’exploitation ». Le pipeline utilisera la gestion des versions sémantique pour l’image parent, ce qui permet de détecter les mises à jour des dépendances dans les tâches planifiées automatiquement. Pour plus d’informations, consultez la section [Gestion des versions sémantique](https://docs.aws.amazon.com/imagebuilder/latest/userguide/ibhow-semantic-versioning.html) dans le *Guide de l’utilisateur EC2 Image Builder*.

AWS met régulièrement à jour les images d'AMI optimisées pour Amazon ECS avec des correctifs de sécurité et la nouvelle version de l'agent de conteneur. Lorsque vous utilisez un ID AMI comme image parent dans votre recette d’image, vous devez vérifier régulièrement les mises à jour de l’image parent. S’il y a des mises à jour, vous devez créer une nouvelle version de votre recette avec l’AMI mise à jour. Cela garantit que vos images personnalisées incorporent la dernière version de l’image parent. Pour plus d'informations sur la création d'un flux de travail permettant de mettre automatiquement à jour vos instances EC2 dans votre cluster Amazon ECS avec les instances nouvellement créées AMIs, consultez [Comment créer un pipeline de renforcement des AMI et automatiser les mises à jour de votre parc d'instances ECS](https://aws.amazon.com/blogs/security/how-to-create-an-ami-hardening-pipeline-and-automate-updates-to-your-ecs-instance-fleet/).

Vous pouvez également spécifier le Amazon Resource Name (ARN) d’une image parent publiée via un pipeline EC2 Image Builder géré. Amazon publie régulièrement des images AMI optimisées pour Amazon ECS via des pipelines gérés. Ces images sont publiquement accessibles. Vous devez disposer des autorisations nécessaires pour accéder à l’image. Lorsque vous utilisez un ARN d’image au lieu d’une AMI dans votre recette Image Builder, votre pipeline utilise automatiquement la version la plus récente de l’image parent à chaque exécution. Cette approche élimine le besoin de créer manuellement de nouvelles versions de recettes pour chaque mise à jour. 

## Nettoyage de l’AMI optimisée pour Amazon ECS
<a name="cleanup-ecs-optimized-ami"></a>

Lorsque vous utilisez une AMI optimisée pour Amazon ECS comme image parent, vous devez nettoyer l’image pour éviter les problèmes transitoires. L’AMI optimisée pour Amazon ECS est préconfigurée pour que l’agent Amazon ECS démarre automatiquement et s’enregistre en tant qu’instance de conteneur auprès d’Amazon ECS. Son utilisation comme image de base sans nettoyage approprié peut entraîner des problèmes dans votre AMI personnalisée.

Pour nettoyer l’image en vue d’une utilisation future, créez un composant qui exécute les commandes suivantes pour arrêter le package ecs-init et les processus Docker :

```
sudo systemctl stop ecs
sudo systemctl stop docker
```

Supprimez tous les fichiers journaux de l’instance actuelle pour éviter de les conserver lors de l’enregistrement de l’image. Utilisez l’exemple de script de la section [Pratiques exemplaires en matière de sécurité pour EC2 Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/security-best-practices.html) pour nettoyer les différents fichiers de l’instance.

Pour nettoyer les données spécifiques d’Amazon ECS, exécutez les commandes suivantes :

```
sudo rm -rf /var/log/ecs/*
sudo rm /var/lib/ecs/data/agent.db
```

Pour plus d'informations sur la création d'une AMI personnalisée optimisée pour Amazon ECS AMIs, consultez [Comment créer une AMI personnalisée à partir d'une AMI optimisée pour Amazon ECS](https://forums.aws.amazon.com/knowledge-center/ecs-create-custom-amis/) ? dans le AWS Knowledge Center.

## Utilisation de l’ARN d’image avec l’infrastructure en tant que code (IaC)
<a name="infrastructure-as-code-arn"></a>

Vous pouvez configurer la recette à l'aide de la console EC2 Image Builder, de l'infrastructure sous forme de code (par exemple CloudFormation) ou AWS du SDK. Lorsque vous spécifiez une image parent dans votre recette, vous pouvez spécifier un ID d'AMI EC2, un ARN d'image Image Builder, un identifiant de AWS Marketplace produit ou une image de conteneur. AWS publie publiquement l'image AMI IDs et Image Builder ARNs d'Amazon ECS optimisée AMIs . Le format de l’ARN d’image est le suivant :

```
arn:${Partition}:imagebuilder:${Region}:${Account}:image/${ImageName}/${ImageVersion}
```

L’`ImageVersion` a le format suivant. Remplacez*major*, *minor* et *patch* par les dernières valeurs.

```
<major>.<minor>.<patch>
```

Vous pouvez remplacer `major` `minor` et `patch` remplacer des valeurs spécifiques ou utiliser l'ARN sans version d'une image, afin que votre pipeline conserve up-to-date la dernière version de l'image parent. Un ARN sans version utilise le format générique « x.x.x » pour représenter la version de l’image. Cette approche permet au service Image Builder de résoudre automatiquement la version la plus récente de l’image. L’utilisation d’un ARN sans version garantit que votre référence pointe toujours vers la dernière image disponible, ce qui rationalise le processus de mise à jour des images dans votre déploiement. Lorsque vous créez une recette avec la console, EC2 Image Builder identifie automatiquement l’ARN de votre image parent. Lorsque vous utilisez l’IaC pour créer la recette, vous devez identifier l’ARN et sélectionner la version d’image souhaitée ou utiliser un ARN sans version pour indiquer la dernière image disponible. Nous vous recommandons de créer un script automatique pour filtrer et n’afficher que les images correspondant à vos critères. Le script Python suivant montre comment récupérer une liste d'Amazon ECS AMIs optimisés. 

Le script accepte deux arguments facultatifs : `owner` et `platform`, avec les valeurs par défaut « Amazon » et « Windows » respectivement. Les valeurs valides pour l’argument du propriétaire sont : `Self`, `Shared`, `Amazon` et `ThirdParty`. Les valeurs valides pour l’argument de plateforme sont `Windows` et `Linux`. Par exemple, si vous exécutez le script avec les arguments `owner` définis sur `Amazon` et `platform` définis sur `Linux`, le script génère une liste d’images publiées par Amazon, y compris des images optimisées pour Amazon ECS.

```
import boto3
import argparse

def list_images(owner, platform):
    # Create a Boto3 session
    session = boto3.Session()
    
    # Create an EC2 Image Builder client
    client = session.client('imagebuilder')

    # Define the initial request parameters
    request_params = {
        'owner': owner,
        'filters': [
            {
                'name': 'platform',
                'values': [platform]
            }
        ]
    }

    # Initialize the results list
    all_images = []

    # Get the initial response with the first page of results
    response = client.list_images(**request_params)

    # Extract images from the response
    all_images.extend(response['imageVersionList'])

    # While 'nextToken' is present, continue paginating
    while 'nextToken' in response and response['nextToken']:
        # Update the token for the next request
        request_params['nextToken'] = response['nextToken']

        # Get the next page of results
        response = client.list_images(**request_params)

        # Extract images from the response
        all_images.extend(response['imageVersionList'])

    return all_images

def main():
    # Initialize the parser
    parser = argparse.ArgumentParser(description="List AWS images based on owner and platform")
    
    # Add the parameters/arguments
    parser.add_argument("--owner", default="Amazon", help="The owner of the images. Default is 'Amazon'.")
    parser.add_argument("--platform", default="Windows", help="The platform type of the images. Default is 'Windows'.")

    # Parse the arguments
    args = parser.parse_args()

    # Retrieve all images based on the provided owner and platform
    images = list_images(args.owner, args.platform)

    # Print the details of the images
    for image in images:
        print(f"Name: {image['name']}, Version: {image['version']}, ARN: {image['arn']}")

if __name__ == "__main__":
    main()
```

## Utilisation de l'ARN de l'image avec CloudFormation
<a name="arn-with-cloudformation"></a>

Une recette d’image Image Builder est un plan qui spécifie l’image parent et les composants nécessaires pour obtenir la configuration prévue de l’image de sortie. Vous utilisez la ressource `AWS::ImageBuilder::ImageRecipe`. Définissez la valeur `ParentImage` sur l’ARN d’image. Utilisez l’ARN sans version de l’image souhaitée pour vous assurer que votre pipeline utilise toujours la version la plus récente de l’image. Par exemple, `arn:aws:imagebuilder:us-east-1:aws:image/amazon-linux-2023-ecs-optimized-x86/x.x.x`. La définition de `AWS::ImageBuilder::ImageRecipe` ressource suivante utilise un ARN d’image géré par Amazon :

```
ECSRecipe:
    Type: AWS::ImageBuilder::ImageRecipe
    Properties:
      Name: MyRecipe
      Version: '1.0.0'
      Components:
        - ComponentArn: [<The component arns of the image recipe>]
      ParentImage: "arn:aws:imagebuilder:us-east-1:aws:image/amazon-linux-2023-ecs-optimized-x86/x.x.x"
```

Pour plus d’informations sur la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagerecipe.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagerecipe.html), consultez le *Guide de l’utilisateur AWS CloudFormation *.

Vous pouvez automatiser la création de nouvelles images dans votre pipeline en définissant la propriété `Schedule` de la ressource `AWS::ImageBuilder::ImagePipeline`. Le calendrier inclut une condition de départ et une expression cron. Pour plus d’informations, consultez [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagepipeline.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-imagebuilder-imagepipeline.html) dans le *Guide de l’utilisateur AWS CloudFormation *.

 Dans l’exemple `AWS::ImageBuilder::ImagePipeline` suivant, le pipeline exécute une construction à 10 h 00, heure universelle coordonnée (UTC) tous les jours. Définissez les valeurs `Schedule` suivantes :
+ Définissez `PipelineExecutionStartCondition` sur `EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE`. Le build ne démarre que si des ressources dépendantes telles que l’image parent ou les composants, qui utilisent le caractère générique « x » dans leurs versions sémantiques, sont mises à jour. Cela garantit que la version intègre les dernières mises à jour de ces ressources.
+  ScheduleExpression Défini sur l'expression `(0 10 * * ? *)` cron.

```
ECSPipeline:
    Type: AWS::ImageBuilder::ImagePipeline
    Properties:
      Name: my-pipeline
      ImageRecipeArn: <arn of the recipe you created in previous step>
      InfrastructureConfigurationArn: <ARN of the infrastructure configuration associated with this image pipeline>
      Schedule:
        PipelineExecutionStartCondition: EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE
        ScheduleExpression: 'cron(0 10 * * ? *)'
```

## Utilisation de l’ARN d’image avec Terraform
<a name="arn-with-terraform"></a>

L’approche pour spécifier l’image parent et le calendrier de votre pipeline dans Terraform s’aligne sur celle de AWS CloudFormation. Vous utilisez la ressource `aws_imagebuilder_image_recipe`. Définissez la valeur `parent_image` sur l’ARN d’image. Utilisez l’ARN sans version de l’image souhaitée pour vous assurer que votre pipeline utilise toujours la version la plus récente de l’image. Pour plus d’informations, consultez la section [https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_recipe#argument-reference](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_recipe#argument-reference) dans la documentation Terraform. 

Dans le bloc de configuration du calendrier de la `aws_imagebuilder_image_pipeline resource`, définissez la valeur de l’argument `schedule_expression` sur une expression cron de votre choix pour spécifier la fréquence d’exécution du pipeline, puis définissez la valeur de `pipeline_execution_start_condition` sur `EXPRESSION_MATCH_AND_DEPENDENCY_UPDATES_AVAILABLE`. Pour plus d’informations, consultez la section [https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_pipeline#argument-reference](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/imagebuilder_image_pipeline#argument-reference) dans la documentation Terraform. 

# Utilisation de AWS Deep Learning Containers sur Amazon ECS
<a name="deep-learning-containers"></a>

AWS Les Deep Learning Containers fournissent un ensemble d'images Docker pour la formation et le service de modèles dans TensorFlow et Apache MXNet (incubation) sur Amazon ECS. Les Deep Learning Containers permettent d'optimiser les environnements grâce TensorFlow aux bibliothèques NVIDIA CUDA (pour les instances GPU) et Intel MKL (pour les instances CPU). Les images de conteneur pour les conteneurs Deep Learning Containers sont disponibles dans Amazon ECR pour être référencés dans les définitions de tâches Amazon ECS. Vous pouvez utiliser les conteneurs Deep Learning Containers avec Amazon Elastic Inference pour réduire vos coûts d'inférence.

Pour commencer à utiliser les conteneurs Deep Learning sans Elastic Inference sur Amazon ECS, consultez la section [Conteneurs Deep Learning sur Amazon ECS](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/deep-learning-containers-ecs-setup.html) dans le *Guide du développeur AWS Apprentissage profond (deep learning) AMIs *.

# Tutoriel : Création d'un service à l'aide d'un Blue/Green déploiement
<a name="create-blue-green"></a>

Amazon ECS a intégré blue/green les déploiements dans l'assistant de création de service sur la console Amazon ECS. Pour de plus amples informations, veuillez consulter [Création d’un déploiement de mise à jour propagée Amazon ECS](create-service-console-v2.md).

Le didacticiel suivant explique comment créer un service Amazon ECS contenant une tâche Fargate qui utilise blue/green le type de déploiement avec le. AWS CLI

**Note**  
Support pour effectuer un blue/green déploiement a été ajouté pour CloudFormation. *Pour plus d'informations, consultez la section [Effectuer des déploiements bleu/vert d'Amazon ECS CloudFormation dans le AWS CloudFormation guide CodeDeploy de l'](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html)utilisateur.*

## Conditions préalables
<a name="create-blue-green-prereqs"></a>

Le didacticiel suppose de remplir les prérequis suivants :
+ La dernière version du AWS CLI est installée et configurée. Pour plus d'informations sur l'installation ou la mise à niveau du AWS CLI, voir [Installation du AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html).
+ Vous devez avoir suivi les étapes de [Configurer l'utilisation d'Amazon ECS](get-set-up-for-amazon-ecs.md).
+ Votre utilisateur IAM dispose des autorisations requises spécifiées dans l’exemple de politique IAM [Amazon ECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess).
+ Vous avez un créé un VPC et un groupe de sécurité prêts à être utilisés. Pour de plus amples informations, veuillez consulter [Créer un Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ Le rôle Amazon ECS CodeDeploy IAM est créé. Pour de plus amples informations, veuillez consulter [Rôle CodeDeploy IAM d'Amazon ECS](codedeploy_IAM_role.md).

## Étape 1 : Créer un Application Load Balancer
<a name="create-blue-green-loadbalancer"></a>

Les services Amazon ECS utilisant le type de blue/green déploiement nécessitent l'utilisation d'un Application Load Balancer ou d'un Network Load Balancer. Ce didacticiel utilise un équilibreur de charge Application Load Balancer.

**Pour créer un Application Load Balancer**

1. Utilisez la [create-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-load-balancer.html)commande pour créer un Application Load Balancer. Spécifiez deux sous-réseaux qui ne proviennent pas de la même zone de disponibilité, ainsi qu'un groupe de sécurité.

   ```
   aws elbv2 create-load-balancer \
        --name bluegreen-alb \
        --subnets subnet-abcd1234 subnet-abcd5678 \
        --security-groups sg-abcd1234 \
        --region us-east-1
   ```

   Les données de sortie contiennent l'Amazon Resource Name (ARN) de l'équilibreur de charge, au format suivant :

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642
   ```

1. Utilisez la [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-target-group.html)commande pour créer un groupe cible. Ce groupe cible achemine le trafic vers la tâche d'origine définie dans votre service.

   ```
   aws elbv2 create-target-group \
        --name bluegreentarget1 \
        --protocol HTTP \
        --port 80 \
        --target-type ip \
        --vpc-id vpc-abcd1234 \
        --region us-east-1
   ```

   Les données de sortie contiennent l'ARN du groupe cible, au format suivant :

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4
   ```

1. Utilisez la commande [create-listener](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-listener.html) pour créer un écouteur d'équilibreur de charge avec une règle par défaut qui transfère les demandes au groupe cible :

   ```
   aws elbv2 create-listener \
        --load-balancer-arn arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642 \
        --protocol HTTP \
        --port 80 \
        --default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4 \
        --region us-east-1
   ```

   Les données de sortie contiennent l'ARN de l'écouteur, au format suivant :

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:listener/app/bluegreen-alb/e5ba62739c16e642/665750bec1b03bd4
   ```

## Étape 2 : créer un cluster Amazon ECS
<a name="create-blue-green-cluster"></a>

Utilisez la commande [create-cluster](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-cluster.html) pour créer un cluster nommé `tutorial-bluegreen-cluster` à utiliser.

```
aws ecs create-cluster \
     --cluster-name tutorial-bluegreen-cluster \
     --region us-east-1
```

Les données de sortie contiennent l'ARN du cluster, au format suivant :

```
arn:aws:ecs:region:aws_account_id:cluster/tutorial-bluegreen-cluster
```

## Étape 3 : Enregistrer une définition de tâche
<a name="create-blue-green-taskdef"></a>

Utilisez la [register-task-definition](https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html)commande pour enregistrer une définition de tâche compatible avec Fargate. Cela exige d'utiliser le mode réseau `awsvpc`. Voici l'exemple de définition de tâche utilisé pour ce didacticiel.

Pour commencer, créez un fichier nommé `fargate-task.json` avec le contenu suivant. Assurez-vous d'utiliser l'ARN de votre rôle d'exécution de tâche. Pour de plus amples informations, veuillez consulter [Rôle IAM d'exécution de tâche Amazon ECS](task_execution_IAM_role.md).

```
{
    "family": "sample-fargate", 
    "networkMode": "awsvpc", 
    "containerDefinitions": [
        {
            "name": "sample-app", 
            "image": "public.ecr.aws/docker/library/httpd:latest", 
            "portMappings": [
                {
                    "containerPort": 80, 
                    "hostPort": 80, 
                    "protocol": "tcp"
                }
            ], 
            "essential": true, 
            "entryPoint": [
                "sh",
		"-c"
            ], 
            "command": [
                "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
            ]
        }
    ], 
    "requiresCompatibilities": [
        "FARGATE"
    ], 
    "cpu": "256", 
    "memory": "512"
}
```

Enregistrez ensuite la définition de tâche à l'aide du fichier `fargate-task.json` que vous avez créé.

```
aws ecs register-task-definition \
     --cli-input-json file://fargate-task.json \
     --region us-east-1
```

## Étape 4 : créer un service Amazon ECS
<a name="create-blue-green-service"></a>

Utilisez la commande [create-service](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-service.html) pour créer un service. 

Pour commencer, créez un fichier nommé `service-bluegreen.json` avec le contenu suivant.

```
{
    "cluster": "tutorial-bluegreen-cluster",
    "serviceName": "service-bluegreen",
    "taskDefinition": "tutorial-task-def",
    "loadBalancers": [
        {
            "targetGroupArn": "arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4",
            "containerName": "sample-app",
            "containerPort": 80
        }
    ],
    "launchType": "FARGATE",
    "schedulingStrategy": "REPLICA",
    "deploymentController": {
        "type": "CODE_DEPLOY"
    },
    "platformVersion": "LATEST",
    "networkConfiguration": {
       "awsvpcConfiguration": {
          "assignPublicIp": "ENABLED",
          "securityGroups": [ "sg-abcd1234" ],
          "subnets": [ "subnet-abcd1234", "subnet-abcd5678" ]
       }
    },
    "desiredCount": 1
}
```

Ensuite, créez votre service à l'aide du fichier `service-bluegreen.json` que vous avez créé.

```
aws ecs create-service \
     --cli-input-json file://service-bluegreen.json \
     --region us-east-1
```

Les données de sortie contiennent l'ARN du service, au format suivant :

```
arn:aws:ecs:region:aws_account_id:service/service-bluegreen
```

## Étape 5 : Création des AWS CodeDeploy ressources
<a name="create-blue-green-codedeploy"></a>

Suivez les étapes ci-dessous pour créer votre CodeDeploy application, le groupe cible Application Load Balancer pour le groupe de CodeDeploy déploiement et le groupe de CodeDeploy déploiement.

**Pour créer des CodeDeploy ressources**

1. Utilisez la commande [create-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-application.html) pour créer une CodeDeploy application. Précisez la plateforme de calcul `ECS`.

   ```
   aws deploy create-application \
        --application-name tutorial-bluegreen-app \
        --compute-platform ECS \
        --region us-east-1
   ```

   Les données de sortie contiennent l'ID d'application, au format suivant :

   ```
   {
       "applicationId": "b8e9c1ef-3048-424e-9174-885d7dc9dc11"
   }
   ```

1. Utilisez la [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-target-group.html)commande pour créer un deuxième groupe cible Application Load Balancer, qui sera utilisé lors de la création de votre groupe de CodeDeploy déploiement.

   ```
   aws elbv2 create-target-group \
        --name bluegreentarget2 \
        --protocol HTTP \
        --port 80 \
        --target-type ip \
        --vpc-id "vpc-0b6dd82c67d8012a1" \
        --region us-east-1
   ```

   Les données de sortie contiennent l'ARN du groupe cible, au format suivant :

   ```
   arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget2/708d384187a3cfdc
   ```

1. Utilisez la [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)commande pour créer un groupe CodeDeploy de déploiement.

   Pour commencer, créez un fichier nommé `tutorial-deployment-group.json` avec le contenu suivant. Cet exemple utilise la ressource que vous avez créée. Pour le`serviceRoleArn`, spécifiez l'ARN de votre rôle Amazon ECS CodeDeploy IAM. Pour de plus amples informations, veuillez consulter [Rôle CodeDeploy IAM d'Amazon ECS](codedeploy_IAM_role.md).

   ```
   {
      "applicationName": "tutorial-bluegreen-app",
      "autoRollbackConfiguration": {
         "enabled": true,
         "events": [ "DEPLOYMENT_FAILURE" ]
      },
      "blueGreenDeploymentConfiguration": {
         "deploymentReadyOption": {
            "actionOnTimeout": "CONTINUE_DEPLOYMENT",
            "waitTimeInMinutes": 0
         },
         "terminateBlueInstancesOnDeploymentSuccess": {
            "action": "TERMINATE",
            "terminationWaitTimeInMinutes": 5
         }
      },
      "deploymentGroupName": "tutorial-bluegreen-dg",
      "deploymentStyle": {
         "deploymentOption": "WITH_TRAFFIC_CONTROL",
         "deploymentType": "BLUE_GREEN"
      },
      "loadBalancerInfo": {
         "targetGroupPairInfoList": [
           {
             "targetGroups": [
                {
                    "name": "bluegreentarget1"
                },
                {
                    "name": "bluegreentarget2"
                }
             ],
             "prodTrafficRoute": {
                 "listenerArns": [
                     "arn:aws:elasticloadbalancing:region:aws_account_id:listener/app/bluegreen-alb/e5ba62739c16e642/665750bec1b03bd4"
                 ]
             }
           }
         ]
      },
      "serviceRoleArn": "arn:aws:iam::aws_account_id:role/ecsCodeDeployRole",
      "ecsServices": [
          {
              "serviceName": "service-bluegreen",
              "clusterName": "tutorial-bluegreen-cluster"
          }
      ]
   }
   ```

   Créez ensuite le groupe CodeDeploy de déploiement.

   ```
   aws deploy create-deployment-group \
        --cli-input-json file://tutorial-deployment-group.json \
        --region us-east-1
   ```

   Les données de sortie contiennent l'ID du groupe de déploiement, au format suivant :

   ```
   {
       "deploymentGroupId": "6fd9bdc6-dc51-4af5-ba5a-0a4a72431c88"
   }
   ```

## Étape 6 : Création et surveillance d'un CodeDeploy déploiement
<a name="create-blue-green-verify"></a>

Suivez les étapes ci-dessous pour créer et télécharger un fichier de spécification d'application (AppSpec fichier) et un CodeDeploy déploiement.

**Pour créer et surveiller un CodeDeploy déploiement**

1. Créez et chargez un AppSpec fichier en suivant les étapes ci-dessous.

   1. Créez un fichier nommé `appspec.yaml` avec le contenu du groupe de déploiement CodeDeploy . Cet exemple utilise les ressources que vous avez créées précédemment dans le didacticiel.

      ```
      version: 0.0
      Resources:
        - TargetService:
            Type: AWS::ECS::Service
            Properties:
              TaskDefinition: "arn:aws:ecs:region:aws_account_id:task-definition/first-run-task-definition:7"
              LoadBalancerInfo:
                ContainerName: "sample-app"
                ContainerPort: 80
              PlatformVersion: "LATEST"
      ```

   1. Utilisez la commande [s3 mb](https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html) pour créer un compartiment Amazon S3 pour le AppSpec fichier.

      ```
      aws s3 mb s3://tutorial-bluegreen-bucket
      ```

   1. Utilisez la commande [s3 cp](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html) pour charger le AppSpec fichier dans le compartiment Amazon S3.

      ```
      aws s3 cp ./appspec.yaml s3://tutorial-bluegreen-bucket/appspec.yaml
      ```

1. Créez le CodeDeploy déploiement en suivant les étapes ci-dessous.

   1. Créez un fichier nommé `create-deployment.json` avec le contenu du CodeDeploy déploiement. Cet exemple utilise les ressources que vous avez créées précédemment dans le didacticiel.

      ```
      {
          "applicationName": "tutorial-bluegreen-app",
          "deploymentGroupName": "tutorial-bluegreen-dg",
          "revision": {
              "revisionType": "S3",
              "s3Location": {
                  "bucket": "tutorial-bluegreen-bucket",
                  "key": "appspec.yaml",
                  "bundleType": "YAML"
              }
          }
      }
      ```

   1. Utilisez la commande [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html) pour créer le déploiement.

      ```
      aws deploy create-deployment \
           --cli-input-json file://create-deployment.json \
           --region us-east-1
      ```

      Les données de sortie contiennent l'ID du déploiement, au format suivant :

      ```
      {
          "deploymentId": "d-RPCR1U3TW"
      }
      ```

   1. Utilisez la [get-deployment-target](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-target.html)commande pour obtenir les détails du déploiement, en spécifiant ceux `deploymentId` de la sortie précédente.

      ```
      aws deploy get-deployment-target \
           --deployment-id "d-IMJU3A8TW" \
           --target-id tutorial-bluegreen-cluster:service-bluegreen \
           --region us-east-1
      ```

      Continuez de récupérer les détails du déploiement jusqu'à ce que le statut soit `Succeeded`, comme indiqué dans la sortie suivante.

      ```
      {
          "deploymentTarget": {
              "deploymentTargetType": "ECSTarget",
              "ecsTarget": {
                  "deploymentId": "d-RPCR1U3TW",
                  "targetId": "tutorial-bluegreen-cluster:service-bluegreen",
                  "targetArn": "arn:aws:ecs:region:aws_account_id:service/service-bluegreen",
                  "lastUpdatedAt": 1543431490.226,
                  "lifecycleEvents": [
                      {
                          "lifecycleEventName": "BeforeInstall",
                          "startTime": 1543431361.022,
                          "endTime": 1543431361.433,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "Install",
                          "startTime": 1543431361.678,
                          "endTime": 1543431485.275,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AfterInstall",
                          "startTime": 1543431485.52,
                          "endTime": 1543431486.033,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "BeforeAllowTraffic",
                          "startTime": 1543431486.838,
                          "endTime": 1543431487.483,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AllowTraffic",
                          "startTime": 1543431487.748,
                          "endTime": 1543431488.488,
                          "status": "Succeeded"
                      },
                      {
                          "lifecycleEventName": "AfterAllowTraffic",
                          "startTime": 1543431489.152,
                          "endTime": 1543431489.885,
                          "status": "Succeeded"
                      }
                  ],
                  "status": "Succeeded",
                  "taskSetsInfo": [
                      {
                          "identifer": "ecs-svc/9223370493425779968",
                          "desiredCount": 1,
                          "pendingCount": 0,
                          "runningCount": 1,
                          "status": "ACTIVE",
                          "trafficWeight": 0.0,
                          "targetGroup": {
                              "name": "bluegreentarget1"
                          }
                      },
                      {
                          "identifer": "ecs-svc/9223370493423413672",
                          "desiredCount": 1,
                          "pendingCount": 0,
                          "runningCount": 1,
                          "status": "PRIMARY",
                          "trafficWeight": 100.0,
                          "targetGroup": {
                              "name": "bluegreentarget2"
                          }
                      }
                  ]
              }
          }
      }
      ```

## Étape 7 : Nettoyer
<a name="create-blue-green-cleanup"></a>

Lorsque vous avez terminé ce didacticiel, nettoyez les ressources qui lui sont associées afin d'éviter la facturation de frais pour des ressources que vous n'utilisez pas.

**Nettoyage des ressources du didacticiel**

1. Utilisez la [delete-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-deployment-group.html)commande pour supprimer le groupe CodeDeploy de déploiement.

   ```
   aws deploy delete-deployment-group \
        --application-name tutorial-bluegreen-app \
        --deployment-group-name tutorial-bluegreen-dg \
        --region us-east-1
   ```

1. Utilisez la commande [delete-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-application.html) pour supprimer l' CodeDeploy application.

   ```
   aws deploy delete-application \
        --application-name tutorial-bluegreen-app \
        --region us-east-1
   ```

1. Utilisez la commande [delete-service](https://docs.aws.amazon.com/cli/latest/reference/ecs/delete-service.html) pour supprimer l'Amazon ECS service. Utiliser l'indicateur `--force` vous permet de supprimer un service, même s'il n'a pas été abaissé à 0 tâche.

   ```
   aws ecs delete-service \
        --service arn:aws:ecs:region:aws_account_id:service/service-bluegreen \
        --force \
        --region us-east-1
   ```

1. Utilisez la commande [delete-cluster](https://docs.aws.amazon.com/cli/latest/reference/ecs/delete-cluster.html) pour supprimer le cluster Amazon ECS.

   ```
   aws ecs delete-cluster \
        --cluster tutorial-bluegreen-cluster \
        --region us-east-1
   ```

1. Utilisez la commande [s3 rm](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html) pour supprimer le AppSpec fichier du compartiment Amazon S3.

   ```
   aws s3 rm s3://tutorial-bluegreen-bucket/appspec.yaml
   ```

1. Utilisez la commande [s3 rb](https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html) pour supprimer le compartiment Amazon S3.

   ```
   aws s3 rb s3://tutorial-bluegreen-bucket
   ```

1. Utilisez la [delete-load-balancer](https://docs.aws.amazon.com/cli/latest/reference/elbv2/delete-load-balancer.html)commande pour supprimer l'Application Load Balancer.

   ```
   aws elbv2 delete-load-balancer \
        --load-balancer-arn arn:aws:elasticloadbalancing:region:aws_account_id:loadbalancer/app/bluegreen-alb/e5ba62739c16e642 \
        --region us-east-1
   ```

1. Utilisez la [delete-target-group](https://docs.aws.amazon.com/cli/latest/reference/elbv2/delete-target-group.html)commande pour supprimer les deux groupes cibles Application Load Balancer.

   ```
   aws elbv2 delete-target-group \
        --target-group-arn arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget1/209a844cd01825a4 \
        --region us-east-1
   ```

   ```
   aws elbv2 delete-target-group \
        --target-group-arn arn:aws:elasticloadbalancing:region:aws_account_id:targetgroup/bluegreentarget2/708d384187a3cfdc \
        --region us-east-1
   ```