Crear una VPC de AWS

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

GKE en AWS crea y administra recursos dentro de la VPC que especifique. También debe 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 carga de servicios de Kubernetes

Esta página está dirigida a especialistas en redes que desean instalar, configurar y dar soporte a equipos de red. Para obtener más información sobre roles comunes y ejemplos de tareas que mencionamos en Google Cloud contenido, consulte Roles y tareas de usuario comunes de GKE Enterprise .

Ejemplo de VPC

Siga estos pasos para configurar la VPC que se muestra a continuación. Para sus casos de uso en producción, puede elegir diferentes rangos de IP, zonas de disponibilidad, subredes y listas de control de acceso a la red que se adapten a sus cargas de trabajo.

El siguiente diagrama muestra la VPC de muestra que se crea al seguir estos pasos:

Ejemplo de VPC

  • Este ejemplo utiliza 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 , estas podrían configurarse 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 subred privada.

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

  • Las subredes públicas proporcionan acceso a Internet saliente para las subredes privadas y los puntos finales del balanceador de carga público.

  • Todas estas subredes están etiquetadas para el autodescubrimiento de subredes . Se instalarán balanceadores de carga internos en las subredes privadas y balanceadores de carga con conexión a internet en las subredes públicas.

Crea tu VPC

  1. Elija un prefijo y edite la variable de página AMC_PREFIX en el siguiente comando para configurarla con el prefijo seleccionado. Los siguientes comandos de ejemplo adjuntarán automáticamente este prefijo a todas las referencias a su VPC y sus recursos.

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

    Reemplace lo siguiente:

    • AWS_REGION : el nombre de la región de AWS compatible para crear la VPC en
    • AMC_PREFIX : el prefijo del nombre de VPC que ha elegido para su VPC y sus recursos

  3. Guarde su ID de VPC en una variable de entorno y habilite la compatibilidad 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 puede usar diferentes configuraciones de DNS para su VPC. Para obtener más información, consulte DNS de AWS VPC .

Subredes del plano de control

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

Los clústeres son privados para su VPC. No se permite el acceso entrante directo a los clústeres desde Internet. GKE en AWS requiere un acceso saliente limitado a Internet para crear y administrar clústeres. Este ejemplo utiliza una puerta de enlace de Internet para el acceso saliente.

Requisitos de subred

Las subredes deben

  • Ser capaz de resolver direcciones DNS
  • Poder establecer conexiones TCP salientes en el puerto 443 a direcciones IP enrutables
  • Poder conectarse a los siguientes puntos finales:
Punto final Objetivo
almacenamiento.googleapis.com Para descargar desde el almacenamiento en la nube durante la instalación
*.gcr.io Para descargar desde Container Registry durante la instalación
gkeconnect.googleapis.com Para conectarse al servicio de administración
oauth2.googleapis.com Para la autenticación de clúster
sts.googleapis.com Para la autenticación de clúster
logging.googleapis.com Para enviar registros a Cloud Logging
monitoreo.googleapis.com Para enviar métricas a Cloud Monitoring
opsconfigmonitoring.googleapis.com` Para enviar metadatos de recursos a Cloud Monitoring
servicecontrol.googleapis.com Para el registro de auditoría en la nube

Si no tiene subredes para las instancias del plano de control, utilice los siguientes comandos para crearlas.

Crear subredes privadas

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

Reemplace lo siguiente:

Crear subredes públicas

  1. Cree tres subredes públicas. Estas se utilizará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}]'

    Reemplace lo siguiente:

    • AWS_ZONE_1
    • AWS_ZONE_2
    • AWS_ZONE_3

  2. Marcar 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 puerta de enlace a Internet

  1. Cree una puerta de enlace a 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}]'

    Reemplace AWS_REGION : el nombre de la región de AWS donde se creó su VPC .

  2. Conecte la puerta de enlace de Internet a su 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 para subredes públicas

  1. Cree 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. Asociar 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. Crear 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

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

Crear puertas de enlace NAT

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

Configurar las tablas de enrutamiento para subredes privadas

  1. Cree 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. Asociar las tablas de rutas privadas 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

  3. Cree las rutas predeterminadas para 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 ubica en una sola subred. Se pueden ubicar varios grupos de nodos en una subred. La cantidad de nodos y grupos de nodos que se pueden crear está limitada por el rango de direcciones IP disponible en la subred.

Cada subred del grupo de nodos debe:

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

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

Subredes del balanceador de carga de servicio

Si está creando balanceadores de carga de red o balanceadores de carga HTTP , etiquete las subredes del balanceador de carga para el descubrimiento automático.

Etiquete 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

Etiquete 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?

Crear claves AWS KMS .