Esta documentación es para la versión actual de GKE en AWS, publicada en noviembre de 2021. Consulta las notas de la versión para obtener más información.

Crear una VPC de AWS

GKE en AWS se ejecuta en una nube privada virtual (VPC) de AWS. En esta página, se explica cómo configurar una VPC nueva para tu clúster.

GKE en AWS crea y administra recursos dentro de la VPC que especifiques. También debes crear varias subredes dentro de la VPC:

Hasta tres subredes para los nodos del plano de control
Una subred para el grupo de nodos
Subredes para balanceadores de cargas de servicio de Kubernetes

VPC de muestra

Sigue estos pasos para configurar la VPC que se ilustra a continuación. Para tus propios casos de uso de producción, puedes elegir diferentes rangos de IP, zonas de disponibilidad, subredes y listas de control de acceso a la red que se adapten a tus cargas de trabajo.

En el siguiente diagrama, se muestra la VPC de muestra que creas cuando sigues estos pasos:

VPC de muestra

En este ejemplo, se usan tres zonas de disponibilidad: Zona de disponibilidad 1, Zona de disponibilidad 2, Zona de disponibilidad 3. Por ejemplo, para crear una VPC en la región us-east-1, las zonas se pueden configurar como us-east-1a, us-east-1b y us-east-1c.
Dentro de cada una de las tres zonas de disponibilidad, hay una subred pública y una privada.
Las réplicas del plano de control y los extremos del balanceador de cargas, así como los grupos de nodos, se crean en las subredes privadas.
Las subredes públicas proporcionan acceso saliente a Internet para las subredes privadas y los extremos públicos del balanceador de cargas.
Todas estas subredes se etiquetan para el descubrimiento automático de subredes. Los balanceadores de cargas internos se aprovisionarán en las subredes privadas y los balanceadores de cargas orientados a Internet en las subredes públicas.

Crea tu VPC

Elige un prefijo y edita la variable de página AMC_PREFIX en el siguiente comando para establecerlo en el prefijo que elegiste. Los comandos de muestra que aparecen a continuación adjuntarán de forma automática este prefijo a todas las referencias a tu VPC y sus recursos.
Crea una nube privada virtual (VPC) de AWS:
```
aws --region AWS_REGION ec2 create-vpc \
    --cidr-block 10.0.0.0/16 \
    --tag-specifications 'ResourceType=vpc, Tags=[{Key=Name,Value=AMC_PREFIXVPC}]'
```
Reemplaza lo siguiente:
- AWS_REGION: el nombre de la región de AWS compatible en la que se creará la VPC.
- AMC_PREFIX: el prefijo del nombre de VPC que elegiste para tu VPC y sus recursos

Guarda tu ID de VPC en una variable de entorno y habilita la asistencia de DNS proporcionada por AWS para la VPC:

VPC_ID=$(aws ec2 describe-vpcs \
  --filters 'Name=tag:Name,Values=AMC_PREFIXVPC' \
  --query "Vpcs[].VpcId" --output text)
aws ec2 modify-vpc-attribute --enable-dns-hostnames --vpc-id $VPC_ID
aws ec2 modify-vpc-attribute --enable-dns-support --vpc-id $VPC_ID

También puedes usar diferentes opciones de configuración de DNS para tu VPC. Para obtener más información, consulta DNS de VPC de AWS.

Subredes del plano de control

Puedes configurar hasta tres subredes para las réplicas del plano de control. Si especificas menos de tres subredes, GKE en AWS crea tres réplicas del plano de control y las distribuye en las subredes especificadas.

Los clústeres son privados para tu VPC. No se permite el acceso entrante directo a los clústeres desde Internet. GKE en AWS requiere acceso limitado de salida a Internet para crear y administrar clústeres. En este ejemplo, se usa una puerta de enlace de Internet para el acceso saliente.

Requisitos de la subred

Las subredes deben cumplir con estos requisitos:

Ser capaz de resolver direcciones DNS
Poder establecer conexiones TCP salientes en el puerto 443 para direcciones IP enrutables
Poder conectarse a los siguientes extremos:

