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’un service Amazon ECS qui utilise la découverte de service
<a name="create-service-discovery"></a>

Découvrez comment créer un service contenant une tâche Fargate qui utilise la découverte de service avec l’ AWS CLI.

Pour obtenir la liste de Régions AWS ces services d'assistance découverts, consultez[Utilisation de la découverte de service pour connecter les services Amazon ECS avec des noms DNS](service-discovery.md).

Pour de plus amples informations sur les Régions qui prennent en charge Fargate, veuillez consulter [Régions prises en charge pour Amazon ECS sur AWS Fargate](AWS_Fargate-Regions.md).

**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).

## Conditions préalables
<a name="create-service-discovery-prereqs"></a>

Avant de commencer ce didacticiel, vérifiez que vous respectez les conditions requises suivantes :
+ 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).
+ Les étapes décrites dans [Configurer l'utilisation d'Amazon ECS](get-set-up-for-amazon-ecs.md) sont terminées.
+ 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 créé au moins un VPC et un groupe de sécurité. Pour de plus amples informations, veuillez consulter [Créer un Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).

## Étape 1 : créer les ressources Service Discovery dans AWS Cloud Map
<a name="create-service-discovery-namespace"></a>

Suivez ces étapes suivantes pour créer votre espace de noms de découverte de service et votre service de découverte de service :

1. Créez un espace de noms de découverte de service Cloud Map privé. Cet exemple crée un espace de noms appelé `tutorial`. *vpc-abcd1234*Remplacez-le par l'identifiant de l'un de vos identifiants existants VPCs. 

   ```
   aws servicediscovery create-private-dns-namespace \
         --name tutorial \
         --vpc vpc-abcd1234
   ```

   La sortie de cette commande est la suivante.

   ```
   {
       "OperationId": "h2qe3s6dxftvvt7riu6lfy2f6c3jlhf4-je6chs2e"
   }
   ```

1. À l'aide du paramètre `OperationId` obtenu à partir de la sortie de l'étape précédente, vérifiez que l'espace de noms privés a bien été créé. Notez l'ID de l'espace de noms car vous l'utiliserez dans les commandes suivantes.

   ```
   aws servicediscovery get-operation \
         --operation-id h2qe3s6dxftvvt7riu6lfy2f6c3jlhf4-je6chs2e
   ```

   La sortie est la suivante.

   ```
   {
       "Operation": {
           "Id": "h2qe3s6dxftvvt7riu6lfy2f6c3jlhf4-je6chs2e",
           "Type": "CREATE_NAMESPACE",
           "Status": "SUCCESS",
           "CreateDate": 1519777852.502,
           "UpdateDate": 1519777856.086,
           "Targets": {
              "NAMESPACE": "ns-uejictsjen2i4eeg"
           }
       }
   }
   ```

1. En utilisant l'ID `NAMESPACE` indiqué dans la sortie de l'étape précédente, créez un service de découverte de service. Cet exemple crée un service nommé `myapplication`. Notez l'ID du service et l'ARN car vous les utiliserez dans les commandes suivantes.

   ```
   aws servicediscovery create-service \
         --name myapplication \
         --dns-config "NamespaceId="ns-uejictsjen2i4eeg",DnsRecords=[{Type="A",TTL="300"}]" \
         --health-check-custom-config FailureThreshold=1
   ```

   La sortie est la suivante.

   ```
   {
       "Service": {
          "Id": "srv-utcrh6wavdkggqtk",
           "Arn": "arn:aws:servicediscovery:region:aws_account_id:service/srv-utcrh6wavdkggqtk",
           "Name": "myapplication",
           "DnsConfig": {
               "NamespaceId": "ns-uejictsjen2i4eeg",
               "DnsRecords": [
                   {
                       "Type": "A",
                       "TTL": 300
                   }
               ]
           },
           "HealthCheckCustomConfig": {
               "FailureThreshold": 1
           },
           "CreatorRequestId": "e49a8797-b735-481b-a657-b74d1d6734eb"
       }
   }
   ```

## Étape 2 : Créer les ressources Amazon ECS
<a name="create-service-discovery-cluster"></a>

Suivez ces étapes pour créer votre cluster, votre définition de tâche et votre service Amazon ECS service :

1. Créez un nouveau cluster Amazon ECS. Cet exemple crée un cluster appelé `tutorial`. 

   ```
   aws ecs create-cluster \
         --cluster-name tutorial
   ```

