```
# Configuração do Amazon ECS Service Connect com a AWS CLI
É possível criar um serviço do Amazon ECS para uma tarefa do Fargate que usa o Service Connect com a AWS CLI.
**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
Confira a seguir os pré-requisitos do Service Connect:
+ Verifique se a versão mais recente da AWS CLI está instalada e configurada. Para saber mais, 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).
+ 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ê tem uma VPC, uma sub-rede, uma tabela de rotas e um grupo de segurança criados para serem usados. Para obter mais informações, consulte [Criar uma nuvem privada virtual](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ Você tem um perfil de execução de tarefa com o nome `ecsTaskExecutionRole` e a política gerenciada `AmazonECSTaskExecutionRolePolicy` está anexada ao perfil. Esse perfil permite que o Fargate grave os logs da aplicação NGINX e os logs do proxy do Service Connect no Amazon CloudWatch Logs. Para obter mais informações, consulte [Criar a função de execução de tarefa do](task_execution_IAM_role.md#create-task-execution-role).
## Etapa 1: criar um cluster
Use as etapas a seguir para criar um cluster e um namespace do Amazon ECS.
**Para criar o cluster e o namespace AWS Cloud Map do Amazon ECS**
1. Crie um cluster do Amazon ECS denominado `tutorial` a ser usado. O parâmetro `--service-connect-defaults` define o namespace padrão do cluster. Na saída do exemplo, um namespace do AWS Cloud Map com o nome `service-connect` não existe nessa conta nem na Região da AWS. Portanto, o namespace é criado pelo Amazon ECS. O namespace é criado no AWS Cloud Map na conta e é visível com todos os outros namespaces. Portanto, use um nome que indique a finalidade.
```
aws ecs create-cluster --cluster-name tutorial --service-connect-defaults namespace=service-connect
```
Resultado:
```
{
"cluster": {
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/tutorial",
"clusterName": "tutorial",
"serviceConnectDefaults": {
"namespace": "arn:aws:servicediscovery:us-west-2:123456789012:namespace/ns-EXAMPLE"
},
"status": "PROVISIONING",
"registeredContainerInstancesCount": 0,
"runningTasksCount": 0,
"pendingTasksCount": 0,
"activeServicesCount": 0,
"statistics": [],
"tags": [],
"settings": [
{
"name": "containerInsights",
"value": "disabled"
}
],
"capacityProviders": [],
"defaultCapacityProviderStrategy": [],
"attachments": [
{
"id": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"type": "sc",
"status": "ATTACHING",
"details": []
}
],
"attachmentsStatus": "UPDATE_IN_PROGRESS"
}
}
}
```
1. Verifique se o cluster foi criado:
```
aws ecs describe-clusters --clusters tutorial
```
Resultado:
```
{
"clusters": [
{
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/tutorial",
"clusterName": "tutorial",
"serviceConnectDefaults": {
"namespace": "arn:aws:servicediscovery:us-west-2:123456789012:namespace/ns-EXAMPLE"
},
"status": "ACTIVE",
"registeredContainerInstancesCount": 0,
"runningTasksCount": 0,
"pendingTasksCount": 0,
"activeServicesCount": 0,
"statistics": [],
"tags": [],
"settings": [],
"capacityProviders": [],
"defaultCapacityProviderStrategy": []
}
],
"failures": []
}
```
1. (opcional) verifique se o namespace foi criado no AWS Cloud Map. É possível usar o Console de gerenciamento da AWS ou a configuração normal da AWS CLI, pois ela é criada no AWS Cloud Map.
Por exemplo, use a AWS CLI:
```
aws servicediscovery get-namespace --id ns-EXAMPLE
```
Resultado:
```
{
"Namespace": {
"Id": "ns-EXAMPLE",
"Arn": "arn:aws:servicediscovery:us-west-2:123456789012:namespace/ns-EXAMPLE",
"Name": "service-connect",
"Type": "HTTP",
"Properties": {
"DnsProperties": {
"SOA": {}
},
"HttpProperties": {
"HttpName": "service-connect"
}
},
"CreateDate": 1661749852.422,
"CreatorRequestId": "service-connect"
}
}
```
## Etapa 2: criar o serviço para o servidor
O recurso Service Connect é destinado à interconexão de várias aplicações no Amazon ECS. Pelo menos uma dessas aplicações precisa fornecer um serviço Web ao qual se conectar. Nessa etapa, você criará:
+ A definição de tarefa que usa a imagem oficial do contêiner NGINX não modificada e inclui a configuração do Service Connect.
+ A definição de serviço do Amazon ECS que configura o Service Connect para fornecer a descoberta de serviços e o proxy de malha de serviços para o tráfego desse serviço. A configuração reutiliza o namespace padrão da configuração do cluster para reduzir a quantidade de configuração de serviço feita para cada serviço.
+ O serviço do Amazon ECS. Ele executa uma tarefa usando a definição de tarefa e insere um contêiner adicional para o proxy do Service Connect. O proxy recebe a porta proveniente do mapeamento da porta do contêiner na definição de tarefa. Em uma aplicação cliente executada no Amazon ECS, o proxy na tarefa do cliente recebe as conexões de saída para o nome da porta de definição de tarefa, o nome da descoberta de serviços ou o nome do alias do cliente de serviço e o número da porta do alias do cliente.
**Como criar o serviço Web com o Service Connect**
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 `service-connect-nginx.json` com o conteúdo da seguinte definição de tarefa.
Essa definição de tarefa configura o Service Connect adicionando os parâmetros `name` e `appProtocol` ao mapeamento de portas. O nome da porta torna essa porta mais identificável na configuração do serviço quando várias portas são usadas. O nome da porta também é usado por padrão como o nome detectável para uso por outras aplicações no namespace.
A definição da tarefa contém o perfil do IAM da tarefa, pois o serviço tem o ECS Exec ativado.
**Importante**
Essa definição de tarefa usa a `logConfiguration` para enviar a saída do nginx de `stdout` e `stderr` para o Amazon CloudWatch Logs. Esse perfil de execução de tarefas não tem as permissões extras necessárias para a criação do grupo de logs do CloudWatch Logs. Crie o grupo de logs no CloudWatch Logs usando o Console de gerenciamento da AWS ou a AWS CLI. Se você não quiser enviar os logs do nginx para o CloudWatch Logs, poderá remover a `logConfiguration`.
Substitua o ID da Conta da AWS no perfil de execução de tarefas pelo ID da sua Conta da AWS.
```
{
"family": "service-connect-nginx",
"executionRoleArn": "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"taskRoleArn": "arn:aws:iam::123456789012:role/ecsTaskRole",
"networkMode": "awsvpc",
"containerDefinitions": [
{
"name": "webserver",
"image": "public.ecr.aws/docker/library/nginx:latest",
"cpu": 100,
"portMappings": [
{
"name": "nginx",
"containerPort": 80,
"protocol": "tcp",
"appProtocol": "http"
}
],
"essential": true,
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/service-connect-nginx",
"awslogs-region": "region",
"awslogs-stream-prefix": "nginx"
}
}
}
],
"cpu": "256",
"memory": "512"
}
```
1. Registre a definição de tarefa usando o arquivo `service-connect-nginx.json`:
```
aws ecs register-task-definition --cli-input-json file://service-connect-nginx.json
```
1. Crie um serviço:
1. Crie um arquivo denominado `service-connect-nginx-service.json` com o conteúdo do serviço do Amazon 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 ao Service Connect. Os `securityGroups` e as `subnets` devem pertencer a uma VPC que tenha os requisitos para usar o Amazon ECS. É possível obter os IDs de grupos de segurança e sub-redes no console da Amazon VPC.
Esse serviço configura o Service Connect adicionando o parâmetro `serviceConnectConfiguration`. O namespace não é necessário porque o cluster tem um namespace padrão configurado. As aplicações cliente em execução no ECS no namespace se conectam a esse serviço usando o `portName` e a porta no `clientAliases`. Por exemplo, esse serviço pode ser acessado usando `http://nginx:80/`, pois o nginx fornece uma página de boas-vindas no `/` do local raiz. Aplicações externas que não estão sendo executadas no Amazon ECS ou não estão no mesmo namespace podem acessar essa aplicação por meio do proxy do Service Connect usando o endereço IP da tarefa e o número da porta da definição de tarefa. Na configuração do `tls`, adicione o `arn` do certificado para `awsPcaAuthorityArn`, `kmsKey` e `roleArn` do perfil do IAM.
Esse serviço usa uma `logConfiguration` para enviar a saída do proxy de conexão do serviço de `stdout` e `stderr` para o Amazon CloudWatch Logs. Esse perfil de execução de tarefas não tem as permissões extras necessárias para a criação do grupo de logs do CloudWatch Logs. Crie o grupo de logs no CloudWatch Logs usando o Console de gerenciamento da AWS ou a AWS CLI. Recomendamos que você crie esse grupo de logs e armazene os logs de proxy no CloudWatch Logs. Se você não quiser enviar os logs do proxy para o CloudWatch Logs, poderá remover a `logConfiguration`.
```
{
"cluster": "tutorial",
"deploymentConfiguration": {
"maximumPercent": 200,
"minimumHealthyPercent": 0
},
"deploymentController": {
"type": "ECS"
},
"desiredCount": 1,
"enableECSManagedTags": true,
"enableExecuteCommand": true,
"launchType": "FARGATE",
"networkConfiguration": {
"awsvpcConfiguration": {
"assignPublicIp": "ENABLED",
"securityGroups": [
"sg-EXAMPLE"
],
"subnets": [
"subnet-EXAMPLE",
"subnet-EXAMPLE",
"subnet-EXAMPLE"
]
}
},
"platformVersion": "LATEST",
"propagateTags": "SERVICE",
"serviceName": "service-connect-nginx-service",
"serviceConnectConfiguration": {
"enabled": true,
"services": [
{
"portName": "nginx",
"clientAliases": [
{
"port": 80
}
],
"tls": {
"issuerCertificateAuthority": {
"awsPcaAuthorityArn": "certificateArn"
},
"kmsKey": "kmsKey",
"roleArn": "iamRoleArn"
}
}
],
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/service-connect-proxy",
"awslogs-region": "region",
"awslogs-stream-prefix": "service-connect-proxy"
}
}
},
"taskDefinition": "service-connect-nginx"
}
```
1. Crie um serviço usando o arquivo `service-connect-nginx-service.json`:
```
aws ecs create-service --cluster tutorial --cli-input-json file://service-connect-nginx-service.json
```
Resultado:
```
{
"service": {
"serviceArn": "arn:aws:ecs:us-west-2:123456789012:service/tutorial/service-connect-nginx-service",
"serviceName": "service-connect-nginx-service",
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/tutorial",
"loadBalancers": [],
"serviceRegistries": [],
"status": "ACTIVE",
"desiredCount": 1,
"runningCount": 0,
"pendingCount": 0,
"launchType": "FARGATE",
"platformVersion": "LATEST",
"platformFamily": "Linux",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/service-connect-nginx:1",
"deploymentConfiguration": {
"deploymentCircuitBreaker": {
"enable": false,
"rollback": false
},
"maximumPercent": 200,
"minimumHealthyPercent": 0
},
"deployments": [
{
"id": "ecs-svc/3763308422771520962",
"status": "PRIMARY",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/service-connect-nginx:1",
"desiredCount": 1,
"pendingCount": 0,
"runningCount": 0,
"failedTasks": 0,
"createdAt": 1661210032.602,
"updatedAt": 1661210032.602,
"launchType": "FARGATE",
"platformVersion": "1.4.0",
"platformFamily": "Linux",
"networkConfiguration": {
"awsvpcConfiguration": {
"assignPublicIp": "ENABLED",
"securityGroups": [
"sg-EXAMPLE"
],
"subnets": [
"subnet-EXAMPLEf",
"subnet-EXAMPLE",
"subnet-EXAMPLE"
]
}
},
"rolloutState": "IN_PROGRESS",
"rolloutStateReason": "ECS deployment ecs-svc/3763308422771520962 in progress.",
"failedLaunchTaskCount": 0,
"replacedTaskCount": 0,
"serviceConnectConfiguration": {
"enabled": true,
"namespace": "service-connect",
"services": [
{
"portName": "nginx",
"clientAliases": [
{
"port": 80
}
]
}
],
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/service-connect-proxy",
"awslogs-region": "us-west-2",
"awslogs-stream-prefix": "service-connect-proxy"
},
"secretOptions": []
}
},
"serviceConnectResources": [
{
"discoveryName": "nginx",
"discoveryArn": "arn:aws:servicediscovery:us-west-2:123456789012:service/srv-EXAMPLE"
}
]
}
],
"roleArn": "arn:aws:iam::123456789012:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS",
"version": 0,
"events": [],
"createdAt": 1661210032.602,
"placementConstraints": [],
"placementStrategy": [],
"networkConfiguration": {
"awsvpcConfiguration": {
"assignPublicIp": "ENABLED",
"securityGroups": [
"sg-EXAMPLE"
],
"subnets": [
"subnet-EXAMPLE",
"subnet-EXAMPLE",
"subnet-EXAMPLE"
]
}
},
"schedulingStrategy": "REPLICA",
"enableECSManagedTags": true,
"propagateTags": "SERVICE",
"enableExecuteCommand": true
}
}
```
A `serviceConnectConfiguration` que você forneceu aparece na primeira *implantação* da saída. À medida que você faz alterações no serviço do ECS de maneiras que precisam fazer alterações nas tarefas, uma nova implantação é criada pelo Amazon ECS.
## Etapa 3: verificar se você pode se conectar
Para verificar se o Service Connect está configurado e funcionando, siga estas etapas para se conectar ao serviço Web em uma aplicação externa. Em seguida, consulte as métricas adicionais que o proxy do Service Connect cria no CloudWatch.
**Para se conectar ao serviço Web em uma aplicação externa**
+ Conecte-se ao endereço IP da tarefa e à porta do contêiner usando o endereço IP da tarefa
Use a AWS CLI para obter o ID da tarefa, usando o `aws ecs list-tasks --cluster tutorial`.
Se suas sub-redes e seu grupo de segurança permitirem tráfego da Internet pública na porta da definição da tarefa, será possível se conectar ao IP público no seu computador. No entanto, o IP público não está disponível em “describe-tasks”. Portanto, as etapas envolvem acessar o Console de gerenciamento da AWS ou a AWS CLI do Amazon EC2 para obter os detalhes da interface de rede elástica.
Nesse exemplo, uma instância do Amazon EC2 na mesma VPC usa o IP privado da tarefa. A aplicação é nginx, mas o cabeçalho `server: envoy` mostra que o proxy do Service Connect é usado. O proxy do Service Connect recebe a porta do contêiner vindo da definição de tarefa.
```
$ curl -v 10.0.19.50:80/
* Trying 10.0.19.50:80...
* Connected to 10.0.19.50 (10.0.19.50) port 80 (#0)
> GET / HTTP/1.1
> Host: 10.0.19.50
> User-Agent: curl/7.79.1
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
< server: envoy
< date: Tue, 23 Aug 2022 03:53:06 GMT
< content-type: text/html
< content-length: 612
< last-modified: Tue, 16 Apr 2019 13:08:19 GMT
< etag: "5cb5d3c3-264"
< accept-ranges: bytes
< x-envoy-upstream-service-time: 0
<
Welcome to nginx!
Welcome to nginx!
If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.
For online documentation and support please refer to
nginx.org.
Commercial support is available at
nginx.com.
Thank you for using nginx.
```
**Para visualizar as métricas do Service Connect**
O proxy do Service Connect cria métricas de aplicações (conexão HTTP, HTTP2, gRPC ou TCP) nas métricas do CloudWatch. Ao usar o console do CloudWatch, consulte as dimensões de métricas adicionais de **DiscoveryName**, (**DiscoveryName, ServiceName, ClusterName**), **TargetDiscoveryName** e (**TargetDiscoveryName, ServiceName, ClusterName**) no namespace do Amazon ECS. Para obter mais informações sobre essas métricas e dimensões, consulte [Visualizar métricas disponíveis](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/viewing_metrics_with_cloudwatch.html) no Guia do usuário do Amazon CloudWatch Logs.
# Uso da descoberta de serviços para conectar serviços do Amazon ECS com nomes DNS
O serviço do Amazon ECS pode ser opcionalmente configurado para usar a descoberta de serviço do Amazon ECS. A descoberta de serviço usa ações de API do AWS Cloud Map para gerenciar namespaces HTTP e DNS para serviços do Amazon ECS. Para obter mais informações, consulte [O que é o AWS Cloud Map?](https://docs.aws.amazon.com/cloud-map/latest/dg/Welcome.html) no *Guia do desenvolvedor do AWS Cloud Map*.
A descoberta de serviço está disponível nas seguintes regiões da AWS:
| Nome da Região | Região |
| --- | --- |
| Leste dos EUA (Norte da Virgínia) | us-east-1 |
| Leste dos EUA (Ohio) | us-east-2 |
| Oeste dos EUA (N. da Califórnia) | us-west-1 |
| Oeste dos EUA (Oregon) | us-west-2 |
| África (Cidade do Cabo) | af-south-1 |
| Ásia-Pacífico (Hong Kong) | ap-east-1 |
| Ásia-Pacífico (Taipei) | ap-east-2 |
| Ásia-Pacífico (Mumbai) | ap-south-1 |
| Ásia-Pacífico (Hyderabad) | ap-south-2 |
| Ásia-Pacífico (Tóquio) | ap-northeast-1 |
| Ásia-Pacífico (Seul) | ap-northeast-2 |
| Ásia-Pacífico (Osaka) | ap-northeast-3 |
| Ásia-Pacífico (Singapura) | ap-southeast-1 |
| Ásia-Pacífico (Sydney) | ap-southeast-2 |
| Ásia-Pacífico (Jacarta) | ap-southeast-3 |
| Ásia-Pacífico (Melbourne) | ap-southeast-4 |
| Ásia-Pacífico (Malásia) | ap-southeast-5 |
| Ásia-Pacífico (Nova Zelândia) | ap-southeast-6 |
| Ásia-Pacífico (Tailândia) | ap-southeast-7 |
| Canadá (Central) | ca-central-1 |
| Oeste do Canadá (Calgary) | ca-west-1 |
| China (Pequim) | cn-north-1 |
| China (Ningxia) | cn-northwest-1 |
| Europa (Frankfurt) | eu-central-1 |
| Europa (Zurique) | eu-central-2 |
| Europa (Irlanda) | eu-west-1 |
| Europa (Londres) | eu-west-2 |
| Europa (Paris) | eu-west-3 |
| Europa (Milão) | eu-south-1 |
| Europa (Estocolmo) | eu-north-1 |
| Israel (Tel Aviv) | il-central-1 |
| Europa (Espanha) | eu-south-2 |
| Oriente Médio (Emirados Árabes Unidos) | me-central-1 |
| México (Central) | mx-central-1 |
| Oriente Médio (Barém) | me-south-1 |
| América do Sul (São Paulo) | sa-east-1 |
| AWS GovCloud (Leste dos EUA) | us-gov-east-1 |
| AWS GovCloud (Oeste dos EUA) | us-gov-west-1 |
## Conceitos de descoberta de serviço
A descoberta de serviço consiste nos seguintes componentes:
+ **Namespace de descoberta de serviço**: grupo lógico de serviços de descoberta de serviço que compartilham o mesmo nome de domínio, como `example.com`, que é onde você deseja rotear o tráfico. É possível criar um namespace com uma chamada para o comando `aws servicediscovery create-private-dns-namespace` ou no console do Amazon ECS. É possível usar o comando `aws servicediscovery list-namespaces` para exibir as informações resumidas sobre os namespaces criados pela conta atual. Para obter mais informações sobre os comandos de descoberta de serviço, consulte `[create-private-dns-namespace](https://docs.aws.amazon.com/cli/latest/reference/servicediscovery/create-private-dns-namespace.html)` e `[list-namespaces](https://docs.aws.amazon.com/cli/latest/reference/servicediscovery/list-namespaces.html)` no *Guia de referência da AWS CLI do AWS Cloud Map (descoberta de serviço)*.
+ **Serviço de descoberta de serviço**: existe no namespace de descoberta de serviço e consiste no nome do serviço e na configuração do DNS para o namespace. Ele fornece os seguintes componentes principais:
+ **Service registry (Registro do serviço)**: permite pesquisar um serviço por meio de DNS ou ações de API do AWS Cloud Map disponíveis que podem ser usados para se conectar ao serviço.
+ **Instância de descoberta de serviço**: existe no serviço de descoberta de serviço e consiste nos atributos associados a cada serviço do Amazon ECS no diretório de serviços.
+ **Atributos de instância**: os metadados a seguir são adicionados como atributos personalizados para cada serviço do Amazon ECS configurado para usar a descoberta de serviço:
+ **`AWS_INSTANCE_IPV4`**: para um registro `A`, o endereço IPv4 que o Route 53 retorna em resposta a consultas de DNS e que o AWS Cloud Map retorna ao descobrir detalhes da instância, por exemplo, `192.0.2.44`.
+ **`AWS_INSTANCE_IPV6`**: para um registro `AAAA`, o endereço IPv6 que Route 53 retorna em resposta a consultas ao DNS e que AWS Cloud Map retorna ao descobrir detalhes da instância, por exemplo, ` 2001:0db8:85a3:0000:0000:abcd:0001:2345`. `AWS_INSTANCE_IPv4` e `AWS_INSTANCE_IPv6` são adicionados aos serviços de pilha dupla do Amazon ECS. Apenas `AWS_INSTANCE_IPv6` é adicionado para serviços somente IPv6 do Amazon ECS.
+ **`AWS_INSTANCE_PORT`** – o valor da porta associado ao serviço de descoberta de serviço.
+ **`AVAILABILITY_ZONE`** – a zona de disponibilidade na qual a tarefa foi iniciada. Para tarefas que usam o EC2, essa é a zona de disponibilidade na qual a instância de contêiner existe. Para tarefas que usam o Fargate, essa é a zona de disponibilidade na qual a interface de rede elástica existe.
+ **`REGION`** – a região em que a tarefa existe.
+ **`ECS_SERVICE_NAME`** – o nome do serviço do Amazon ECS ao qual a tarefa pertence.
+ **`ECS_CLUSTER_NAME`** – o nome do cluster do Amazon ECS ao qual a tarefa pertence.
+ **`EC2_INSTANCE_ID`** – o ID da instância de contêiner na qual a tarefa foi posicionada. Esse atributo personalizado não será adicionado se a tarefa estiver usando o Fargate.
+ **`ECS_TASK_DEFINITION_FAMILY`** – a família de definições de tarefa que a tarefa está usando.
+ **`ECS_TASK_SET_EXTERNAL_ID`**: se um conjunto de tarefas for criado para uma implantação externa e for associado a um registro de descoberta de serviço, o atributo `ECS_TASK_SET_EXTERNAL_ID` conterá o ID externo do conjunto de tarefas.
+ **Verificações de integridade do Amazon ECS**: o Amazon ECS executa verificações de integridade periódicas em nível de contêiner. Se não passar na verificação de integridade, o endpoint é removido do roteamento de DNS e marcado como não íntegro.
## Considerações sobre descoberta de serviço
As seguintes informações devem ser considerada ao usar a descoberta de serviço:
+ A descoberta de serviços é compatível com as tarefas no Fargate se você está usando a versão 1.1.0 ou posterior da plataforma. Para obter mais informações, consulte [Versões da plataforma do Fargate para o Amazon ECS](platform-fargate.md).
+ Os serviços configurados para usar a descoberta de serviços têm um limite de 1.000 tarefas por serviço. Isso se deve a uma cota de serviço do Route 53.
+ O fluxo de trabalho Create Service (Criar serviço) no console do Amazon ECS é compatível apenas com o registro de serviços em namespaces DNS privados. Quando um namespace DNS privado do AWS Cloud Map for criado, será criada automaticamente uma zona hospedada privada do Route 53.
+ Os atributos DNS da VPC devem ser configurados para resoluções DNS bem-sucedidas. Para obter informações sobre como configurar os atributos, consulte [Suporte a DNS na sua VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) no *Guia do usuário da Amazon VPC*.
+ O Amazon ECS não oferece suporte ao registro de serviços em namespaces AWS Cloud Map compartilhados.
+ Os registros de DNS criados para um serviço de descobertra de serviço sempre são registrados com o endereço IP privado da tarefa, em vez do endereço IP público, mesmo quando são usados namespaces públicos.
+ A descoberta de serviço exige que as tarefas especifiquem o modo de rede `awsvpc`, `bridge` ou `host` (`none` não é compatível).
+ Se a definição de tarefa de serviço usar o modo de rede `awsvpc`, será possível criar qualquer combinação de registros `A` ou `SRV` para cada tarefa de serviço. Se você usar registros `SRV`, uma porta será necessária. Além disso, você poderá criar registros `AAAA` se o serviço usar sub-redes de pilha dupla. Se o serviço usar sub-redes somente IPv6, não será possível criar registros `A`.
+ Se a definição de tarefa de serviço usa o modo de rede `bridge` ou `host`, o único tipo de registro DNS com suporte é o registro SRV. Crie um registro SRV para cada tarefa de serviço. O registro SRV deve especificar o nome do contêiner e a combinação de portas do contêiner da definição de tarefa.
+ Os registros de DNS de um serviço de descoberta de serviço podem ser consultados na VPC. Eles usam o seguinte formato: `.`.
+ Ao fazer uma consulta ao DNS no nome do serviço, os registros `A` e `AAAA` retornam um conjunto de endereços IP correspondentes às suas tarefas. Os registros `SRV` retornam um conjunto de endereços IP e portas para cada tarefa.
+ Se você tiver oito ou menos registros íntegros, o Route 53 responderá a todas as consultas DNS com todos os registros íntegros.
+ Quando nenhum dos registros estiver íntegro, o Route 53 responderá às consultas DNS com até oito registros não íntegros.
+ É possível configurar a descoberta de serviço para um serviço que esteja atrás de um balanceador de carga, mas o tráfego da descoberta de serviço sempre será roteado para a tarefa, e não para o balanceador de carga.
+ A descoberta de serviço não oferece suporte ao uso de Classic Load Balancers.
+ Convém usar verificações de integridade em nível de contêiner gerenciadas pelo Amazon ECS para o serviço de descoberta de serviços.
+ **HealthCheckCustomConfig**: o Amazon ECS gerencia as verificações de integridade em seu nome. O Amazon ECS usa informações de contêiner e das verificações de integridade, além do estado da tarefa, para atualizar a integridade com o AWS Cloud Map. Isso é especificado pelo uso do parâmetro `--health-check-custom-config` ao ser criado o serviço de descoberta de serviço. Para obter mais informações, consulte [HealthCheckCustomConfig](https://docs.aws.amazon.com/cloud-map/latest/api/API_HealthCheckCustomConfig.html) na *Referência da API do AWS Cloud Map*.
+ Os recursos do AWS Cloud Map criados quando a descoberta de serviço é usada devem ser limpos manualmente.
+ As tarefas e instâncias são registradas como `UNHEALTHY` até que as verificações de integridade do contêiner retornem um valor. Se as verificações de integridade forem aprovadas, o status é atualizado para `HEALTHY`. Se as verificações de integridade do contêiner falharem, o registro da instância da descoberta de serviços é cancelado.
## Preço da descoberta de serviço
Os clientes que usam a descoberta de serviço do Amazon ECS são cobrados pelos recursos do Route 53 e pelas operações da API de descoberta do AWS Cloud Map. Isso envolve os custos de criação de zonas hospedadas do Route 53 e de consultas ao registro do serviço. Para obter mais informações, consulte [Preços do AWS Cloud Map](https://docs.aws.amazon.com/cloud-map/latest/dg/cloud-map-pricing.html) no *Guia do desenvolvedor do AWS Cloud Map*.
O Amazon ECS executa verificações de integridade no nível do contêiner e as expõe às operações da API de verificação de integridade personalizada do AWS Cloud Map. Atualmente, isso é disponibilizado aos clientes sem nenhum custo extra. Se configurar verificações de integridade de rede adicionais para tarefas expostas publicamente, você será cobrado por essas verificações.
# Criar um novo serviço Amazon ECS que usa descoberta de serviços
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
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
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
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 ' Amazon ECS Sample App Amazon ECS Sample App
Congratulations!
Your application is now running on a container in Amazon ECS.
' > /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
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
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
```
# Use o Amazon VPC Lattice para conectar, observar e proteger seus serviços do Amazon ECS
O Amazon VPC Lattice é um serviço totalmente gerenciado de rede de aplicações que possibilita que os clientes do Amazon ECS observem, protejam e monitorem as aplicações criadas em serviços de computação, VPCs e contas da AWS sem precisar de qualquer alteração no código.
O VPC Lattice usa grupos de destino, que são uma coleção de recursos computacionais. Esses destinos executam a aplicação ou serviço e podem ser instâncias do Amazon EC2, endereços IP, funções do Lambda e Application Load Balancers. Ao associarem seus serviços do Amazon ECS a um grupo de destino do VPC Lattice, os clientes agora podem habilitar tarefas do Amazon ECS como destinos IP no VPC Lattice. O Amazon ECS registra automaticamente as tarefas no grupo de destino do VPC Lattice quando as tarefas do serviço registrado são iniciadas.
**nota**
Ao usar cinco configurações de VPC Lattice, seu tempo de implantação pode ser um pouco maior do que ao usar menos configurações.
Uma regra de receptor é usada para encaminhar o tráfego para um grupo de destino especificado quando as condições são atendidas. Um receptor verifica solicitações de conexão usando o protocolo na porta que você configurou. Um serviço roteia solicitações para seus destinos registrados com base nas regras definidas por você ao configurar seu receptor.
O Amazon ECS também substitui automaticamente uma tarefa quando ela não está íntegra de acordo com as verificações de saúde do VPC Lattice. Uma vez associados ao VPC Lattice, os clientes do Amazon ECS também podem aproveitar muitos outros recursos de conectividade entre computadores, segurança e observabilidade no VPC Lattice, como conexão a serviços entre clusters, VPCs e contas com AWS Resource Access Manager, integração IAM para autorização e autenticação e recursos avançados de gerenciamento de tráfego.
Os clientes do Amazon ECS podem se beneficiar do VPC Lattice conforme mostrado a seguir.
+ Maior produtividade do desenvolvedor: o VPC Lattice aumenta a produtividade do desenvolvedor, permitindo que você se concentre na criação de recursos enquanto o VPC Lattice lida com os desafios de rede, segurança e observabilidade de forma uniforme em todas as plataformas de computação.
+ Melhor postura de segurança: o VPC Lattice permite que seus desenvolvedores autentiquem e protejam facilmente a comunicação entre aplicações e plataformas de computação, apliquem criptografia em trânsito e apliquem controles de acesso granulares com políticas de autenticação do VPC Lattice. Isso permite que você adote uma postura de segurança mais forte que atenda aos principais requisitos regulatórios e de conformidade do setor.
+ Escalabilidade e resiliência aprimoradas de aplicações: o VPC Lattice permite criar uma rede de aplicações implantadas com recursos como roteamento, autenticação, autorização e monitoramento baseados em caminhos, cabeçalhos e métodos. Esses benefícios são fornecidos sem sobrecarga de recursos nas workloads e podem suportar implantações de vários clusters que geram milhões de solicitações por segundo sem adicionar latência significativa.
+ Flexibilidade de implantação com infraestrutura heterogênea: o VPC Lattice fornece recursos consistentes em todos os serviços de computação, como Amazon ECS, Fargate, Amazon EC2, Amazon EKS e Lambda e permite à sua organização a flexibilidade de escolher a infraestrutura adequada para cada aplicação.
## Como o VPC Lattice funciona com outros serviços do Amazon ECS
Usar o VPC Lattice com o Amazon ECS pode mudar a forma como você usa outros serviços do Amazon ECS, enquanto alguns permanecem os mesmos.
**Application Load Balancers**
Não é mais necessário criar um Application Load Balancer específico para usar com o tipo de grupo de destino do Application Load Balancer no VPC Lattice, que então se vincula ao serviço do Amazon ECS. Em vez disso, basta configurar o serviço do Amazon ECS com um grupo de destino do VPC Lattice. Você também pode optar por usar o Application Load Balancer com o Amazon ECS ao mesmo tempo.
**Implantações contínuas do Amazon ECS**
Somente as implantações contínuas do Amazon ECS funcionam com o VPC Lattice, e o Amazon ECS insere tarefas com segurança e as remove dos serviços durante a implantação. Não há suporte a implantação de código nem a implantações azuis/verdes.
Para saber mais sobre o VPC Lattice, consulte o [Guia do usuário do Amazon VPC Lattice](https://docs.aws.amazon.com/vpc-lattice/latest/ug/what-is-vpc-lattice.html).
# Criar um serviço que usa o VPC Lattice
Você pode usar o Console de gerenciamento da AWS ou o AWS CLI para criar um serviço com o VPC Lattice.
## Pré-requisitos
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 a AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html).
**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).
+ 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).
## Criar um serviço que usa o VPC Lattice com o Console de gerenciamento da AWS
Siga estas etapas para criar um serviço com o VPC Lattice usando o Console de gerenciamento da AWS.
1. Abra o console em [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).
1. Na página de navegação, escolha **Clusters**.
1. Na página **Clusters**, selecione o cluster no qual o serviço será criado.
1. Na guia **Services** (Serviços), escolha **Create** (Criar).
Se você nunca criou um serviço antes, siga as etapas encontradas em [Criar um serviço do Amazon ECS usando o console](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html) e continue com estas etapas ao chegar à seção VPC Lattice.
1. Selecione o botão para **Ativar o VPC Lattice**.
1. Para usar um perfil existente, em **Perfil da infraestrutura do ECS para Amazon ECS**, escolha um que você já criou para usar ao criar o grupo de destino da VPC Lattice. Para criar um novo perfil, selecione **Criar perfil da infraestrutura do ECS**.
1. Escolha a **VPC**.
A **VPC** depende do modo de rede que você selecionou ao registrar sua definição de tarefa. Se você usar o modo `host` ou `network` com o EC2, escolha sua VPC.
Para o modo `awsvpc`, a VPC será selecionada automaticamente com base na VPC que você escolheu em **Rede** e não poderá ser alterada.
1. Em **Grupos de destino**, escolha um ou mais grupos de destino. Escolha pelo menos um grupo de destino e, no máximo, cinco. Escolha **Adicionar grupo de destino** para adicionar mais grupos de destino. Escolha o **Nome da porta**, o **Protocolo** e a **Porta** para cada grupo de destino escolhido. Para excluir um grupo de destino, escolha **Remover**.
**nota**
Se desejar adicionar grupos de destino existentes, será necessário usar a AWS CLI. Para obter instruções sobre como adicionar grupos de destino usando o AWS CLI, consulte [register-targets](https://docs.aws.amazon.com/cli/latest/reference/vpc-lattice/register-targets.html) na *Referência do AWS Command Line Interface*.
Embora um serviço do VPC Lattice possa ter vários grupos de destino, cada grupo de destino só pode ser adicionado a um serviço.
Para criar um serviço em uma configuração somente IPv6, escolha grupos de destino com um tipo de endereço IP `IPv6`.
1. Nesse ponto, navegue até o console do VPC Lattice para continuar a configuração. É aqui que você inclui seus novos grupos de destino na ação padrão do receptor ou nas regras de um serviço do VPC Lattice existente.
Para obter mais informações, consulte [Regras de receptor para o serviço do VPC Lattice](https://docs.aws.amazon.com/vpc-lattice/latest/ug/listener-rules.html).
**Importante**
É necessário permitir o prefixo `vpc-lattice` da regra de entrada em seu grupo de segurança. Caso contrário, as tarefas e verificações de integridade poderão falhar.
## Criar um serviço que usa o VPC Lattice com a AWS CLI
Use a AWS CLI para criar um serviço com o VPC Lattice. Substitua cada *espaço reservado para entrada do usuário* por suas próprias informações.
1. Crie um arquivo de configuração de grupo de destino. O exemplo a seguir é denominado `tg-config.json`
```
{
"ipAddressType": "IPV4",
"port": 443,
"protocol": "HTTPS",
"protocolVersion": "HTTP1",
"vpcIdentifier": "vpc-f1663d9868EXAMPLE"
}
```
1. Use o comando a seguir para criar um grupo de destino do VPC Lattice.
```
aws vpc-lattice create-target-group \
--name my-lattice-target-group-ip \
--type IP \
--config file://tg-config.json
```
**nota**
Para criar um serviço em uma configuração somente IPv6, crie grupos de destino com um tipo de endereço IP `IPv6`. Para obter mais informações, consulte [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/vpc-lattice/create-target-group.html) na *Referência de comandos da AWS CLI*.
Resultado do exemplo:
```
{
"arn": "arn:aws:vpc-lattice:us-east-2:123456789012:targetgroup/tg-0eaa4b9ab4EXAMPLE",
"config": {
"healthCheck": {
"enabled": true,
"healthCheckIntervalSeconds": 30,
"healthCheckTimeoutSeconds": 5,
"healthyThresholdCount": 5,
"matcher": {
"httpCode": "200"
},
"path": "/",
"protocol": "HTTPS",
"protocolVersion": "HTTP1",
"unhealthyThresholdCount": 2
},
"ipAddressType": "IPV4",
"port": 443,
"protocol": "HTTPS",
"protocolVersion": "HTTP1",
"vpcIdentifier": "vpc-f1663d9868EXAMPLE"
},
"id": "tg-0eaa4b9ab4EXAMPLE",
"name": "my-lattice-target-group-ip",
"status": "CREATE_IN_PROGRESS",
"type": "IP"
}
```
1. O arquivo JSON a seguir, chamado *ecs-service-vpc-lattice.json*, é um exemplo usado para anexar um serviço do Amazon ECS a um grupo de destino do VPC Lattice. O `portName` no exemplo abaixo é o mesmo que você definiu no campo `name` da propriedade `portMappings` da definição da sua tarefa.
```
{
"serviceName": "ecs-service-vpc-lattice",
"taskDefinition": "ecs-task-def",
"vpcLatticeConfigurations": [
{
"targetGroupArn": "arn:aws:vpc-lattice:us-west-2:123456789012:targetgroup/tg-0eaa4b9ab4EXAMPLE",
"portName": "testvpclattice",
"roleArn": "arn:aws:iam::123456789012:role/ecsInfrastructureRoleVpcLattice"
}
],
"desiredCount": 5,
"role": "ecsServiceRole"
}
```
Use o comando a seguir para criar um serviço do Amazon ECS e anexá-lo ao grupo de destino do VPC Lattice usando o exemplo de json acima.
```
aws ecs create-service \
--cluster clusterName \
--serviceName ecs-service-vpc-lattice \
--cli-input-json file://ecs-service-vpc-lattice.json
```
**nota**
A VPC Lattice não é compatível com o Amazon ECS Anywhere.