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 Amazon ECS pour EC2 avec AWS CLI
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
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
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
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
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
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
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
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
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
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
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
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
**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 :
```
Welcome to nginx!
...
Welcome to nginx!
If you can see this page, the nginx web server is successfully installed and working.
...
```
La page d’accueil de nginx confirme que votre service fonctionne correctement et est accessible depuis Internet.
## nettoyer des ressources ;
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"
}
}
```