1. Enregistrez une définition de tâche compatible avec Fargate et qui utilise le mode réseau `awsvpc`. Procédez comme suit :

   1. Créez un fichier nommé `fargate-task.json` avec le contenu de la définition de tâche suivante.

      ```
      {
          "family": "tutorial-task-def",
              "networkMode": "awsvpc",
              "containerDefinitions": [
                  {
                      "name": "sample-app",
                      "image": "public.ecr.aws/docker/library/httpd:2.4",
                      "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"
      }
      ```

   1. Enregistrez la définition de tâche en utilisant `fargate-task.json`.

      ```
      aws ecs register-task-definition \
            --cli-input-json file://fargate-task.json
      ```

1. Créez un service ECS en procédant comme suit :

   1. Créez un fichier nommé `ecs-service-discovery.json` avec le contenu du service ECS que vous créez. Cet exemple utilise la définition de tâche créée à l'étape précédente. Le paramètre `awsvpcConfiguration` est obligatoire, car l'exemple de définition de tâche utilise le mode réseau `awsvpc`. 

      Lorsque vous créez le service ECS, spécifiez le type de lancement Fargate et la version de plateforme `LATEST`, qui prend en charge la fonction de découverte de service. Lorsque le service de découverte de service est créé dans AWS Cloud Map , `registryArn` est l'ARN renvoyé. Les `securityGroups` et les `subnets` doivent appartenir au VPC utilisé pour créer l'espace de noms Cloud Map. Vous pouvez obtenir le groupe de sécurité et le sous-réseau IDs depuis la console Amazon VPC.

      ```
      {
          "cluster": "tutorial",
          "serviceName": "ecs-service-discovery",
          "taskDefinition": "tutorial-task-def",
          "serviceRegistries": [
             {
                "registryArn": "arn:aws:servicediscovery:region:aws_account_id:service/srv-utcrh6wavdkggqtk"
             }
          ],
          "launchType": "FARGATE",
          "platformVersion": "LATEST",
          "networkConfiguration": {
             "awsvpcConfiguration": {
                "assignPublicIp": "ENABLED",
                "securityGroups": [ "sg-abcd1234" ],
                "subnets": [ "subnet-abcd1234" ]
             }
          },
          "desiredCount": 1
      }
      ```

   1. Créez votre service ECS à l'aide du `ecs-service-discovery.json`.

      ```
      aws ecs create-service \
            --cli-input-json file://ecs-service-discovery.json
      ```

## Étape 3 : vérifier la découverte du service dans AWS Cloud Map
<a name="create-service-discovery-verify"></a>

Vous pouvez vérifier que tout est bien créé en interrogeant les informations associées à la fonction de découverte de service. Une fois la découverte des services configurée, vous pouvez soit utiliser des opérations d' AWS Cloud Map API, soit effectuer un appel `dig` depuis une instance au sein de votre VPC. Procédez comme suit :

1. À l'aide de l'ID de service de découverte de service, répertoriez les instances de découverte de service. Notez l'ID de l'instance (en gras) pour le nettoyage des ressources. 

   ```
    aws servicediscovery list-instances \
          --service-id srv-utcrh6wavdkggqtk
   ```

   La sortie est la suivante.

   ```
   {
       "Instances": [
           {
               "Id": "16becc26-8558-4af1-9fbd-f81be062a266",
               "Attributes": {
                   "AWS_INSTANCE_IPV4": "172.31.87.2"
                   "AWS_INSTANCE_PORT": "80", 
                   "AVAILABILITY_ZONE": "us-east-1a", 
                   "REGION": "us-east-1", 
                   "ECS_SERVICE_NAME": "ecs-service-discovery", 
                   "ECS_CLUSTER_NAME": "tutorial", 
                   "ECS_TASK_DEFINITION_FAMILY": "tutorial-task-def"
               }
           }
       ]
   }
   ```

1. Utilisez l'espace de noms, le service et les paramètres supplémentaires tels que le nom du cluster ECS pour demander des informations détaillées sur les instances de la fonction de découverte de service.

   ```
   aws servicediscovery discover-instances \
         --namespace-name tutorial \
         --service-name myapplication \
         --query-parameters ECS_CLUSTER_NAME=tutorial
   ```

