El producto descrito en esta documentación, Anthos Clusters en AWS (generación anterior), se encuentra actualmente en modo de mantenimiento . Todas las nuevas instalaciones deben usar el producto de la generación actual, Anthos Clusters en AWS .

Esta página se ha traducido con Cloud Translation API.

Integración con la infraestructura actual

En este tema, se configura una nube privada virtual (VPC) de AWS con subredes públicas y privadas, y se ejecuta anthos-gke para completar la instalación de un servicio de gestión.

Antes de empezar

Para completar los pasos que se indican a continuación, necesitas lo siguiente:

Permisos de gestión de identidades y accesos de AWS, tal como se describe en la sección Requisitos.
Una VPC de AWS con lo siguiente:
- Al menos una subred pública.
- Al menos una subred privada.
- Una pasarela de Internet con una ruta a la subred pública.
- Una pasarela de NAT con una ruta a la subred privada.
- Nombres de host de DNS habilitados.
- No hay ningún valor personalizado de domain-name en tus conjuntos de opciones de DHCP. Para obtener más información, consulta Solucionar problemas. GKE en AWS no admite valores distintos de los nombres de dominio de EC2 predeterminados.
Para obtener más información sobre cómo configurar tu VPC de AWS, consulta VPC con subredes públicas y privadas.
Los IDs de las subredes públicas y privadas de tu VPC. Por ejemplo, subnet-1234567890abcdefg.
En el caso de los clústeres con la versión 1.20 o inferior, un grupo de seguridad de AWS que permita la entrada de SSH (puerto 22) desde los grupos de seguridad o los intervalos de IP en los que gestionarás tu instalación de GKE en AWS.
En el caso de los clústeres con la versión 1.21 o posterior, un grupo de seguridad de AWS que permita las conexiones salientes de Konnectivity (puerto 8132) desde los intervalos de IP de la VPC que alojan tus grupos de nodos de GKE en AWS.

Crear el espacio de trabajo

