# Criar um novo serviço Amazon ECS que usa descoberta de serviços
<a name="create-service-discovery"></a>

Saiba como criar um serviço que contém uma tarefa do Fargate que usa descoberta de serviços com a AWS CLI.

Para obter uma lista de Regiões da AWS que oferecem suporte à descoberta de serviços, consulte [Uso da descoberta de serviços para conectar serviços do Amazon ECS com nomes DNS](service-discovery.md).

Para obter informações sobre as regiões que oferecem suporte ao Fargate, consulte [Regiões com suporte para Amazon ECS no AWS Fargate](AWS_Fargate-Regions.md).

**nota**  
É possível usar endpoints de serviço de pilha dupla para interagir com o Amazon ECS via AWS CLI, SDKs e API do Amazon ECS sobre IPv4 e IPv6. Para obter mais informações, consulte [Usar endpoints de pilha dupla do Amazon ECS](dual-stack-endpoint.md).

## Pré-requisitos
<a name="create-service-discovery-prereqs"></a>

Antes de começar este tutorial, certifique-se de que os seguintes pré-requisitos foram atendidos:
+ A versão mais recente da AWS CLI está instalada e configurada. Para obter mais informações, consulte [Instalar ou atualizar para a versão mais recente da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ As etapas descritas em [Configuração para usar o Amazon ECS](get-set-up-for-amazon-ecs.md) estão concluídas.
+ O usuário do IAM tem as permissões necessárias especificadas no exemplo de política do IAM de [AmazonECS\$1FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess).
+ Você criou pelo menos uma VPC e um grupo de segurança. Para obter mais informações, consulte [Criar uma nuvem privada virtual](get-set-up-for-amazon-ecs.md#create-a-vpc).

## Etapa 1: criar os recursos da descoberta de serviços no AWS Cloud Map
<a name="create-service-discovery-namespace"></a>

Siga estas etapas para criar o namespace de descoberta de serviços e o serviço de descoberta de serviços.

1. Crie um namespace privado de descoberta de serviços do Cloud Map. Este exemplo cria um namespace denominado `tutorial`. Substitua *vpc-abcd1234* pelo ID de uma das VPCs existentes. 

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

   A saída deste comando é a seguinte.

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

1. Usando o `OperationId` do resultado da etapa anterior, verifique se o namespace privado foi criado com êxito. Anote o ID de namespace, pois ele será usado em comandos subsequentes.

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

   A saída é a seguinte:

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

1. Usando o ID do `NAMESPACE` da saída da etapa anterior, crie um serviço de descoberta de serviços. Este exemplo cria um serviço denominado `myapplication`. Anote o ID do serviço e o ARN, pois você os usará em comandos subsequentes.

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

   A saída é a seguinte:

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

## Etapa 2: criar os recursos do Amazon ECS
<a name="create-service-discovery-cluster"></a>

Siga estas etapas para criar seu cluster, definição de tarefa e serviço do Amazon ECS:

1. Crie um cluster do Amazon ECS. Este exemplo cria um cluster que denominado `tutorial`. 

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

1. Registre uma definição de tarefa compatível com o Fargate e use o modo de rede `awsvpc`. Siga estas etapas:

   1. Crie um arquivo denominado `fargate-task.json` com o conteúdo da seguinte definição de tarefa.

      ```
      {
          "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 a definição de tarefa usando `fargate-task.json`.

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

1. Crie um serviço do ECS seguindo estas etapas:

   1. Crie um arquivo denominado `ecs-service-discovery.json` com o conteúdo do serviço do ECS que você está criando. Este exemplo usa a definição de tarefa criada na etapa anterior. Uma `awsvpcConfiguration` é necessária, pois o exemplo de definição de tarefa usa o modo de rede `awsvpc`. 

      Ao criar o serviço do ECS, especifique o Fargate e a versão da plataforma `LATEST` que oferece suporte à descoberta de serviços. Quando o serviço de descoberta de serviços é criado no AWS Cloud Map, `registryArn` é o ARN retornado. `securityGroups` e `subnets` devem pertencer à VPC utilizada para criar o namespace do Cloud Map. É possível obter os IDs de grupos de segurança e sub-redes no console da 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. Crie seu serviço do ECS usando `ecs-service-discovery.json`.

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

## Etapa 3: verificar a descoberta de serviços no AWS Cloud Map
<a name="create-service-discovery-verify"></a>

Verifique se tudo foi criado corretamente consultando suas informações da descoberta de serviços. Depois que a descoberta de serviços estiver configurada, será possível usar operações de API do AWS Cloud Map ou chamar `dig` de uma instância na sua VPC. Siga estas etapas:

1. Usando o ID de serviço de descoberta de serviço, liste as instâncias da descoberta de serviço. Anote o ID da instância (marcado em negrito) para a limpeza de recursos. 

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

   A saída é a seguinte:

   ```
   {
       "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. Use o namespace de descoberta de serviços, o serviço e parâmetros adicionais, como o nome do cluster do ECS, para consultar detalhes sobre as instâncias de descoberta de serviços.

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

1. Os registros DNS criados na zona hospedada do Route 53 para o serviço de descoberta de serviço podem ser consultados com os comandos da AWS CLI a seguir:

   1. Usando o ID do namespace, obtenha informações sobre o namespace, o que inclui o ID da zona hospedada do Route 53.

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

      A saída é a seguinte:

      ```
      {
          "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. Usando o ID da zona hospedada do Route 53 da etapa anterior (veja o texto em negrito), obtenha o registro de recurso definido para a zona hospedada. 

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

1. Você também pode consultar o DNS de uma instância na sua VPC usando `dig`.

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

## Etapa 4: limpar
<a name="create-service-discovery-cleanup"></a>

Ao concluir este tutorial, limpe os recursos associados para evitar cobranças por recursos não utilizados. Siga estas etapas:

1. Cancele o registro das instâncias do serviço de descoberta de serviços, usando o ID do serviço e o ID da instância anotados anteriormente.

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

   A saída é a seguinte:

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

1. Usando o `OperationId` da saída da etapa anterior, verifique se as instâncias do serviço de descoberta de serviços foram canceladas com ê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. Exclua o serviço de descoberta de serviços usando o ID do serviço.

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

1. Exclua o namespace de descoberta de serviços usando o ID do namespace.

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

   A saída é a seguinte:

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

1. Usando o `OperationId` da saída da etapa anterior, verifique se o namespace da descoberta de serviços foi excluído com êxito.

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

   A saída é a seguinte:

   ```
   {
       "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. Atualize para`0` a contagem desejada para o serviço Amazon ECS. Isso deve ser feito para excluir o serviço na etapa seguinte.

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

1. Exclua o serviço do Amazon ECS.

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

1. Exclua o cluster do Amazon ECS.

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