Creazione di un VPC AWS

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

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

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

Questa pagina è rivolta agli specialisti di networking che vogliono installare, configurare e supportare le apparecchiature di rete. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei contenuti di Google Cloud , consulta Ruoli e attività comuni degli utenti GKE.

VPC di esempio

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

Il seguente diagramma mostra il VPC di esempio che crei seguendo 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, questi valori potrebbero essere impostati su us-east-1a, us-east-1b e us-east-1c.

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

• Le repliche del control plane e gli endpoint del bilanciatore del carico, nonché 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 del bilanciatore del carico pubblico.

• Tutte queste subnet sono taggate per il rilevamento automatico delle subnet. I bilanciatori del carico interni verranno sottoposti a provisioning nelle subnet private e i bilanciatori del carico accessibili da internet nelle subnet pubbliche.

Crea il tuo VPC

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

2. Crea un Virtual Private Cloud (VPC) 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 VPC che hai scelto per la tua VPC e le relative risorse

3. Salva l'ID VPC in una variabile di ambiente e attiva 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 maggiori informazioni, consulta DNS VPC AWS.

Subnet del control plane

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

I cluster sono privati per il tuo VPC. L'accesso in entrata diretto ai cluster da internet non è consentito. 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 della subnet

Le subnet devono

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

Endpoint	Finalità
storage.googleapis.com	Per scaricare da Cloud Storage durante l'installazione
*.gcr.io	Per 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 di 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 seguenti comandi per crearle.

Crea subnet private

Crea tre subnet private nelle rispettive zone di disponibilità:

   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. Crea tre subnet pubbliche. Verranno utilizzati 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 abbiano accesso 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 tuo 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 di routing 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 al 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. Assegna un indirizzo IP elastico (EIP) per ogni 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 ognuna 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 routing 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 di 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 del node pool

Ogni pool di nodi viene inserito in una singola 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:

• Soddisfare gli stessi requisiti di accesso a internet in uscita delle subnet del control plane
• Avere 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 del pool di nodi.

Subnet del 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.

Tagga le 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

Tagga le 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 AWS KMS.