Extremo	Objetivo
storage.googleapis.com	Para descargar desde Cloud Storage durante la instalación
*.gcr.io	Para descargar desde Container Registry durante la instalación
gkeconnect.googleapis.com	Para conectar al servicio de administración
oauth2.googleapis.com	Para la autenticación del clúster
sts.googleapis.com	Para la autenticación del clúster
logging.googleapis.com	Para enviar registros a Cloud Logging
monitoring.googleapis.com	Para enviar métricas a Cloud Monitoring
opsconfigmonitoring.googleapis.com`	Para enviar metadatos de recursos a Cloud Monitoring
servicecontrol.googleapis.com	Para Cloud Audit Logging

Si no tienes subredes para las instancias del plano de control, usa los siguientes comandos a fin de crearlas.

Crea subredes privadas

Crea tres subredes privadas en sus zonas de disponibilidad correspondientes:

   aws ec2 create-subnet \
     --availability-zone AWS_ZONE_1 \
     --vpc-id $VPC_ID \
     --cidr-block 10.0.1.0/24 \
     --tag-specifications 'ResourceType=subnet, Tags=[{Key=Name,Value=AMC_PREFIXPrivateSubnet1}]'
   aws ec2 create-subnet \
     --availability-zone AWS_ZONE_2 \
     --vpc-id $VPC_ID \
     --cidr-block 10.0.2.0/24 \
     --tag-specifications 'ResourceType=subnet, Tags=[{Key=Name,Value=AMC_PREFIXPrivateSubnet2}]'
   aws ec2 create-subnet \
     --availability-zone AWS_ZONE_3 \
     --vpc-id $VPC_ID \
     --cidr-block 10.0.3.0/24 \
     --tag-specifications 'ResourceType=subnet, Tags=[{Key=Name,Value=AMC_PREFIXPrivateSubnet3}]'

Reemplaza lo siguiente:

AWS_ZONE_1: Zona de disponibilidad 1
AWS_ZONE_2: Zona de disponibilidad 2
AWS_ZONE_3: Zona de disponibilidad 3

Crea subredes públicas

Crea tres subredes públicas. Estas se usarán a fin de proporcionar acceso a Internet saliente a las subredes privadas.

aws ec2 create-subnet \
  --availability-zone AWS_ZONE_1 \
  --vpc-id $VPC_ID \
  --cidr-block 10.0.101.0/24 \
  --tag-specifications 'ResourceType=subnet, Tags=[{Key=Name,Value=AMC_PREFIXPublicSubnet1}]'
aws ec2 create-subnet \
  --availability-zone AWS_ZONE_2 \
  --vpc-id $VPC_ID \
  --cidr-block 10.0.102.0/24 \
  --tag-specifications 'ResourceType=subnet, Tags=[{Key=Name,Value=AMC_PREFIXPublicSubnet2}]'
aws ec2 create-subnet \
  --availability-zone AWS_ZONE_3 \
  --vpc-id $VPC_ID \
  --cidr-block 10.0.103.0/24 \
  --tag-specifications 'ResourceType=subnet, Tags=[{Key=Name,Value=AMC_PREFIXPublicSubnet3}]'

Reemplaza lo siguiente:

AWS_ZONE_1
AWS_ZONE_2
AWS_ZONE_3

Marca las subredes como públicas:

PUBLIC_SUBNET_ID_1=$(aws ec2 describe-subnets \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPublicSubnet1' \
  --query "Subnets[].SubnetId" --output text)
PUBLIC_SUBNET_ID_2=$(aws ec2 describe-subnets \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPublicSubnet2' \
  --query "Subnets[].SubnetId" --output text)
PUBLIC_SUBNET_ID_3=$(aws ec2 describe-subnets \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPublicSubnet3' \
  --query "Subnets[].SubnetId" --output text)
aws ec2 modify-subnet-attribute \
  --map-public-ip-on-launch \
  --subnet-id $PUBLIC_SUBNET_ID_1
aws ec2 modify-subnet-attribute \
  --map-public-ip-on-launch \
  --subnet-id $PUBLIC_SUBNET_ID_2
aws ec2 modify-subnet-attribute \
  --map-public-ip-on-launch \
  --subnet-id $PUBLIC_SUBNET_ID_3

Crea una puerta de enlace de Internet

Crea una puerta de enlace de Internet para que las subredes públicas tengan acceso a Internet:
```
aws --region AWS_REGION  ec2 create-internet-gateway \
  --tag-specifications 'ResourceType=internet-gateway, Tags=[{Key=Name,Value=AMC_PREFIXInternetGateway}]'
