Diese Dokumentation bezieht sich auf die aktuelle Version von GKE on AWS, die im November 2021 veröffentlicht wurde. Weitere Informationen finden Sie in den Versionshinweisen.

AWS-VPC erstellen

GKE on AWS wird in einer Virtual Private Cloud (VPC) von AWS ausgeführt. Auf dieser Seite wird erläutert, wie Sie eine neue VPC für Ihren Cluster einrichten.

GKE on AWS erstellt und verwaltet Ressourcen in der von Ihnen angegebenen VPC. Sie müssen auch mehrere Subnetze innerhalb der VPC erstellen:

Bis zu drei Subnetze für die Knoten der Steuerungsebene
Ein Subnetz für den Knotenpool
Subnetze für Dienst-Load-Balancer von Kubernetes

Grafik: Beispiel-VPC

Führen Sie die folgenden Schritte aus, um die unten dargestellte VPC einzurichten. Für eigene Produktionsanwendungsfälle können Sie verschiedene IP-Bereiche, Verfügbarkeitszonen, Subnetze und Netzwerkzugriffslisten auswählen, die zu Ihren Arbeitslasten passen.

Das folgende Diagramm zeigt die Beispiel-VPC, die Sie bei der Ausführung dieser Schritte erstellen:

Grafik: Beispiel-VPC

In diesem Beispiel werden drei Verfügbarkeitszonen verwendet: Verfügbarkeitszone 1, Verfügbarkeitszone 2 und Verfügbarkeitszone 3. Wenn Sie beispielsweise eine VPC in der Region us-east-1 erstellen möchten, können diese auf us-east-1a, us-east-1b, us-east-1c gesetzt werden.
In jeder der drei Verfügbarkeitszonen gibt es ein öffentliches und ein privates Subnetz.
Replikate auf Steuerungsebene und Load-Balancer-Endpunkte sowie Knotenpools werden in den privaten Subnetzen erstellt.
Öffentliche Subnetze bieten ausgehenden Internetzugriff für die privaten Subnetze und die Endpunkte öffentlicher Load-Balancer.
Alle diese Subnetze sind für die automatische Subnetzerkennung getaggt. Interne Load-Balancer werden in den privaten Subnetzen und mit dem Internet verbundene Load-Balancer in den öffentlichen Subnetzen bereitgestellt.

VPC erstellen

Wählen Sie ein Präfix aus und bearbeiten Sie die Seitenvariable AMC_PREFIX im folgenden Befehl, um sie auf das ausgewählte Präfix festzulegen. Mit den folgenden Beispielbefehlen wird dieses Präfix automatisch an alle Verweise auf Ihre VPC und deren Ressourcen angehängt.
Erstellen Sie eine AWS Virtual Private Cloud (VPC):
```
aws --region AWS_REGION ec2 create-vpc \
    --cidr-block 10.0.0.0/16 \
    --tag-specifications 'ResourceType=vpc, Tags=[{Key=Name,Value=AMC_PREFIXVPC}]'
```
Ersetzen Sie Folgendes:
- AWS_REGION: Name der unterstützten AWS-Region, in der die VPC erstellt werden soll
- AMC_PREFIX: das VPC-Namenspräfix, das Sie für die VPC und deren Ressourcen ausgewählt haben

Speichern Sie die VPC-ID in einer Umgebungsvariablen und aktivieren Sie die von AWS bereitgestellte DNS-Unterstützung für die 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

Sie können auch andere DNS-Einstellungen für Ihre VPC verwenden. Weitere Informationen finden Sie unter AWS VPC-DNS.

Subnetze der Steuerungsebene

Sie können bis zu drei Subnetze für Replikate der Steuerungsebene konfigurieren. Wenn Sie weniger als drei Subnetze angeben, erstellt GKE on AWS drei Replikate der Steuerungsebene und verteilt sie auf die angegebenen Subnetze.

Cluster sind nur in Ihrer VPC privat. Der direkte eingehende Zugriff auf Cluster aus dem Internet ist nicht zulässig. GKE on AWS benötigt begrenzten ausgehenden Internetzugriff, um Cluster zu erstellen und zu verwalten. In diesem Beispiel wird ein Internetgateway für ausgehenden Zugriff verwendet.

Anforderungen an Subnetze

Subnetze müssen:

DNS-Adressen auflösen
Ausgehende TCP-Verbindungen an Port 443 an routingfähige IP-Adressen einrichten können
Eine Verbindung zu den folgenden Endpunkten herstellen können:

Endpunkt	Zweck
storage.googleapis.com	Zum Herunterladen aus Cloud Storage während der Installation
*.gcr.io	Zum Herunterladen aus Container Registry während der Installation
gkeconnect.googleapis.com	Zum Herstellen einer Verbindung zum Verwaltungsdienst
oauth2.googleapis.com	Für die Clusterauthentifizierung
sts.googleapis.com	Für die Clusterauthentifizierung
logging.googleapis.com	Zum Senden von Logs an Cloud Logging
monitoring.googleapis.com	Zum Senden von Messwerten an Cloud Monitoring
opsconfigmonitoring.googleapis.com`	Zum Senden von Ressourcenmetadaten an Cloud Monitoring
servicecontrol.googleapis.com	Für Cloud-Audit-Logging

Wenn Sie keine Subnetze für Ihre Instanzen auf Steuerungsebene haben, verwenden Sie die folgenden Befehle, um sie zu erstellen.

Private Subnetze erstellen

Erstellen Sie drei private Subnetze in den entsprechenden Verfügbarkeitszonen:

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

Ersetzen Sie Folgendes:

AWS_ZONE_1: Verfügbarkeitszone 1
AWS_ZONE_2: Verfügbarkeitszone 2
AWS_ZONE_3: Verfügbarkeitszone 3

Öffentliche Subnetze erstellen

Erstellen Sie drei öffentliche Subnetze. Diese verwenden Sie, um ausgehenden Internetzugriff für die privaten Subnetze bereitzustellen.

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

Ersetzen Sie Folgendes:

AWS_ZONE_1
AWS_ZONE_2
AWS_ZONE_3

Kennzeichnen Sie die Subnetze als öffentlich:

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

Internetgateway erstellen

Erstellen Sie ein Internet-Gateway, damit die öffentlichen Subnetze Zugriff auf das Internet haben:
```
aws --region AWS_REGION  ec2 create-internet-gateway \
  --tag-specifications 'ResourceType=internet-gateway, Tags=[{Key=Name,Value=AMC_PREFIXInternetGateway}]'
```
Ersetzen Sie AWS_REGION: der Name der AWS-Region, in der Ihre VPC erstellt wurde.

Hängen Sie das Internetgateway an Ihre VPC an:

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

Routingtabellen für öffentliche Subnetze konfigurieren

Erstellen Sie eine Routingtabelle für jedes der öffentlichen Subnetze.

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

Ordnen Sie die öffentlichen Routingtabellen den öffentlichen Subnetzen zu:

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

Erstellen Sie Standardrouten zum Internetgateway:

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

Weisen Sie jedem NAT-Gateway eine elastische IP-Adresse (EIP-Adresse) zu:

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

NAT-Gateways erstellen

Erstellen Sie in jedem der drei öffentlichen Subnetze ein NAT-Gateway:

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

Routingtabellen für private Subnetze konfigurieren

Erstellen Sie eine Routingtabelle für jedes private Subnetz:

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

Ordnen Sie die privaten Routingtabellen den privaten Subnetzen zu:

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

Erstellen Sie die Standardrouten zu NAT-Gateways:

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

Knotenpool-Subnetze

Jeder Knotenpool wird in einem einzelnen Subnetz platziert. Sie können mehrere Knotenpools in einem Subnetz platzieren. Die Anzahl der Knoten und Knotenpools, die Sie erstellen können, ist durch den im Subnetz verfügbaren IP-Adressbereich begrenzt.

Jedes Knotenpool-Subnetz muss:

Die gleichen Anforderungen für ausgehenden Internettraffic erfüllen, wie für Ihre Subnetze der Steuerungsebene.
Ausreichend IP-Adressbereich haben, um die Größe des Knotenpools abzudecken.
Die Option „Öffentliche IP-Adressen automatisch zuweisen“ ist nicht aktiviert

Die zuvor erstellten privaten Subnetze erfüllen die Anforderungen sowohl für Subnetze auf Steuerungsebene als auch für Knotenpool-Subnetze.

Subnetze des Dienst-Load-Balancers

Wenn Sie Netzwerk-Load-Balancer oder HTTP-Load-Balancer erstellen, sollten Sie Tag-Load-Balancer-Subnetze für die automatische Erkennung erstellen.

Taggen Sie die öffentlichen Subnetze mit 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

Taggen Sie die privaten Subnetze mit 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

Nächste Schritte

AWS-KMS-Schlüssel erstellen