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.

# 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 des AWS CLI SDK et de l'API Amazon ECS sur 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\_ 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 de plus amples informations sur les groupes de sécurité et les règles, veuillez consulter [Groupes de sécurité par défaut de vos VPC](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 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}}
```