```
Reemplaza AWS_REGION: el nombre de la región de AWS en la que se creó tu VPC.

Adjunta la puerta de enlace de Internet a tu VPC:

INTERNET_GW_ID=$(aws ec2 describe-internet-gateways \
  --filters 'Name=tag:Name,Values=AMC_PREFIXInternetGateway' \
  --query "InternetGateways[].InternetGatewayId" --output text)
aws ec2 attach-internet-gateway \
  --internet-gateway-id $INTERNET_GW_ID \
  --vpc-id $VPC_ID

Configura las tablas de enrutamiento para las subredes públicas

Crea una tabla de ruta para cada una de las subredes públicas.

aws ec2 create-route-table --vpc-id $VPC_ID \
  --tag-specifications 'ResourceType=route-table, Tags=[{Key=Name,Value=AMC_PREFIXPublicRouteTbl1}]'
aws ec2 create-route-table --vpc-id $VPC_ID \
  --tag-specifications 'ResourceType=route-table, Tags=[{Key=Name,Value=AMC_PREFIXPublicRouteTbl2}]'
aws ec2 create-route-table --vpc-id $VPC_ID \
  --tag-specifications 'ResourceType=route-table, Tags=[{Key=Name,Value=AMC_PREFIXPublicRouteTbl3}]'

Asocia las tablas de ruta pública con las subredes públicas:

PUBLIC_ROUTE_TABLE_ID_1=$(aws ec2 describe-route-tables \
    --filters 'Name=tag:Name,Values=AMC_PREFIXPublicRouteTbl1' \
    --query "RouteTables[].RouteTableId" --output text)
PUBLIC_ROUTE_TABLE_ID_2=$(aws ec2 describe-route-tables \
    --filters 'Name=tag:Name,Values=AMC_PREFIXPublicRouteTbl2' \
    --query "RouteTables[].RouteTableId" --output text)
PUBLIC_ROUTE_TABLE_ID_3=$(aws ec2 describe-route-tables \
    --filters 'Name=tag:Name,Values=AMC_PREFIXPublicRouteTbl3' \
    --query "RouteTables[].RouteTableId" --output text)
aws ec2 associate-route-table \
  --route-table-id $PUBLIC_ROUTE_TABLE_ID_1 \
  --subnet-id $PUBLIC_SUBNET_ID_1
aws ec2 associate-route-table \
  --route-table-id $PUBLIC_ROUTE_TABLE_ID_2 \
  --subnet-id $PUBLIC_SUBNET_ID_2
aws ec2 associate-route-table \
  --route-table-id $PUBLIC_ROUTE_TABLE_ID_3 \
  --subnet-id $PUBLIC_SUBNET_ID_3

Crea rutas predeterminadas a la puerta de enlace de Internet:

aws ec2 create-route --route-table-id $PUBLIC_ROUTE_TABLE_ID_1 \
  --destination-cidr-block 0.0.0.0/0 --gateway-id $INTERNET_GW_ID
aws ec2 create-route --route-table-id $PUBLIC_ROUTE_TABLE_ID_2 \
  --destination-cidr-block 0.0.0.0/0 --gateway-id $INTERNET_GW_ID
aws ec2 create-route --route-table-id $PUBLIC_ROUTE_TABLE_ID_3 \
  --destination-cidr-block 0.0.0.0/0 --gateway-id $INTERNET_GW_ID

Asigna una dirección IP elástica (EIP) para cada puerta de enlace NAT:

aws ec2 allocate-address \
  --tag-specifications 'ResourceType=elastic-ip, Tags=[{Key=Name,Value=AMC_PREFIXNatEip1}]'
aws ec2 allocate-address \
  --tag-specifications 'ResourceType=elastic-ip, Tags=[{Key=Name,Value=AMC_PREFIXNatEip2}]'
aws ec2 allocate-address \
  --tag-specifications 'ResourceType=elastic-ip, Tags=[{Key=Name,Value=AMC_PREFIXNatEip3}]'

Crea puertas de enlace NAT

Crea una puerta de enlace NAT en cada una de las tres subredes públicas:

   NAT_EIP_ALLOCATION_ID_1=$(aws ec2 describe-addresses \
     --filters 'Name=tag:Name,Values=AMC_PREFIXNatEip1' \
     --query "Addresses[].AllocationId" --output text)
   NAT_EIP_ALLOCATION_ID_2=$(aws ec2 describe-addresses \
     --filters 'Name=tag:Name,Values=AMC_PREFIXNatEip2' \
     --query "Addresses[].AllocationId" --output text)
   NAT_EIP_ALLOCATION_ID_3=$(aws ec2 describe-addresses \
     --filters 'Name=tag:Name,Values=AMC_PREFIXNatEip3' \
     --query "Addresses[].AllocationId" --output text)
   aws ec2 create-nat-gateway \
     --allocation-id $NAT_EIP_ALLOCATION_ID_1 \
     --subnet-id $PUBLIC_SUBNET_ID_1 \
     --tag-specifications 'ResourceType=natgateway, Tags=[{Key=Name,Value=AMC_PREFIXNatGateway1}]'
   aws ec2 create-nat-gateway \
     --allocation-id $NAT_EIP_ALLOCATION_ID_2 \
     --subnet-id $PUBLIC_SUBNET_ID_2 \
     --tag-specifications 'ResourceType=natgateway, Tags=[{Key=Name,Value=AMC_PREFIXNatGateway2}]'
   aws ec2 create-nat-gateway \
     --allocation-id $NAT_EIP_ALLOCATION_ID_3 \
     --subnet-id $PUBLIC_SUBNET_ID_3 \
     --tag-specifications 'ResourceType=natgateway, Tags=[{Key=Name,Value=AMC_PREFIXNatGateway3}]'

Configura las tablas de enrutamiento para las subredes privadas

Crea una tabla de ruta para cada subred privada:

aws ec2 create-route-table --vpc-id $VPC_ID \
  --tag-specifications 'ResourceType=route-table, Tags=[{Key=Name,Value=AMC_PREFIXPrivateRouteTbl1}]'
aws ec2 create-route-table --vpc-id $VPC_ID \
  --tag-specifications 'ResourceType=route-table, Tags=[{Key=Name,Value=AMC_PREFIXPrivateRouteTbl2}]'
aws ec2 create-route-table --vpc-id $VPC_ID \
  --tag-specifications 'ResourceType=route-table, Tags=[{Key=Name,Value=AMC_PREFIXPrivateRouteTbl3}]'

Asocia las tablas de ruta privada con las subredes privadas:

PRIVATE_SUBNET_ID_1=$(aws ec2 describe-subnets \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPrivateSubnet1' \
  --query "Subnets[].SubnetId" --output text)
PRIVATE_SUBNET_ID_2=$(aws ec2 describe-subnets \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPrivateSubnet2' \
  --query "Subnets[].SubnetId" --output text)
PRIVATE_SUBNET_ID_3=$(aws ec2 describe-subnets \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPrivateSubnet3' \
  --query "Subnets[].SubnetId" --output text)
PRIVATE_ROUTE_TABLE_ID_1=$(aws ec2 describe-route-tables \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPrivateRouteTbl1' \
  --query "RouteTables[].RouteTableId" --output text)
PRIVATE_ROUTE_TABLE_ID_2=$(aws ec2 describe-route-tables \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPrivateRouteTbl2' \
  --query "RouteTables[].RouteTableId" --output text)
PRIVATE_ROUTE_TABLE_ID_3=$(aws ec2 describe-route-tables \
  --filters 'Name=tag:Name,Values=AMC_PREFIXPrivateRouteTbl3' \
  --query "RouteTables[].RouteTableId" --output text)
aws ec2 associate-route-table --route-table-id $PRIVATE_ROUTE_TABLE_ID_1 \
  --subnet-id $PRIVATE_SUBNET_ID_1
aws ec2 associate-route-table --route-table-id $PRIVATE_ROUTE_TABLE_ID_2 \
  --subnet-id $PRIVATE_SUBNET_ID_2
aws ec2 associate-route-table --route-table-id $PRIVATE_ROUTE_TABLE_ID_3 \
  --subnet-id $PRIVATE_SUBNET_ID_3

Crea las rutas predeterminadas a las puertas de enlace NAT:

NAT_GW_ID_1=$(aws ec2 describe-nat-gateways \
 --filter 'Name=tag:Name,Values=AMC_PREFIXNatGateway1' \
 --query "NatGateways[].NatGatewayId" --output text)
NAT_GW_ID_2=$(aws ec2 describe-nat-gateways \
 --filter 'Name=tag:Name,Values=AMC_PREFIXNatGateway2' \
 --query "NatGateways[].NatGatewayId" --output text)
NAT_GW_ID_3=$(aws ec2 describe-nat-gateways \
 --filter 'Name=tag:Name,Values=AMC_PREFIXNatGateway3' \
 --query "NatGateways[].NatGatewayId" --output text)
aws ec2 create-route --route-table-id $PRIVATE_ROUTE_TABLE_ID_1  \
  --destination-cidr-block 0.0.0.0/0 --gateway-id $NAT_GW_ID_1
aws ec2 create-route --route-table-id $PRIVATE_ROUTE_TABLE_ID_2  \
  --destination-cidr-block 0.0.0.0/0 --gateway-id $NAT_GW_ID_2
aws ec2 create-route --route-table-id $PRIVATE_ROUTE_TABLE_ID_3 \
  --destination-cidr-block 0.0.0.0/0 --gateway-id $NAT_GW_ID_3

Subredes del grupo de nodos

Cada grupo de nodos se coloca en una sola subred. Puedes colocar varios grupos de nodos en una subred. La cantidad de nodos y grupos de nodos que puedes crear está limitada por el rango de direcciones IP disponible en la subred.

Cada subred del grupo de nodos debe cumplir con estos requisitos:

Cumplir con los mismos requisitos de acceso a Internet saliente que tus subredes del plano de control
Tener suficiente espacio de direcciones IP para cubrir el tamaño del grupo de nodos
No tener habilitada la opción “Asignar IP públicas de forma automática”

Las subredes privadas creadas anteriormente satisfacen los requisitos de las subredes del plano de control y de las subredes del grupo de nodos.

Subredes del balanceador de cargas de servicio

Si creas balanceadores de cargas de red o balanceadores de cargas de HTTP, etiqueta subredes del balanceador de cargas para descubrimiento automático.

Etiqueta las subredes públicas con kubernetes.io/role/elb:

aws ec2 create-tags \
  --resources $PUBLIC_SUBNET_ID_1 \
  --tags Key=kubernetes.io/role/elb,Value=1
aws ec2 create-tags \
  --resources $PUBLIC_SUBNET_ID_2 \
  --tags Key=kubernetes.io/role/elb,Value=1
aws ec2 create-tags \
  --resources $PUBLIC_SUBNET_ID_3 \
  --tags Key=kubernetes.io/role/elb,Value=1

Etiqueta las subredes privadas con kubernetes.io/role/internal-elb:

aws ec2 create-tags \
  --resources $PRIVATE_SUBNET_ID_1 \
  --tags Key=kubernetes.io/role/internal-elb,Value=1
aws ec2 create-tags \
  --resources $PRIVATE_SUBNET_ID_2 \
  --tags Key=kubernetes.io/role/internal-elb,Value=1
aws ec2 create-tags \
  --resources $PRIVATE_SUBNET_ID_3 \
  --tags Key=kubernetes.io/role/internal-elb,Value=1

¿Qué sigue?

Crea claves de KMS de AWS.