1. Vous pouvez interroger les registres DNS créés dans la zone hébergée Route 53 de votre service de découverte de service à l'aide des commandes AWS CLI suivantes :

   1. À l'aide de l'ID de l'espace de noms, obtenez les informations relatives à l'espace de noms, lesquelles incluent l'ID de la zone hébergée Route 53.

      ```
      aws servicediscovery \
            get-namespace --id ns-uejictsjen2i4eeg
      ```

      La sortie est la suivante.

      ```
      {
          "Namespace": {
              "Id": "ns-uejictsjen2i4eeg",
              "Arn": "arn:aws:servicediscovery:region:aws_account_id:namespace/ns-uejictsjen2i4eeg",
              "Name": "tutorial",
              "Type": "DNS_PRIVATE",
              "Properties": {
                   "DnsProperties": {
                      "HostedZoneId": "Z35JQ4ZFDRYPLV"
                  }
              },
              "CreateDate": 1519777852.502,
              "CreatorRequestId": "9049a1d5-25e4-4115-8625-96dbda9a6093"
          }
      }
      ```

   1. À l'aide de l'ID de zone hébergée Route 53 de l'étape précédente (voir le texte en gras), obtenez l'enregistrement de ressource défini pour la zone hébergée. 

      ```
      aws route53 list-resource-record-sets \
            --hosted-zone-id Z35JQ4ZFDRYPLV
      ```

1. Vous pouvez également interroger le DNS à partir d'une instance de votre VPC à l'aide de `dig`.

   ```
   dig +short myapplication.tutorial
   ```

## Étape 4 : nettoyer
<a name="create-service-discovery-cleanup"></a>

Une fois que vous avez terminé ce didacticiel, nettoyez les ressources qui lui sont associées afin d'éviter la facturation de frais pour des ressources inutilisées. Procédez comme suit :

1. Annulez l'enregistrement des instances de service de découverte de service à l'aide de l'ID de service et de l'ID de l'instance que vous avez notés précédemment.

   ```
   aws servicediscovery deregister-instance \
         --service-id srv-utcrh6wavdkggqtk \
         --instance-id 16becc26-8558-4af1-9fbd-f81be062a266
   ```

   La sortie est la suivante.

   ```
   {
       "OperationId": "xhu73bsertlyffhm3faqi7kumsmx274n-jh0zimzv"
   }
   ```

1. À l'aide du `OperationId` indiqué dans la sortie de l'étape précédente, vérifiez que l'inscription des instances du service de découverte de service ont été correctement annulées.

   ```
   aws servicediscovery get-operation \ 
         --operation-id xhu73bsertlyffhm3faqi7kumsmx274n-jh0zimzv
   ```

   ```
   {
     "Operation": {
           "Id": "xhu73bsertlyffhm3faqi7kumsmx274n-jh0zimzv",
           "Type": "DEREGISTER_INSTANCE",
           "Status": "SUCCESS",
           "CreateDate": 1525984073.707,
           "UpdateDate": 1525984076.426,
           "Targets": {
               "INSTANCE": "16becc26-8558-4af1-9fbd-f81be062a266",
               "ROUTE_53_CHANGE_ID": "C5NSRG1J4I1FH",
               "SERVICE": "srv-utcrh6wavdkggqtk"
           }
       }
   }
   ```

1. Supprimez le service de découverte de service en utilisant l'ID du service.

   ```
   aws servicediscovery delete-service \ 
         --id srv-utcrh6wavdkggqtk
   ```

1. Supprimer l'espace de noms de découverte de service en utilisant l'ID de l'espace de noms.

   ```
   aws servicediscovery delete-namespace \ 
         --id ns-uejictsjen2i4eeg
   ```

   La sortie est la suivante.

   ```
   {
       "OperationId": "c3ncqglftesw4ibgj5baz6ktaoh6cg4t-jh0ztysj"
   }
   ```

1. À l'aide du `OperationId` indiqué dans la sortie de l'étape précédente, vérifiez que l'espace de noms de la découverte de service a été correctement supprimé.

   ```
   aws servicediscovery get-operation \ 
         --operation-id c3ncqglftesw4ibgj5baz6ktaoh6cg4t-jh0ztysj
   ```

   La sortie est la suivante.

   ```
   {
       "Operation": {
           "Id": "c3ncqglftesw4ibgj5baz6ktaoh6cg4t-jh0ztysj",
           "Type": "DELETE_NAMESPACE",
           "Status": "SUCCESS",
           "CreateDate": 1525984602.211,
           "UpdateDate": 1525984602.558,
           "Targets": {
               "NAMESPACE": "ns-rymlehshst7hhukh",
               "ROUTE_53_CHANGE_ID": "CJP2A2M86XW3O"
           }
       }
   }
   ```

1. Définissez le nombre souhaité pour le service Amazon ECS sur `0`. Vous devez effectuer cette étape pour supprimer le service à l'étape suivante.

   ```
   aws ecs update-service \
         --cluster tutorial \
         --service ecs-service-discovery \
         --desired-count 0
   ```

1. Supprimez l'Amazon ECS service.

   ```
   aws ecs delete-service \
         --cluster tutorial \
         --service ecs-service-discovery
   ```

1. Supprimez le cluster Amazon ECS.

   ```
   aws ecs delete-cluster \
         --cluster tutorial
   ```