Creazione di un VPC AWS

GKE su AWS viene eseguito in un VPC (Virtual Private Cloud) AWS. Questa pagina spiega come configurare un nuovo VPC per il cluster.

GKE su AWS crea e gestisce le risorse all'interno del VPC da te specificato. Devi anche creare diverse subnet all'interno del VPC:

• Fino a tre subnet per i nodi del piano di controllo
• Una subnet per il pool di nodi
• Subnet per i bilanciatori del carico del servizio Kubernetes

VPC di esempio

Segui questi passaggi per configurare il VPC illustrato di seguito. Per i tuoi casi d'uso in produzione, puoi scegliere diversi intervalli IP, zone di disponibilità, subnet ed elenchi di controllo dell'accesso dell'accesso alla rete adatti ai tuoi carichi di lavoro.

Il seguente diagramma mostra il VPC di esempio che crei quando segui questi passaggi:

• Questo esempio utilizza tre zone di disponibilità: Zona di disponibilità 1, Zona di disponibilità 2 e Zona di disponibilità 3. Ad esempio, per creare un VPC nella regione us-east-1, potrebbero essere impostati su us-east-1a, us-east-1b, us-east-1c.

• All'interno di ciascuna delle tre zone di disponibilità sono presenti una subnet pubblica e una privata.

• Le repliche del piano di controllo, gli endpoint del bilanciatore del carico e i pool di nodi vengono creati nelle subnet private.

• Le subnet pubbliche forniscono l'accesso a internet in uscita per le subnet private e gli endpoint pubblici del bilanciatore del carico.

• Tutte queste subnet sono codificate per il rilevamento automatico delle subnet. Verrà eseguito il provisioning dei bilanciatori del carico interni nelle subnet private e nei bilanciatori del carico rivolti a internet nelle subnet pubbliche.

Crea il tuo VPC

1. Scegli un prefisso e modifica la variabile di pagina AMC_PREFIX nel comando seguente per impostarla con il prefisso che hai scelto. I comandi di esempio riportati di seguito collegheranno automaticamente questo prefisso a tutti i riferimenti al VPC e alle relative risorse.

2. Crea un VPC (Virtual Private Cloud) 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}]'
   

   Sostituisci quanto segue:

   • AWS_REGION: il nome della regione AWS supportata in cui creare il VPC
   • AMC_PREFIX: il prefisso del nome del VPC che hai scelto per il VPC e le sue risorse

3. Salva il tuo ID VPC in una variabile di ambiente e abilita il supporto DNS fornito da AWS per il 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
   

   Puoi anche utilizzare impostazioni DNS diverse per il tuo VPC. Per ulteriori informazioni, consulta DNS VPC AWS.

Subnet del piano di controllo

Puoi configurare fino a tre subnet per le repliche del piano di controllo. Se specifichi meno di tre subnet, GKE su AWS crea tre repliche del piano di controllo e le distribuisce tra le subnet specificate.

I cluster sono privati per il VPC. Non è consentito l'accesso diretto ai cluster da internet. GKE su AWS richiede un accesso a internet in uscita limitato per creare e gestire i cluster. Questo esempio utilizza un gateway internet per l'accesso in uscita.

Requisiti delle subnet

Le subnet devono

• Essere in grado di risolvere gli indirizzi DNS
• Essere in grado di stabilire connessioni TCP in uscita sulla porta 443 verso indirizzi IP instradabili
• Essere in grado di connettersi ai seguenti endpoint:

Endpoint	Finalità
storage.googleapis.com	Scaricare da Cloud Storage durante l'installazione
*.gcr.io	Scaricare da Container Registry durante l'installazione
gkeconnect.googleapis.com	Per connettersi al servizio di gestione
oauth2.googleapis.com	Per l'autenticazione del cluster
sts.googleapis.com	Per l'autenticazione del cluster
logging.googleapis.com	Per l'invio dei log a Cloud Logging
monitoring.googleapis.com	Per l'invio di metriche a Cloud Monitoring
opsconfigmonitoring.googleapis.com`	Per l'invio di metadati delle risorse a Cloud Monitoring
servicecontrol.googleapis.com	Per l'audit logging di Cloud

Se non hai subnet per le istanze del piano di controllo, utilizza i comandi seguenti per crearle.

Crea subnet private

Crea tre subnet private nelle zone di disponibilità corrispondenti:

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

Sostituisci quanto segue:

• AWS_ZONE_1: Zona di disponibilità 1
• AWS_ZONE_2: Zona di disponibilità 2
• AWS_ZONE_3: Zona di disponibilità 3

Crea subnet pubbliche

1. Creare tre subnet pubbliche. Verranno usate per fornire l'accesso a internet in uscita per le subnet private.

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

   Sostituisci quanto segue:

   • AWS_ZONE_1
   • AWS_ZONE_2
   • AWS_ZONE_3

2. Contrassegna le subnet come pubbliche:

   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 un gateway internet

1. Crea un gateway internet in modo che le subnet pubbliche possano accedere a internet:

   aws --region AWS_REGION  ec2 create-internet-gateway \
     --tag-specifications 'ResourceType=internet-gateway, Tags=[{Key=Name,Value=AMC_PREFIXInternetGateway}]'
   

   Sostituisci AWS_REGION: il nome della regione AWS in cui è stato creato il VPC.

2. Collega il gateway internet al tuo 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 le tabelle di routing per le subnet pubbliche

1. Crea una tabella di route per ciascuna delle subnet pubbliche.

   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. Associa le tabelle delle route pubbliche alle subnet pubbliche:

   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 route predefinite per il gateway 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. Alloca un indirizzo Elastic IP (EIP) per ciascun gateway 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 gateway NAT

Crea un gateway NAT in ciascuna delle tre subnet pubbliche:

   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 le tabelle di routing per le subnet private

1. Crea una tabella di route per ogni subnet privata:

   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. Associa le tabelle delle route private alle subnet private:

   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 le route predefinite ai gateway 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
   

Subnet di pool di nodi

Ogni pool di nodi si trova in un'unica subnet. Puoi inserire più pool di nodi in una subnet. Il numero di nodi e pool di nodi che puoi creare è limitato dall'intervallo di indirizzi IP disponibile nella subnet.

Ogni subnet del pool di nodi deve:

• Soddisfa gli stessi requisiti di accesso a internet in uscita delle subnet del piano di controllo
• Avere uno spazio di indirizzi IP sufficiente per coprire le dimensioni del pool di nodi
• Non avere l'opzione "Assegna automaticamente IP pubblici" abilitata

Le subnet private create in precedenza soddisfano i requisiti sia per le subnet del piano di controllo sia per le subnet dei pool di nodi.

Subnet bilanciatore del carico del servizio

Se stai creando bilanciatori del carico di rete o bilanciatori del carico HTTP, tagga le subnet del bilanciatore del carico per il rilevamento automatico.

Applica il tagging alle subnet pubbliche 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

Applica il tagging alle subnet private 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

Passaggi successivi

Crea chiavi KMS di AWS.