Creazione di un VPC AWS

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

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

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

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

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 e liste di controllo dell'accesso alla rete diversi in base ai tuoi carichi di lavoro.

Il seguente diagramma mostra la VPC di esempio che crei seguendo questi passaggi:

VPC di esempio

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

  • In ciascuna delle tre zone di disponibilità è presente una subnet pubblica e una subnet privata.

  • Le repliche del piano di controllo 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 per gli endpoint pubblici del bilanciatore del carico.

  • Tutte queste subnet sono contrassegnate per il rilevamento automatico delle subnet. Il provisioning dei bilanciatori del carico interni verrà eseguito nelle subnet private e quello dei bilanciatori del carico per internet nelle subnet pubbliche.

Crea il tuo VPC

  1. Scegli un prefisso e modifica la variabile pagina AMC_PREFIX nel comando riportato di seguito per impostarla sul prefisso che hai scelto. I comandi di esempio riportati di seguito collegheranno automaticamente questo prefisso a tutti i riferimenti al tuo VPC e alle sue 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 della VPC scelto per la 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 la tua VPC. Per ulteriori informazioni, consulta DNS VPC AWS.

Subnet del control plane

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 nelle subnet specificate.

I cluster sono privati per la tua 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 ad indirizzi IP routabili
  • Devi essere in grado di connetterti 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 connetterti 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 delle metriche a Cloud Monitoring
opsconfigmonitoring.googleapis.com` Per l'invio dei metadati delle risorse a Cloud Monitoring
servicecontrol.googleapis.com Per l'audit logging di Cloud

Se non hai sottoreti per le istanze del piano di controllo, utilizza i seguenti comandi 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:

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

Creare un gateway internet

  1. Crea un gateway internet in modo che le sottoreti 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 con il nome della regione AWS in cui è stato creato il tuo VPC.

  2. Collega il gateway internet alla tua 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 routing 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 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. 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 ciascuna delle tre sottoreti 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 per i 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 sottorete. Puoi posizionare 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 piano di controllo
  • Avere spazio di indirizzi IP sufficiente per coprire le dimensioni del pool di nodi
  • L'opzione "Assegna automaticamente gli IP pubblici" non è 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 crei bilanciatori del carico di rete o bilanciatori del carico HTTP, tagga le sottoreti del bilanciatore del carico per l'autoscoperta.

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.