Crea un archivo llamado anthos-gke.yaml en un editor de texto. Pega el siguiente contenido en el archivo.
```
 apiVersion: multicloud.cluster.gke.io/v1
 kind: AWSManagementService
 metadata:
   name: management
 spec:
   version: aws-1.14.1-gke.0
   region: AWS_REGION
   authentication:
     awsIAM:
       adminIdentityARNs:
       - ADMIN_AWS_IAM_ARN
   kmsKeyARN: KMS_KEY_ARN
   databaseEncryption:
     kmsKeyARN: DATABASE_KMS_KEY_ARN
   securityGroupIDs:
   - SECURITY_GROUP_IDS
   googleCloud:
     projectID: GCP_PROJECT_ID
     serviceAccountKeys:
       managementService: MANAGEMENT_KEY_PATH
       connectAgent: HUB_KEY_PATH
       node: NODE_KEY_PATH
   existingVPC:
     subnetID: VPC_SUBNET_ID
     allowedSSHSecurityGroupIDs:
     - SSH_SECURITY_GROUP
   # Optional fields
   rootVolume:
     sizeGiB: ROOT_VOLUME_SIZE
     volumeType: ROOT_VOLUME_TYPE
     iops: ROOT_VOLUME_IOPS
     kmsKeyARN: ROOT_VOLUME_KEY
   bastionHost:
     subnetID: BASTION_HOST_SUBNET_ID
     allowedSSHCIDRBlocks:
     - SSH_CIDR_BLOCK
     rootVolume: # Optional
       kmsKeyARN: BASTION_VOLUME_KEY
   proxy: PROXY_JSON_FILE
```
Sustituye los siguientes valores:
- AWS_REGION con la región de AWS en la que quieres ejecutar el clúster.
- ADMIN_AWS_IAM_ARN con el nombre de recurso de Amazon de la clave de gestión de identidades y accesos de AWS del administrador.
- KMS_KEY_ARN con el nombre de recurso de Amazon de la clave de AWS KMS que protege los datos de tu servicio de gestión cuando se crea el servicio de gestión.
- DATABASE_KMS_KEY_ARN con el nombre de recurso de Amazon de la clave de KMS de AWS que protege tus bases de datos de etcd.
- SECURITY_GROUP_IDS con IDs de grupos de seguridad adicionales que tengan permiso para acceder a tus VMs de servicio de gestión.
- GCP_PROJECT_ID con el Google Cloud proyecto que aloja tu entorno de GKE en AWS.
- MANAGEMENT_KEY_PATH con la ubicación de tu Google Cloud gestión clave de cuenta de servicio.
- HUB_KEY_PATH con la ubicación de tu Google Cloud Conectar clave de cuenta de servicio.
- NODE_KEY_PATH con la ubicación de la clave de cuenta de servicio de tu nodo de GKE en AWS.
- VPC_SUBNET_ID con el ID de la subred en la que se ejecuta el servicio de gestión.
- SSH_SECURITY_GROUP con la lista de IDs de grupos de seguridad permitidos acceso SSH en las instancias del servicio de gestión.
Opcional: Si quieres cifrar los volúmenes de tu servicio de gestión, sustituye los siguientes valores:
- ROOT_VOLUME_SIZE con el tamaño del volumen en gigabytes del servicio de gestión. Por ejemplo, 10.
- ROOT_VOLUME_TYPE con el tipo de volumen de EBS. Por ejemplo, gp3.
- ROOT_VOLUME_IOPS con el número de operaciones de E/S aprovisionadas por segundo (IOPS) del volumen. Solo es válido cuando volumeType es GP3. Para obtener más información, consulta Volúmenes SSD de uso general (gp3).
- ROOT_VOLUME_KEY con el nombre de recurso de Amazon de la clave de AWS KMS que cifra los volúmenes raíz de tu instancia de servicio de gestión. Para obtener más información, consulta Usar una CMK gestionada por el cliente para cifrar volúmenes.
Opcional: Si quieres crear un host de acceso para acceder a tu entorno de GKE en AWS con un túnel SSH, sustituye los siguientes valores:
- BASTION_HOST_SUBNET_ID con el ID de la subred en la que se ejecuta el host bastion. Asegúrate de que VPC_SUBNET_ID permita las conexiones entrantes de BASTION_HOST_SUBNET_ID.
- SSH_CIDR_BLOCK con el bloque CIDR desde el que tu host de acceso permite la conexión SSH entrante. Por ejemplo, 203.0.113.0/24. Si quieres permitir conexiones SSH desde cualquier dirección IP, usa 0.0.0.0/0.
- BASTION_VOLUME_KEY con el nombre de recurso de Amazon de la clave de KMS de AWS que protege el volumen raíz de tu bastion.
Opcional: Si quieres dirigir el tráfico a través de un proxy HTTP, sustituye el siguiente valor:
- PROXY_JSON_FILE con la ruta relativa del archivo de configuración del proxy. Si no utilizas un proxy, elimina esta línea.
Ejecuta anthos-gke aws management init para crear archivos de configuración:
```
anthos-gke aws management init
```
Ejecuta anthos-gke aws management apply para crear el clúster.
```
anthos-gke aws management apply
```
El comando anthos-gke aws management apply puede tardar hasta diez minutos en completarse. Cuando anthos-gke termine, tu servicio de gestión se ejecutará en AWS.

Etiqueta tus subredes con el nombre del clúster

Si usas subredes de AWS con GKE en AWS y quieres crear balanceadores de carga, debes etiquetar tu VPC y tus subredes con el nombre de tu servicio de gestión. Si has creado tu VPC con anthos-gke o ya has etiquetado tus subredes, sáltate este paso.

Para etiquetar tus subredes, sigue estos pasos:

