```
# Configuración de Amazon ECS Service Connect con la AWS CLI
Puede crear un servicio de Amazon ECS para una tarea de Fargate que utilice Service Connect a través de la AWS CLI.
**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 continuación, se indican los requisitos previos de Service Connect:
+ Compruebe que 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).
+ 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.
+ Tiene una VPC, una subred, una tabla de enrutamiento y un grupo de seguridad creados para utilizarlos. Para obtener más información, consulte [Creación de una nube virtual privada](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ Tiene un rol de ejecución de tareas con el nombre `ecsTaskExecutionRole` y la política administrada `AmazonECSTaskExecutionRolePolicy` está asociada al rol. Este rol permite a Fargate escribir los registros de aplicaciones de NGINX y los registros de proxy de Service Connect en los registros de Amazon CloudWatch. Para obtener más información, consulte [Creación del rol de de ejecución de tareas](task_execution_IAM_role.md#create-task-execution-role).
## Paso 1: Crear el clúster
Siga los pasos a continuación para crear el clúster y el espacio de nombres de Amazon ECS.
**Para crear un clúster de Amazon ECS y espacio de nombres de AWS Cloud Map**
1. Cree un clúster de Amazon ECS con el nombre `tutorial` para su utilización. El parámetro `--service-connect-defaults` establece el espacio de nombres predeterminado del clúster. En el resultado del ejemplo, no existe un espacio de nombres de AWS Cloud Map con nombre `service-connect` en esta cuenta y Región de AWS, por lo tanto, Amazon ECS crea el espacio de nombres. El espacio de nombres se crea en AWS Cloud Map en la cuenta y es visible con todos los demás espacios de nombres, así que debe usar un nombre que indique el propósito.
```
aws ecs create-cluster --cluster-name tutorial --service-connect-defaults namespace=service-connect
```
Salida:
```
{
"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. Compruebe que se haya creado el clúster:
```
aws ecs describe-clusters --clusters tutorial
```
Salida:
```
{
"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) Compruebe que el espacio de nombres se haya creado en AWS Cloud Map. Puede usar la Consola de administración de AWS o la configuración normal de la AWS CLI, ya que esto se crea en AWS Cloud Map.
Por ejemplo, use la AWS CLI:
```
aws servicediscovery get-namespace --id ns-EXAMPLE
```
Salida:
```
{
"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"
}
}
```
## Paso 2: crear el servicio para el servidor
La característica de Service Connect está diseñada para interconectar varias aplicaciones en Amazon ECS. Al menos una de esas aplicaciones debe proporcionar un servicio web al cual conectarse. En este paso, creará:
+ La definición de tarea que utiliza la imagen del contenedor oficial de NGINX sin modificar e incluye la configuración de Service Connect.
+ La definición de servicio de Amazon ECS que configura Service Connect para proporcionar la detección de servicios y el proxy de malla de servicios para el tráfico a este servicio. La configuración reutiliza el espacio de nombres predeterminado de la configuración del clúster para reducir la cantidad de configuración que se realiza para cada servicio.
+ El servicio de Amazon ECS. Ejecuta una tarea mediante la definición de tarea e inserta un contenedor adicional para el proxy de Service Connect. El proxy escucha en el puerto desde la asignación de puertos del contenedor de la definición de la tarea. En una aplicación de cliente que se ejecuta en Amazon ECS, el proxy de la tarea del cliente escucha las conexiones salientes al nombre del puerto de definición de la tarea, el nombre de detección de servicios o el nombre de alias del cliente de servicio y el número de puerto del alias de cliente.
**Para crear el servicio web con Service Connect**
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 `service-connect-nginx.json` con los contenidos de la siguiente definición de tareas.
Esta definición de tarea configura Service Connect al agregar los parámetros `name` y `appProtocol` a la asignación de puertos. El nombre del puerto hace que este sea más identificable en la configuración del servicio cuando se utilizan varios puertos. El nombre del puerto también se usa de forma predeterminada como nombre detectable para que lo usen otras aplicaciones en el espacio de nombres.
La definición de la tarea contiene el rol de IAM de la tarea porque el servicio tiene habilitado ECS Exec.
**importante**
Esta definición de tarea usa una `logConfiguration` para enviar la salida de nginx desde `stdout` y `stderr` hacia los registros de Amazon CloudWatch. Este rol de ejecución de tareas no tiene los permisos adicionales necesarios para crear el grupo de registro de registros de CloudWatch. Cree el grupo de registro de registros de CloudWatch mediante la Consola de administración de AWS o la AWS CLI. Si no desea enviar los registros de nginx a registros de CloudWatch, puede eliminar la `logConfiguration`.
Sustituya el ID de la Cuenta de AWS en el rol de ejecución de la tarea por el ID de su Cuenta de 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 la definición de tareas mediante el archivo `service-connect-nginx.json`:
```
aws ecs register-task-definition --cli-input-json file://service-connect-nginx.json
```
1. Cree un servicio:
1. Cree un archivo llamado `service-connect-nginx-service.json` con el contenido del servicio de Amazon 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 Service Connect. Los `securityGroups` y las `subnets` deben pertenecer a una VPC que cumpla los requisitos de uso de Amazon ECS. Puede obtener los ID de subred y grupos de seguridad en la consola de Amazon VPC.
Este servicio configura Service Connect al agregar el parámetro `serviceConnectConfiguration`. El espacio de nombres no es obligatorio porque el clúster tiene configurado un espacio de nombres predeterminado. Las aplicaciones de cliente que se ejecutan en ECS en el espacio de nombres se conectan a este servicio mediante `portName` y el puerto de `clientAliases`. Por ejemplo, se puede acceder a este servicio con `http://nginx:80/`, ya que nginx proporciona una página de bienvenida en la ubicación raíz `/`. Las aplicaciones externas que no se ejecutan en Amazon ECS o que no están en el mismo espacio de nombres pueden acceder a esta aplicación a través del proxy de Service Connect mediante la dirección IP de la tarea y el número de puerto de la definición de la tarea. Para su configuración de `tls`, agregue el certificado `arn` para su `awsPcaAuthorityArn` su `kmsKey`, y `roleArn` de su rol de IAM.
Este servicio utiliza una `logConfiguration` para enviar la salida del proxy de Service Connect desde `stdout` y `stderr` hacia los registros de Amazon CloudWatch. Este rol de ejecución de tareas no tiene los permisos adicionales necesarios para crear el grupo de registro de registros de CloudWatch. Cree el grupo de registro de registros de CloudWatch mediante la Consola de administración de AWS o la AWS CLI. Le recomendamos que cree este grupo de registro y almacene los registros de proxy en registros de CloudWatch. Si no desea enviar los registros de proxy a registros de CloudWatch, puede eliminar la `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. Cree un servicio mediante el archivo `service-connect-nginx-service.json`:
```
aws ecs create-service --cluster tutorial --cli-input-json file://service-connect-nginx-service.json
```
Salida:
```
{
"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
}
}
```
La `serviceConnectConfiguration` que ha proporcionado aparece dentro de la primera *implementación* de la salida. A medida que hace cambios en el servicio de ECS de manera que es necesario realizar cambios en las tareas, Amazon ECS crea una nueva implementación.
## Paso 3: Comprobar que puede conectarse
Para comprobar que Service Connect está configurado y funciona, siga estos pasos para conectarse al servicio web desde una aplicación externa. A continuación, consulte las métricas adicionales en CloudWatch que crea el proxy de Service Connect.
**Para conectarse al servicio web desde una aplicación externa**
+ Conéctese a la dirección IP de la tarea y al puerto del contenedor mediante la dirección IP de la tarea
Utilice la AWS CLI para obtener el ID de la tarea, mediante el `aws ecs list-tasks --cluster tutorial`.
Si las subredes y el grupo de seguridad permiten el tráfico de la Internet pública en el puerto de la definición de la tarea, puede conectarse a la IP pública desde su equipo. Sin embargo, la IP pública no está disponible en “describe-tasks”, por lo que los pasos incluyen ir a la Consola de administración de AWS o la AWS CLI de Amazon EC2 para obtener los detalles de la interfaz de red elástica.
En este ejemplo, una instancia de Amazon EC2 de la misma VPC usa la IP privada de la tarea. La aplicación es nginx, pero el encabezado `server: envoy` muestra que se utiliza el proxy de Service Connect. El proxy de Service Connect escucha el puerto del contenedor de la definición de la tarea.
```
$ 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 ver las métricas de Service Connect**
El proxy de Service Connect crea métricas de aplicaciones (conexión HTTP, HTTP2, gRPC o TCP) en las métricas de CloudWatch. Cuando utilice la consola de CloudWatch, consulte las dimensiones de métricas adicionales de **DiscoveryName**, (**DiscoveryName, ServiceName, ClusterName**), **TargetDiscoveryName** y (**TargetDiscoveryName, ServiceName, ClusterName**) en el espacio de nombres de Amazon ECS. Para obtener más información acerca de estas métricas y sus dimensiones, consulte [View Available Metrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/viewing_metrics_with_cloudwatch.html) en la Guía del usuario de Registros de Amazon CloudWatch.
# Uso de la detección de servicios para conectar los servicios de Amazon ECS con nombres de DNS
Su servicio de Amazon ECS también puede configurarse para utilizar la detección de servicios de Amazon ECS. La detección de servicios utiliza acciones de la API de AWS Cloud Map para administrar los espacios de nombres de DNS y HTTP para sus servicios de Amazon ECS. Para obtener más información, consulte [¿Qué es AWS Cloud Map?](https://docs.aws.amazon.com/cloud-map/latest/dg/Welcome.html) en la *Guía para desarrolladores de AWS Cloud Map*.
La detección de servicios se encuentra disponible en las siguientes regiones de AWS:
| Nombre de la región | Región |
| --- | --- |
| Este de EE. UU. (Norte de Virginia) | us-east-1 |
| Este de EE. UU. (Ohio) | us-east-2 |
| Oeste de EE. UU. (Norte de California) | us-west-1 |
| Oeste de EE. UU. (Oregón) | us-west-2 |
| África (Ciudad del Cabo) | af-south-1 |
| Asia-Pacífico (Hong Kong) | ap-east-1 |
| Asia-Pacífico (Taipéi) | ap-east-2 |
| Asia-Pacífico (Mumbai) | ap-south-1 |
| Asia-Pacífico (Hyderabad) | ap-south-2 |
| Asia-Pacífico (Tokio) | ap-northeast-1 |
| Asia-Pacífico (Seúl) | ap-northeast-2 |
| Asia-Pacífico (Osaka) | ap-northeast-3 |
| Asia-Pacífico (Singapur) | ap-southeast-1 |
| Asia-Pacífico (Sídney) | ap-southeast-2 |
| Asia-Pacífico (Yakarta) | ap-southeast-3 |
| Asia-Pacífico (Melbourne) | ap-southeast-4 |
| Asia-Pacífico (Malasia) | ap-southeast-5 |
| Asia-Pacífico (Nueva Zelanda) | ap-southeast-6 |
| Asia-Pacífico (Tailandia) | ap-southeast-7 |
| Canadá (centro) | ca-central-1 |
| Oeste de Canadá (Calgary) | ca-west-1 |
| China (Pekín) | cn-north-1 |
| China (Ningxia) | cn-northwest-1 |
| Europe (Frankfurt) | eu-central-1 |
| Europa (Zúrich) | eu-central-2 |
| Europa (Irlanda) | eu-west-1 |
| Europa (Londres) | eu-west-2 |
| Europa (París) | eu-west-3 |
| Europa (Milán) | eu-south-1 |
| Europa (Estocolmo) | eu-north-1 |
| Israel (Tel Aviv) | il-central-1 |
| Europa (España) | eu-south-2 |
| Medio Oriente (EAU) | me-central-1 |
| México (centro) | mx-central-1 |
| Medio Oriente (Baréin) | me-south-1 |
| América del Sur (São Paulo) | sa-east-1 |
| AWS GovCloud (Este de EE. UU.) | us-gov-east-1 |
| AWS GovCloud (Oeste de EE. UU.) | us-gov-west-1 |
## Conceptos sobre la detección de servicios
La detección de servicios consta de los siguientes componentes:
+ **Espacio de nombres de detección de servicios**: grupo lógico de servicios de detección de servicios que comparten el mismo nombre de dominio, como `example.com`, que es adónde quiere dirigir el tráfico. Puede crear un espacio de nombres con una llamada al comando `aws servicediscovery create-private-dns-namespace` o en la consola de Amazon ECS. Puede utilizar el comando `aws servicediscovery list-namespaces` para ver la información de resumen de los espacios de nombres creados por la cuenta corriente. Para obtener más información acerca de los comandos de detección de servicios, consulte `[create-private-dns-namespace](https://docs.aws.amazon.com/cli/latest/reference/servicediscovery/create-private-dns-namespace.html)` y `[list-namespaces](https://docs.aws.amazon.com/cli/latest/reference/servicediscovery/list-namespaces.html)` en la *Guía de referencia de AWS Cloud Map (detección de servicios) de la AWS CLI*.
+ **Service discovery service** (Servicio de detección de servicios): existe dentro del espacio de nombres de detección de servicios y consta del nombre del servicio y la configuración de DNS para el espacio de nombres. Proporciona los siguientes componentes principales:
+ **Registro de servicios**: permite buscar un servicio mediante DNS o con las acciones de la API de AWS Cloud Map y recuperar uno o varios puntos de enlace disponibles que se pueden utilizar para conectarse al servicio.
+ **Service discovery instance** (Instancia de detección de servicios): existe dentro del servicio de detección de servicios y consiste en atributos asociados a cada servicio de Amazon ECS del directorio de servicios.
+ **Instance attributes** (Atributos de instancia): se agregan los siguientes metadatos como atributos personalizados para cada servicio de Amazon ECS que se configura para utilizar la detección de servicios:
+ **`AWS_INSTANCE_IPV4`**: en el caso de un registro `A`, la dirección IPv4 que Route 53 devuelve en respuesta a consultas de DNS y AWS Cloud Map devuelve al detectar detalles de la instancia, por ejemplo, `192.0.2.44`.
+ **`AWS_INSTANCE_IPV6`**: en el caso de un registro `AAAA`, la dirección IPv6 que Route 53 devuelve en respuesta a consultas de DNS y AWS Cloud Map devuelve al detectar detalles de la instancia; por ejemplo, ` 2001:0db8:85a3:0000:0000:abcd:0001:2345`. Tanto `AWS_INSTANCE_IPv4` como `AWS_INSTANCE_IPv6` se agregan para los servicios de doble pila de Amazon ECS. Solo `AWS_INSTANCE_IPv6` se agrega para los servicios de solo IPv6 de Amazon ECS.
+ **`AWS_INSTANCE_PORT`** – el valor del puerto asociado al servicio de detección de servicios.
+ **`AVAILABILITY_ZONE`** – la zona de disponibilidad en la que se lanzó la tarea. En el caso de las tareas que usan EC2, esta es la zona de disponibilidad en la que existe la instancia de contenedor. En el caso de las tareas que utilizan Fargate, esta es la zona de disponibilidad en la que existe la interfaz de red elástica.
+ **`REGION`** – la región en la que existe la tarea.
+ **`ECS_SERVICE_NAME`** – el nombre del servicio de Amazon ECS al que pertenece la tarea.
+ **`ECS_CLUSTER_NAME`** – el nombre del clúster de Amazon ECS al que pertenece la tarea.
+ **`EC2_INSTANCE_ID`** – el ID de la instancia de contenedor en el que se colocó la tarea. Este atributo personalizado no se agrega si la tarea utiliza Fargate.
+ **`ECS_TASK_DEFINITION_FAMILY`** – la familia de definición de tareas que utiliza la tarea.
+ **`ECS_TASK_SET_EXTERNAL_ID`**: si se crea un conjunto de tareas para una implementación externa y se asocia a un registro de detección de servicios, el atributo `ECS_TASK_SET_EXTERNAL_ID` contendrá el ID externo del conjunto de tareas.
+ **Amazon ECS health checks** (Comprobaciones de estado de Amazon ECS): Amazon ECS realiza comprobaciones de estado periódicas en el nivel de contenedor. Si un punto de enlace no supera la comprobación de estado, se elimina del direccionamiento de DNS y se marca como en mal estado.
## Consideraciones sobre la detección de servicios
Al utilizar la detección de servicios, se debe tener en cuenta lo siguiente:
+ La detección de servicios es compatible con tareas alojadas en Fargate que utilizan la versión 1.1.0 de la plataforma o una posterior. Para obtener más información, consulte [Versiones de la plataforma Fargate para Amazon ECS](platform-fargate.md).
+ Los servicios configurados para utilizar la detección de servicios tienen un límite de 1000 tareas por servicio. Esto se debe a una cuota de servicio de Route 53.
+ El flujo de trabajo de creación de servicio en la consola de Amazon ECS solo es admite el registro de servicios en espacios de nombres de DNS privado. Cuando se crea un espacio de nombres de DNS privado de AWS Cloud Map, se creará automáticamente una zona alojada privada de Route 53.
+ Los atributos de DNS de la VPC deben estar configurados para una resolución de DNS correcta. Para obtener información acerca de cómo configurar los atributos, consulte [Compatibilidad de la VPC con DNS](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) en la *Guía del usuario de Amazon VPC*.
+ Amazon ECS no admite el registro de servicios en espacios de nombres de AWS Cloud Map compartidos.
+ Los registros de DNS creados para un servicio de detección de servicios se registran siempre con la dirección IP privada de la tarea, en lugar de la dirección IP pública, incluso cuando se utilizan espacios de nombres públicos.
+ La detección de servicios requiere que las tareas especifiquen el modo de red `awsvpc`, `bridge` o `host` (`none` no se admite).
+ Si la definición de tarea de servicio usa el modo de red `awsvpc`, puede crear cualquier combinación de registros `A` o `SRV` para cada tarea de servicio. Si utiliza los registros `SRV`, se necesita un puerto. También puede crear registros `AAAA` si el servicio utiliza subredes de doble pila. Si el servicio utiliza subredes de solo IPv6, no puede crear registros `A`.
+ Si la definición de tarea de servicio usa el modo de red `bridge` o `host`, el único tipo de registro de DNS admitido es un registro SRV. Cree un registro SRV para cada tarea de servicio. El registro SRV debe especificar una combinación de nombre y puerto de contenedor en la definición de tarea.
+ Los registros de DNS de un servicio de detección de servicios se pueden consultar dentro de la VPC. Utilizan el siguiente formato .: `.`.
+ Al realizar una consulta de DNS en el nombre del servicio, los registros `A` y `AAAA` devuelven un conjunto de direcciones IP que corresponden a las tareas. Los registros `SRV` devuelven un conjunto de direcciones IP y puertos para cada tarea.
+ Si tiene ocho registros o menos en buen estado, Route 53 responde a todas las consultas de DNS con todos los registros en buen estado.
+ Cuando todos los registros están en mal estado, Route 53 responde a las consultas de DNS con hasta ocho registros en mal estado.
+ Puede configurar la detección de servicios para un servicio que se encuentre detrás de un equilibrador de carga, pero el tráfico de la detección de servicios siempre se dirige a la tarea, no al equilibrador de carga.
+ La detección de servicios no admite el uso del equilibrador de carga clásico.
+ Se recomienda utilizar las comprobaciones de estado de nivel de contenedor administradas por Amazon ECS para el servicio de detección de servicios.
+ **HealthCheckCustomConfig**: Amazon ECS administra las comprobaciones de estado en su nombre. Amazon ECS utiliza información del contenedor y de las comprobaciones de estado, además del estado de la tarea, para actualizar el estado mediante AWS Cloud Map. Esto se especifica a través del parámetro `--health-check-custom-config` cuando se crea el servicio de detección de servicios. Para obtener más información, consulte [HealthCheckCustomConfig](https://docs.aws.amazon.com/cloud-map/latest/api/API_HealthCheckCustomConfig.html) en la *Referencia de la API de AWS Cloud Map*.
+ Los recursos de AWS Cloud Map que se crean cuando se utiliza la detección de servicios se deben limpiar manualmente.
+ Las tareas y las instancias se registran como `UNHEALTHY` hasta que las comprobaciones de estado del contenedor devuelvan un valor. Si se pasan las comprobaciones de estado, el estado se actualiza a `HEALTHY`. Si las comprobaciones de estado del contenedor fallan, se anula el registro de la instancia de detección de servicios.
## Precios de la detección de servicios
Los clientes que utilizan la detección de servicios de Amazon ECS deben pagar cargos por los recursos de Route 53 y las operaciones de la API de detección de AWS Cloud Map. Se cobran costos por crear zonas alojadas en Route 53 y por las consultas al registro de servicios. Para obtener más información, consulte [Precios de AWS Cloud Map](https://docs.aws.amazon.com/cloud-map/latest/dg/cloud-map-pricing.html) en la *Guía para desarrolladores de AWS Cloud Map*.
Amazon ECS realiza comprobaciones de estado en el nivel de contenedor y las expone a operaciones de la API de comprobación de estado personalizada de AWS Cloud Map. Actualmente, esto está a disposición de los clientes sin ningún costo adicional. Si configura las comprobaciones de estado de red adicionales para tareas expuestas de forma pública, se le cobrará por dichas comprobaciones de estado.
# Creación de un servicio de Amazon ECS que utilice la detección de servicios
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
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
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
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 ' 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 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
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
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
```
# Uso de Amazon VPC Lattice para conectar, observar y proteger los servicios de Amazon ECS
Amazon VPC Lattice es un servicio de redes de aplicaciones completamente administrado que utilizan los clientes de Amazon ECS para observar, proteger y monitorear las aplicaciones creadas en servicios de computación, VPC y cuentas de AWS sin tener que modificar su código.
VPC Lattice usa grupos de destino, que son un conjunto de recursos de computación. Estos destinos ejecutan la aplicación o servicio y pueden ser instancias de Amazon EC2, direcciones IP, funciones de Lambda y equilibradores de carga de aplicación. Al asociar sus servicios de Amazon ECS a un grupo de destino de VPC Lattice, los clientes ahora pueden habilitar las tareas de Amazon ECS como destinos de IP en VPC Lattice. Amazon ECS registra automáticamente las tareas en el grupo de destino de VPC Lattice cuando se lanzan las tareas del servicio registrado.
**nota**
Cuando se utilizan cinco configuraciones de VPC Lattice, el tiempo de implementación puede ser un poco más que cuando se utilizan menos configuraciones.
Se utiliza una regla de oyente para reenviar el tráfico a un grupo de destino específico cuando se cumplen las condiciones. Un oyente comprueba las solicitudes de conexión mediante el protocolo en el puerto que haya configurado. Un servicio dirige las solicitudes a sus destinos registrados en función de las reglas que haya definido al configurar el oyente.
Amazon ECS también reemplaza automáticamente una tarea si no funciona correctamente según las comprobaciones de estado de VPC Lattice. Una vez asociados a VPC Lattice, los clientes de Amazon ECS también pueden aprovechar muchas otras características de conectividad, seguridad y observabilidad entre cómputos de VPC Lattice, como la conexión a servicios entre clústeres, VPC y cuentas con AWS Resource Access Manager, integración de IAM para autorización y autenticación y características avanzadas de administración del tráfico.
Los clientes de Amazon ECS pueden beneficiarse de VPC Lattice de las siguientes formas.
+ Aumento de la productividad de los desarrolladores: VPC Lattice aumenta la productividad de los desarrolladores al permitir centrarse en la creación de características, mientras que VPC Lattice gestiona los desafíos de redes, seguridad y observabilidad de manera uniforme en todas las plataformas de computación.
+ Mejor postura de seguridad: VPC Lattice permite a los desarrolladores autenticar y proteger fácilmente la comunicación entre aplicaciones y plataformas de computación, aplicar el cifrado en tránsito y aplicar controles de acceso detallados con políticas de autenticación de VPC Lattice. Esto le permite adoptar una postura de seguridad más sólida que cumpla con los requisitos normativos y de cumplimiento líderes del sector.
+ Mejora de la escalabilidad y resiliencia de las aplicaciones: VPC Lattice le permite crear una red de aplicaciones implementadas con característica como enrutamiento, autenticación, autorización y monitoreo basados en rutas, encabezados y métodos. Estas ventajas se proporcionan sin sobrecargar los recursos de las cargas de trabajo y permiten hacer implementaciones de varios clústeres que generan millones de solicitudes por segundo sin agregar una latencia significativa.
+ Flexibilidad de implementación con una infraestructura heterogénea: VPC Lattice proporciona características uniformes en todos los servicios de computación, como Amazon ECS, Fargate, Amazon EC2, Amazon EKS y Lambda, y le da a su organización la flexibilidad de elegir la infraestructura adecuada para cada aplicación.
## Funcionamiento de VPC Lattice con otros servicios de Amazon ECS
El uso de VPC Lattice con Amazon ECS puede cambiar la forma en que utiliza otros servicios de Amazon ECS, mientras que otros seguirán siendo los mismos.
**Equilibradores de carga de aplicación**
Ya no es necesario crear un equilibrador de carga de aplicación específico para usarlo con el tipo de grupo de destino del equilibrador de carga de aplicación en VPC Lattice, que luego se vincula al servicio de Amazon ECS. En su lugar, solo tiene que configurar el servicio de Amazon ECS con un grupo de destino de VPC Lattice. También puede optar por utilizar el equilibrador de carga de aplicación con Amazon ECS al mismo tiempo.
**Implementaciones continuas de Amazon ECS**
Solo las implementaciones continuas de Amazon ECS funcionan con VPC Lattice, y Amazon ECS incorpora las tareas a los servicios y las elimina de forma segura durante la implementación. No se admiten la implementación de código ni las implementaciones azul/verde.
Para obtener más información sobre VPC Lattice, consulte la [Guía del usuario de Amazon VPC Lattice](https://docs.aws.amazon.com/vpc-lattice/latest/ug/what-is-vpc-lattice.html).
# Creación de un servicio que utilice VPC Lattice
Puede usar la Consola de administración de AWS o la AWS CLI para crear un servicio con VPC Lattice.
## Requisitos previos
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 de la AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html).
**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).
+ 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.
## Creación de un servicio que utiliza VPC Lattice con la Consola de administración de AWS
Siga estos pasos para crear un servicio con VPC Lattice mediante la Consola de administración de AWS.
1. Abra la consola en [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).
1. En el panel de navegación, elija **Clústeres**.
1. En la página **Clústeres**, seleccione el clúster en el que va a crear el servicio.
1. En la pestaña **Services** (Servicios), elija **Create** (Crear).
Si nunca antes ha creado un servicio, siga los pasos que se indican en [Creación de un servicio de Amazon ECS mediante la consola](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html) y, a continuación, continúe con estos pasos cuando llegue a la sección de VPC Lattice.
1. Marque el botón para elegir **Activar VPC Lattice**.
1. A fin de utilizar un rol existente para el **rol de infraestructura de ECS para Amazon ECS**, elija uno que ya haya creado para usarlo al crear el grupo de destino de VPC Lattice. Para crear un nuevo rol, **cree un rol de infraestructura de ECS**.
1. Elija la **VPC**.
La **VPC** depende del modo de red que haya seleccionado al registrar la definición de la tarea. Si utiliza el modo `host` o `network` con EC2, elija su VPC.
Si utiliza el modo `awsvpc`, la VPC se selecciona automáticamente en función de la VPC que haya elegido en **Redes** y no se podrá cambiar.
1. En **Grupos de destino**, elija el grupo o grupos de destino. Debe elegir un mínimo de un grupo de destino y un máximo de cinco. Elija **Agregar grupo de destino** para agregar grupos de destino adicionales. Elija el **nombre del puerto**, el **protocolo** y el **puerto** para cada grupo de destino que elija. Para eliminar un grupo de destino, elija **Eliminar**.
**nota**
Si quiere agregar grupos de destino existentes, debe utilizar la AWS CLI. Para obtener instrucciones sobre cómo agregar grupos de destino mediante la AWS CLI, consulte [register-targets](https://docs.aws.amazon.com/cli/latest/reference/vpc-lattice/register-targets.html) en la *Referencia de AWS Command Line Interface*.
Si bien un servicio de VPC Lattice puede tener varios grupos de destino, cada grupo de destino solo se puede agregar a un servicio.
Para crear un servicio en una configuración de solo IPv6, elija grupos de destino con un tipo de dirección IP de `IPv6`.
1. En este punto, vaya a la consola de VPC Lattice para continuar con la configuración. Aquí es donde se incluyen los nuevos grupos de destino en la acción predeterminada del oyente o en las reglas de un servicio de VPC Lattice existente.
Para obtener más información, consulte [Reglas de oyente para el servicio de VPC Lattice](https://docs.aws.amazon.com/vpc-lattice/latest/ug/listener-rules.html).
**importante**
Debe permitir el prefijo `vpc-lattice` de la regla entrante en su grupo de seguridad o tareas y se puede producir un error en las comprobaciones de estado.
## Creación de un servicio que utiliza VPC Lattice con la AWS CLI
Utilice la AWS CLI para crear un servicio con VPC Lattice. Reemplace cada *marcador de posición de entrada del usuario* con información propia.
1. Cree un archivo de configuración de grupo de destino. El siguiente ejemplo se denomina `tg-config.json`
```
{
"ipAddressType": "IPV4",
"port": 443,
"protocol": "HTTPS",
"protocolVersion": "HTTP1",
"vpcIdentifier": "vpc-f1663d9868EXAMPLE"
}
```
1. Utilice el siguiente comando para crear un grupo de destino de VPC Lattice.
```
aws vpc-lattice create-target-group \
--name my-lattice-target-group-ip \
--type IP \
--config file://tg-config.json
```
**nota**
Para crear un servicio en una configuración de solo IPv6, cree grupos de destino con un tipo de dirección IP de `IPv6`. Para obtener más información, consulte [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/vpc-lattice/create-target-group.html) en la *Referencia de comandos de la AWS CLI*.
Ejemplo de código de salida:
```
{
"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. El siguiente archivo JSON denominado *ecs-service-vpc-lattice.json* es un ejemplo que se utiliza para adjuntar un servicio de Amazon ECS a un grupo de destino de VPC Lattice. El `portName` en el ejemplo que aparece a continuación es el mismo que definió en el campo `name` de la propiedad `portMappings` de la definición de la tarea.
```
{
"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"
}
```
Utilice el siguiente comando para crear un servicio de Amazon ECS y adjuntarlo al grupo de destino de VPC Lattice mediante el ejemplo de json anterior.
```
aws ecs create-service \
--cluster clusterName \
--serviceName ecs-service-vpc-lattice \
--cli-input-json file://ecs-service-vpc-lattice.json
```
**nota**
VPC Lattice no es compatible con Amazon ECS Anywhere.