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 para tu clúster.

GKE en AWS crea y gestiona recursos en 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 de balanceadores de carga de servicios de Kubernetes

Esta página está dirigida a especialistas en redes que quieran instalar, configurar y ofrecer asistencia para equipos de redes. Para obtener más información sobre los roles habituales y las tareas de ejemplo a las que hacemos referencia en el contenido de Google Cloud , consulta Roles y tareas de usuario habituales de GKE.

VPC de ejemplo

Sigue estos pasos para configurar la VPC que se muestra a continuación. En tus casos prácticos de producción, puedes elegir diferentes intervalos 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 ejemplo que se crea al seguir estos pasos:

• En este ejemplo se usan tres zonas de disponibilidad: Zona de disponibilidad 1, Zona de disponibilidad 2 y Zona de disponibilidad 3. Por ejemplo, para crear una VPC en la región us-east-1, se pueden definir como us-east-1a, us-east-1b y us-east-1c.

• En cada una de las tres zonas de disponibilidad hay una subred pública y una subred privada.

• Las réplicas del plano de control y los endpoints del balanceador de carga, así como los grupos de nodos, se crean en las subredes privadas.

• Las subredes públicas proporcionan acceso a Internet de salida para las subredes privadas y los endpoints de balanceadores de carga públicos.

• Todas estas subredes están etiquetadas para la detección automática de subredes. Los balanceadores de carga internos se aprovisionarán en las subredes privadas y los balanceadores de carga orientados a Internet, en las subredes públicas.

Crea tu VPC

1. Elige un prefijo y edita la variable de página AMC_PREFIX en el comando de abajo para asignarle el prefijo que hayas elegido. Los comandos de ejemplo que se muestran a continuación añadirán automáticamente este prefijo a todas las referencias a tu VPC y sus recursos.

2. 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}]'
   

   Haz los cambios siguientes:

   • AWS_REGION: el nombre de la región de AWS admitida en la que se va a crear la VPC.
   • AMC_PREFIX: el prefijo de nombre de VPC que has elegido para tu VPC y sus recursos

3. Guarda el ID de la VPC en una variable de entorno y habilita la compatibilidad con 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 puede usar ajustes de DNS diferentes para su 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 on AWS creará tres réplicas del plano de control y las distribuirá entre las subredes especificadas.

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

Requisitos de las subredes

Las subredes deben

• Poder resolver direcciones DNS
• Poder establecer conexiones TCP salientes en el puerto 443 a direcciones IP enrutable
• Poder conectarse a los siguientes endpoints:

Endpoint	Finalidad
storage.googleapis.com	Para descargar desde Cloud Storage durante la instalación
*.gcr.io	Descargar desde Container Registry durante la instalación
gkeconnect.googleapis.com	Para conectarse al servicio de gestión
oauth2.googleapis.com	Para la autenticación de clústeres
sts.googleapis.com	Para la autenticación de clústeres
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	Registro de auditoría de Cloud

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

Crear subredes privadas

Crea tres subredes privadas en sus correspondientes zonas de disponibilidad:

   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}]'

Haz los cambios siguientes:

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

Crear subredes públicas

1. Crea tres subredes públicas. Se usarán para 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}]'
   

   Haz los cambios siguientes:

   • AWS_ZONE_1
   • AWS_ZONE_2
   • AWS_ZONE_3

2. 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
   

Crear una pasarela de Internet

1. Crea una pasarela 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}]'
   

   Sustituye AWS_REGION por el nombre de la región de AWS en la que se creó tu VPC.

2. Asocia la pasarela 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
   

Configurar las tablas de enrutamiento de las subredes públicas

1. Crea una tabla de rutas 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}]'
   

2. Asocia las tablas de rutas públicas 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
   

3. Crea rutas predeterminadas a la pasarela 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
   

4. Asigna una dirección IP elástica (EIP) a cada pasarela 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}]'
   

Crear pasarelas de NAT

Crea una pasarela 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}]'

Configurar las tablas de enrutamiento de las subredes privadas

1. Crea una tabla de rutas 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}]'
   

2. Asocia las tablas de rutas privadas a 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
   

3. Crea las rutas predeterminadas a las pasarelas 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 de grupos de nodos

Cada grupo de nodos se coloca en una única subred. Puedes colocar varios grupos de nodos en una subred. El número de nodos y de grupos de nodos que puedes crear está limitado por el intervalo de direcciones IP disponible en la subred.

Cada subred de grupo de nodos debe cumplir los siguientes requisitos:

• Cumplir los mismos requisitos de acceso a Internet saliente que las 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 IPs públicas automáticamente"

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

Subredes de balanceador de carga de servicio

Si vas a crear balanceadores de carga de red o balanceadores de carga HTTP, etiqueta las subredes de los balanceadores de carga para que se detecten automáticamente.

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

Siguientes pasos

Crea claves de KMS de AWS.