Cambia al directorio con tu configuración de GKE en AWS. Has creado este directorio al instalar el servicio de gestión.
```
cd anthos-aws
```
Exporta el ID de tu clúster como la variable de entorno $CLUSTER-ID. Elige tu versión de Terraform y, a continuación, ejecuta los siguientes comandos:
Terraform 0.12 y 0.13
```
export CLUSTER_ID=$(terraform output cluster_id)
```
Terraform 0.14.3 o versiones posteriores
```
export CLUSTER_ID=$(terraform output -raw cluster_id)
```
Exporta tu ID de VPC de AWS como la variable de entorno $VPC_ID. Elige tu versión de Terraform y, a continuación, ejecuta los siguientes comandos:
Terraform 0.12 y 0.13
```
export VPC_ID=$(terraform output vpc_id)
```
Terraform 0.14.3 o versiones posteriores
```
export VPC_ID=$(terraform output -raw vpc_id)
```
Obtenga los IDs de sus subredes privadas con la herramienta de línea de comandos aws.
```
  aws ec2 describe-subnets \
      --filters "Name=vpc-id,Values=$VPC_ID" "Name=tag:Name,Values=*private*" \
      --query "Subnets[*].SubnetId" \
      --output text
```
Nota: Este comando presupone que tus subredes tienen private en su nombre. Si tus subredes no incluyen este texto, cambia los parámetros de la marca --filters. Para obtener más información, consulta el artículo sobre cómo usar los filtros.
Etiqueta tus subredes con el ID de tu clúster. Ejecuta el siguiente comando para cada una de tus subredes.
```
  aws ec2 create-tags \
      --resources SUBNET_IDS \
      --tags Key=gke:multicloud:cluster-id,Value=$CLUSTER_ID
```
Sustituye SUBNET_IDS por la lista de IDs de subredes, separados por espacios. Por ejemplo, subnet-012345678abcdef subnet-abcdef123456789 subnet-123456789abcdef.

Conectarse al servicio de gestión

En esta sección, establecerás una conexión con tu servicio de gestión. Puedes canalizar tus comandos a través de un host bastion. Si tienes una conexión directa a tu VPC de AWS, ve a Generar credenciales y conectar.

Conectarse a un host bastión

Si usas un host bastión para configurar el túnel SSH, primero configura el host en tu anthos-gke.yaml. A continuación, crea una secuencia de comandos para abrir el túnel siguiendo estos pasos:

Usa terraform para generar una secuencia de comandos que abra un túnel SSH al host bastión.
```
terraform output bastion_tunnel > bastion-tunnel.sh
chmod 755 bastion-tunnel.sh
```
Terraform crea la secuencia de comandos bastion-tunnel.sh que usa la clave SSH del host bastion (~/.ssh/anthos-gke).
Para abrir el túnel, ejecuta la secuencia de comandos bastion-tunnel.sh. El túnel reenvía de localhost:8118 al host bastion.

Para abrir un túnel al host bastion, ejecuta el siguiente comando:
```
./bastion-tunnel.sh -N
```
Los mensajes del túnel SSH aparecen en esta ventana. Cuando quieras cerrar la conexión, detén el proceso con Control+C o cierra la ventana.
Cambia al directorio con tu configuración de GKE en AWS.
```
cd anthos-aws
```

Generar credenciales y conectar

En la documentación de GKE en AWS se presupone que usas un túnel SSH en el puerto 8118 para acceder a tu clúster.localhost Si usas otro tipo de conexión a tu VPC, como una interconexión directa, una VPN u otro método, puedes quitar la línea env HTTP_PROXY=http://localhost:8118 de los comandos.

Genera un kubeconfig para la autenticación. Usa anthos-gke para añadir credenciales a la configuración almacenada en ~/.kube/config.
```
anthos-gke aws management get-credentials
```
Comprueba que puedes conectarte al servicio de gestión con kubectl.
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl cluster-info
```
kubectl muestra el estado del clúster.

Siguientes pasos

Crea un clúster de usuarios.
Usa un proxy con GKE en AWS.
Cambia la configuración de kubectl para conectarte a GKE en AWS con menos opciones de línea de comandos.
Consulta los grupos de seguridad mínimos necesarios para tu servicio de gestión de GKE en AWS y tus clústeres de usuario.