# Creación de un servicio de Amazon ECS que utilice la detección de servicios
<a name="create-service-discovery"></a>

Obtenga información sobre cómo crear un servicio que contenga una tarea de Fargate que utilice la detección de servicios a través de la AWS CLI.

Para obtener una lista de Regiones de AWS que admiten la detección de servicios, consulte [Uso de la detección de servicios para conectar los servicios de Amazon ECS con nombres de DNS](service-discovery.md).

Para obtener información acerca de las regiones que admiten Fargate, consulte [Regiones compatibles con Amazon ECS en AWS Fargate](AWS_Fargate-Regions.md).

**nota**  
Puede utilizar puntos de conexión de servicio de doble pila para interactuar con Amazon ECS desde la AWS CLI, los SDK y la API de Amazon ECS a través de IPv4 e IPv6. Para obtener más información, consulte [Uso de puntos de conexión de doble pila en Amazon ECS](dual-stack-endpoint.md).

## Requisitos previos
<a name="create-service-discovery-prereqs"></a>

Antes de empezar este tutorial, asegúrese de que se cumplen los siguientes requisitos previos:
+ La última versión de la AWS CLI está instalada y configurada. Para obtener más información, consulte [Instalación o actualización de la versión más reciente de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Los pasos descritos en [Configuración para utilizar Amazon ECS](get-set-up-for-amazon-ecs.md) están completos.
+ Su usuario de IAM dispone de los permisos requeridos que se especifican en la política de IAM [AmazonECS\$1FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess) de ejemplo.
+ Ha creado al menos una VPC y un grupo de seguridad. Para obtener más información, consulte [Creación de una nube virtual privada](get-set-up-for-amazon-ecs.md#create-a-vpc).

## Paso 1: crear los recursos para la detección de servicios en AWS Cloud Map
<a name="create-service-discovery-namespace"></a>

Siga estos pasos para crear el espacio de nombres para la detección de servicios y el servicio de detección de servicios:

1. Cree un espacio de nombres de detección de servicios de Cloud Map privado. Este ejemplo crea un espacio de nombres denominado `tutorial`. Reemplace *vpc-abcd1234* con el ID de una de las VPC existentes. 

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

   A continuación se muestra la salida de este comando.

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

1. Mediante el `OperationId` de la salida del paso anterior, compruebe que el espacio de nombres privado se haya creado correctamente. Anote el ID del espacio de nombres porque lo utilizará en los comandos posteriores.

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

   El resultado es el siguiente.

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

1. Mediante el ID de `NAMESPACE` de la salida del paso anterior, cree un servicio de detección de servicios. En este ejemplo, se crea un servicio denominado `myapplication`. Anote el ID de servicio y el ARN porque los utilizará en comandos posteriores.

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

   El resultado es el siguiente.

   ```
   {
       "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"
       }
   }
   ```

## Paso 2: Crear los recursos de Amazon ECS
<a name="create-service-discovery-cluster"></a>

Siga estos pasos para crear el clúster, la definición de tareas y el servicio de Amazon ECS:

1. Cree un clúster de Amazon ECS. Este ejemplo crea un clúster denominado `tutorial`. 

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

1. Registre una definición de tarea que sea compatible con Fargate y utilice el `awsvpc` en modo de red. Siga estos pasos:

   1. Cree un archivo denominado `fargate-task.json` con los contenidos de la siguiente definición de tareas.

      ```
      {
          "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. Registre la definición de tareas mediante `fargate-task.json`.

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

1. Cree un servicio de ECS siguiendo estos pasos:

   1. Cree un archivo llamado `ecs-service-discovery.json` con el contenido del servicio de ECS que va a crear. En este ejemplo se utiliza la definición de tareas creada en el paso anterior. Es necesario un `awsvpcConfiguration` porque el ejemplo de definición de tareas utiliza el modo de red `awsvpc`. 

      Cuando cree el servicio de ECS, especifique Fargate y la versión `LATEST` de la plataforma que admite la detección de servicios. Cuando se crea el servicio de detección de servicios en AWS Cloud Map, `registryArn` es el ARN devuelto. Los `securityGroups` y las `subnets` deben pertenecer a la VPC que se usa para crear el espacio de nombres de Cloud Map. Puede obtener los ID de subred y grupos de seguridad en la consola de 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. Cree el servicio de ECS mediante `ecs-service-discovery.json`.

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

## Paso 3: verificar la detección de servicios en AWS Cloud Map
<a name="create-service-discovery-verify"></a>

Puede comprobar que todo se haya creado de forma correcta al consultar la información de detección de servicios. Una vez configurada la detección de servicios, puede usar las operaciones de la API de AWS Cloud Map o llamar a `dig` desde una instancia de la VPC. Siga estos pasos:

1. Mediante el ID del servicio de detección de servicios, enumere las instancias de detección de servicios. Anote el ID de la instancia (marcado en negrita) para la limpieza de recursos. 

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

   El resultado es el siguiente.

   ```
   {
       "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. Utilice el espacio de nombres de detección de servicios, el servicio y los parámetros adicionales, como el nombre del clúster ECS, para consultar los detalles de las instancias de detección de servicios.

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

1. Los registros de DNS que se crearon en la zona alojada de Route 53 para el servicio de detección de servicios se pueden consultar mediante los siguientes comandos de la AWS CLI:

   1. Mediante el ID de espacio de nombres, obtenga información acerca del espacio de nombres, lo que incluye el ID de la zona alojada de Route 53.

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

      El resultado es el siguiente.

      ```
      {
          "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. Mediante el ID de la zona alojada de Route 53 del paso anterior, obtenga el conjunto de registros de recursos de la zona alojada. 

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

1. También puede consultar el DNS desde una instancia de la VPC con `dig`.

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

## Paso 4: Limpiar
<a name="create-service-discovery-cleanup"></a>

Cuando termine este tutorial, debe limpiar los recursos asociados para evitar incurrir en cargos generados por recursos sin utilizar. Siga estos pasos:

1. Anule el registro de las instancias del servicio de descubrimiento de servicios con el ID de servicio y el ID de instancia que anotó con anterioridad.

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

   El resultado es el siguiente.

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

1. Con el `OperationId` del resultado del paso anterior, verifique que las instancias de servicio de detección de servicios fueron dadas de baja con éxito.

   ```
   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. Elimine el servicio de detección de servicios mediante el ID de servicio.

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

1. Elimine el espacio de nombres de detección de servicios mediante el ID del espacio de nombres.

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

   El resultado es el siguiente.

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

1. Con el `OperationId` del resultado del paso anterior, compruebe que el espacio de nombres de la detección de servicios se haya eliminado correctamente.

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

   El resultado es el siguiente.

   ```
   {
       "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. Actualice el recuento deseado para el servicio Amazon ECS para`0`. Debe hacerlo para eliminar el servicio en el siguiente paso.

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

1. Elimine el servicio Amazon ECS.

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

1. Elimine el clúster de Amazon ECS.

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