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.

Diese Seite wurde von der Cloud Translation API übersetzt.

Anwendung in GKE on AWS bereitstellen

Auf dieser Seite finden Sie eine Kurzanleitung zum Erstellen eines Clusters und eines Knotenpools für die Bereitstellung einer Beispielanwendung mit GKE on AWS.

Kurzanleitung für Cluster mit Terraform

Sie können mit Terraform einen Cluster und einen Knotenpool erstellen. Vor dem Erstellen des Clusters bereiten die Terraform-Skripts auch Ihre AWS-VPC vor.

Weitere Informationen zu Terraform in einer AWS-Umgebung finden Sie in der Referenz zum Terraform-Cluster und der Terraform-Knotenpoolreferenz.

Fahren Sie nach dem Erstellen einer VPC und eines Clusters mit Terraform mit Anwendung im Cluster bereitstellen fort, um eine Beispielanwendung bereitzustellen.

Kurzanleitung für Cluster ohne Terraform

Wenn Sie Ihre AWS-VPC vorbereiten und einen Cluster und Knotenpool ohne Terraform erstellen möchten, folgen Sie dieser Anleitung.

Hinweise

Bevor Sie einen Cluster erstellen, müssen Sie die Voraussetzungen erfüllen. Insbesondere müssen Sie die folgenden Ressourcen bereitstellen:

Eine AWS-VPC, in der der Cluster ausgeführt wird.
Bis zu drei AWS-Subnetze für die drei Replikate der Steuerungsebene. Jedes Subnetz muss sich in einer anderen AWS-Verfügbarkeitszone befinden.
Die AWS-IAM-Rolle, die GKE on AWS beim Verwalten Ihres Clusters übernimmt. Hierfür ist ein bestimmter Satz von IAM-Berechtigungen erforderlich.
Symmetrische KMK-Schlüssel in KMS für die Verschlüsselung inaktiver Clusterdaten (etcd) und für die Konfiguration.
Das AWS-IAM-Instanzprofil für jedes Replikat der Steuerungsebene. Hierfür ist ein bestimmter Satz von IAM-Berechtigungen erforderlich.
Ein EC2-SSH-Schlüsselpaar (optional), wenn Sie SSH-Zugriff auf die EC2-Instanzen benötigen, die jedes Replikat der Steuerungsebene ausführen.

Es liegt in Ihrer Verantwortung, diese Ressourcen zu erstellen und zu verwalten, die von allen GKE on AWS-Clustern gemeinsam genutzt werden können. Alle anderen zugrunde liegenden clusterbezogenen AWS-Ressourcen werden von GKE on AWS verwaltet.

Standardeinstellungen für die gcloud CLI festlegen

Verwenden Sie die gcloud CLI, um die Standardeinstellungen für Ihr Standardprojekt und Ihre Google Cloud-Region zu konfigurieren.

Ihr Projekt hat eine Projekt-ID als eindeutige Kennzeichnung. Wenn Sie ein Projekt erstellen, können Sie die automatisch generierte Projekt-ID verwenden oder eine eigene erstellen.

Ihre Google Cloud-Region ist ein Standort, von dem aus Ihre Cluster verwaltet werden. z. B. us-west1. Weitere Informationen finden Sie unter Verwaltungsregionen.

Wenn Sie diese Standardeinstellungen konfigurieren, müssen Sie sie beim Ausführen der Google Cloud CLI nicht angeben. Um Einstellungen festzulegen oder Standardeinstellungen zu überschreiben können Sie auch die Flags --project und --location an die Google Cloud CLI übergeben.

Wenn Sie GKE on AWS-Ressourcen nach der Konfiguration Ihres Standardprojekts und Standorts erstellen, werden die Ressourcen automatisch in diesem Projekt und am Standort erstellt.

So legen Sie Standardeinstellungen fest:

Legen Sie das Standardprojekt fest:
```
gcloud config set project PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID.
Legen Sie den standardmäßigen Verwaltungsort fest:
```
gcloud config set container_aws/location GOOGLE_CLOUD_LOCATION
```
Ersetzen Sie GOOGLE_CLOUD_LOCATION durch Ihren Standort, z. B. us-west1.

CIDR-Bereiche für den Cluster auswählen

Kubernetes erfordert zwei CIDR-Bereiche, die für den Cluster bereitgestellt werden müssen. Diese CIDR-Bereiche sollten so ausgewählt werden, dass sie sich nicht mit den von Ihren VPC-Subnetzen verwendeten CIDR-Bereichen überschneiden. Sie sollten groß genug für die maximal erwartete Größe Ihres Clusters sein.

CIDR-Bereich der Pod-Adresse: Wenn ein neuer Pod erstellt wird, wird ihm eine IP-Adresse aus diesem Bereich zugewiesen. Beispielbereich: 192.168.208.0/20
CIDR-Bereich der Adresse: Wenn ein neuer Service erstellt wird, wird ihm eine IP-Adresse aus diesem Bereich zugewiesen. Beispielbereich: 192.168.224.0/20

Cluster erstellen

Verwenden Sie den folgenden Befehl, um einen Cluster unter GKE on AWS zu erstellen. Weitere Informationen zu diesem Befehl, einschließlich der optionalen Parameter, finden Sie auf der Referenzseite gcloud container aws create.

gcloud container aws clusters create aws-cluster-0 \
    --cluster-version 1.29.3-gke.600 \
    --aws-region AWS_REGION \
    --fleet-project FLEET_PROJECT_ID \
    --vpc-id VPC_ID \
    --subnet-ids CONTROL_PLANE_SUBNET_1,CONTROL_PLANE_SUBNET_2,CONTROL_PLANE_SUBNET_3 \
    --pod-address-cidr-blocks POD_CIDR_BLOCK \
    --service-address-cidr-blocks SERVICE_CIDR_BLOCK \
    --role-arn API_ROLE_ARN \
    --iam-instance-profile CONTROL_PLANE_PROFILE \
    --database-encryption-kms-key-arn DB_KMS_KEY_ARN \
    --config-encryption-kms-key-arn CONFIG_KMS_KEY_ARN \
    --tags "google:gkemulticloud:cluster=aws-cluster-0"

Ersetzen Sie Folgendes:

AWS_REGION: die AWS-Region, in der der Cluster erstellt werden soll.
FLEET_PROJECT_ID: das Fleet-Hostprojekt, in dem der Cluster registriert wird.
VPC_ID: Die ID der AWS-VPC für diesen Cluster, die Sie im vorherigen Schritt VPC erstellen eingerichtet haben
CONTROL_PLANE_SUBNET_1, CONTROL_PLANE_SUBNET_2, CONTROL_PLANE_SUBNET_3: die Subnetz-IDs für die drei Instanzen der Steuerungsebene des Clusters, die Sie im erforderlichen Schritt Private Subnetze erstellen erstellt haben.
POD_CIDR_BLOCK: den CIDR-Adressbereich für die Pods Ihres Clusters
SERVICE_CIDR_BLOCK: der CIDR-Adressbereich für die Dienste des Clusters
API_ROLE_ARN: der ARN der IAM-Rolle für den GKE-Multi-Cloud-Dienst, den Sie im erforderlichen Schritt GKE Multi-Cloud API-Rolle erstellen erstellt haben
CONTROL_PLANE_PROFILE: Profilname der IAM-Instanz, die dem Cluster zugeordnet ist, den Sie im vorherigen Schritt Rolle "Steuerungsebene erstellen" ausgewählt haben.
DB_KMS_KEY_ARN: Der Amazon-Ressourcenname (ARN) eines der AWS-KMS-Schlüssel, den Sie im erforderlichen Schritt AWS-KMS-Schlüssel erstellen erstellt haben
CONFIG_KMS_KEY_ARN: Der Amazon Resource Name (ARN) der anderen AWS KMS-Schlüssel, die Sie im vorherigen Schritt AWS-KMS-Schlüssel erstellen erstellt haben

Falls vorhanden, wendet der Parameter --tags das angegebene AWS-Tag auf alle zugrunde liegenden AWS-Ressourcen an, die von GKE on AWS verwaltet werden. In diesem Beispiel werden die Knoten der Steuerungsebene mit dem Namen des Clusters getaggt, zu dem sie gehören.

Knotenpool erstellen

Verwenden Sie den folgenden Befehl, um einen Knotenpool zu erstellen:

gcloud container aws node-pools create pool-0 \
    --cluster aws-cluster-0 \
    --node-version 1.29.3-gke.600 \
    --min-nodes 1 \
    --max-nodes 5 \
    --max-pods-per-node 110 \
    --root-volume-size 50 \
    --subnet-id NODEPOOL_SUBNET_ID \
    --iam-instance-profile NODEPOOL_PROFILE \
    --config-encryption-kms-key-arn CONFIG_KMS_KEY_ARN \
    --ssh-ec2-key-pair EC2_KEY_PAIR \
    --tags "google:gkemulticloud:cluster=aws-cluster-0"

Ersetzen Sie Folgendes:

NODEPOOL_SUBNET_ID: Die ID eines der privaten Subnetze, das Sie im Voraussetzungsschritt Private Subnetze erstellen erstellt haben
NODEPOOL_PROFILE: Der Profilname der IAM-Instanz für die EC2-Instanzen im Knotenpool, die Sie im vorherigen Schritt IAM-Rolle für Knotenpool erstellen ausgewählt haben
CONFIG_KMS_KEY_ARN: der Amazon-Ressourcenname (ARN) des AWS KMS-Schlüssels zum Verschlüsseln von Nutzerdaten.
EC2_KEY_PAIR (optional): Der Name des EC2-Schlüsselpaars, das für den SSH-Zugriff erstellt wurde (optional), das Sie im erforderlichen Schritt SSH-Schlüsselpaar erstellen erstellt haben.

zusätzliche Schritte ausführen.

Clusterstatus ansehen

Nachdem Sie einen Cluster und einen Knotenpool erstellt haben, können Sie den Status eines Clusters über die Google Cloud-Befehlszeile oder die Google Cloud Console ansehen. Wählen Sie zum Aufrufen des Clusterstatus aus, ob Sie die Google Cloud-Befehlszeile oder die Google Cloud Console verwenden, und führen Sie die folgenden Schritte aus:

gcloud

Verwenden Sie den Befehl gcloud container aws clusters describe, um Details zu Ihrem Cluster abzurufen:

gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION

Dabei gilt:

CLUSTER_NAME: der Name des Clusters
GOOGLE_CLOUD_LOCATION: der Name des Google Cloud-Standorts, der den Cluster verwaltet.

Google Cloud Console

Rufen Sie in der Google Cloud Console die Seite Google Kubernetes Engine-Cluster auf.

Zu GKE-Clustern
Die Cluster werden nach Name und Standort aufgelistet.
Klicken Sie auf den Namen des Clusters. Es wird ein Bereich mit Informationen zum Cluster angezeigt, einschließlich dessen Status und aktivierter Features.

Authentifizierungsdaten für den Cluster abrufen

Nach dem Erstellen des Clusters müssen Sie Anmeldedaten für die Authentifizierung abrufen, damit Sie mit dem Cluster interagieren können.

gcloud container aws clusters get-credentials aws-cluster-0

Mit diesem Befehl wird kubectl für den Zugriff auf den Cluster konfiguriert, den Sie mit Connect-Gateway erstellt haben. Sie benötigen mindestens einen Knotenpool, um das Connect-Gateway zu verwenden, da es auf dem Connect-Agent basiert, der als Deployment im Cluster ausgeführt wird.

Anwendung im Cluster bereitstellen

Nachdem Sie einen Cluster erstellt haben, können Sie eine containerisierte Anwendung bereitstellen. Für diese Kurzanleitung können Sie unsere Beispielwebanwendung hello-app bereitstellen.

Sie verwenden Kubernetes-Objekte, um die Clusterressourcen zu erstellen und zu verwalten. Sie verwenden das Deployment-Objekt für die Bereitstellung zustandsloser Anwendungen wie Webserver. Über Dienstobjekte werden Regeln und Load-Balancer für den Zugriff auf Ihre Anwendung aus dem Internet festgelegt.

Deployment erstellen

Zum Ausführen von hello-app in Ihrem Cluster müssen Sie die Anwendung mit folgendem Befehl bereitstellen:

kubectl create deployment hello-server --image=us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0

Mit dem Kubernetes-Befehl kubectl create deployment wird ein Deployment mit dem Namen hello-server erstellt. Auf dem Pod des Deployments wird das Container-Image hello-app ausgeführt.

Dabei gilt:

--image gibt das bereitzustellende Container-Image an. In diesem Fall ruft der Befehl das Beispiel-Image aus einem us-docker.pkg.dev/google-samples/containers/gke/hello-app-Artifact Registry-Repository ab. :1.0 gibt die jeweils abzurufende Image-Version an. Wenn Sie keine Version angeben, wird das mit latest getaggte Image verwendet.

Deployment freigeben

Nach dem Deployment der Anwendung müssen Sie sie für das Internet freigeben, damit Nutzer darauf zugreifen können. Sie können Ihre Anwendung bereitstellen, indem Sie einen Dienst erstellen, eine Kubernetes-Ressource, die Ihre Anwendung für externen Datenverkehr verfügbar macht.

Führen Sie den folgenden kubectl expose-Befehl aus, um die Anwendung freizugeben:

kubectl expose deployment hello-server --type LoadBalancer --port 80 --target-port 8080

Wenn Sie das Flag --type LoadBalancer übergeben, wird ein AWS-Load-Balancer für den Container erstellt. Das Flag --port initialisiert den öffentlichen Port 80 für das Internet und das Flag --target-port leitet den Traffic zu Port 8080 der Anwendung weiter.

Load-Balancer werden nach den Preisen für AWS-Load-Balancer abgerechnet.

Anwendung prüfen und ansehen

Sehen Sie sich die ausgeführten Pods mit kubectl get pods an:
```
kubectl get pods
```
Auf dem Cluster müsste ein hello-server-Pod ausgeführt werden.
Sehen Sie sich den Dienst hello-server mit kubectl get service an:
```
kubectl get service hello-server
```
Kopieren Sie in der Ausgabe dieses Befehls die externe IP-Adresse aus der Spalte EXTERNAL-IP.

Hinweis: Sie müssen möglicherweise mehrere Minuten auf die externe IP-Adresse des Diensts warten. Wenn die externe IP-Adresse der Anwendung <pending> lautet, führen Sie kubectl get service noch einmal aus.
Rufen Sie die Anwendung in Ihrem Webbrowser auf. Geben Sie dazu die externe IP-Adresse mit dem freigegebenen Port ein:
```
http://EXTERNAL-IP
```

Sie haben gerade eine containerisierte Webanwendung in GKE on AWS bereitgestellt.

Bereinigen

Löschen Sie den Dienst und das Deployment der Anwendung:

kubectl delete service hello-server
kubectl delete deployment hello-server

Löschen Sie den Knotenpool mit gcloud container aws node-pools delete:

gcloud container aws node-pools delete pool-0 --cluster aws-cluster-0

Löschen Sie den Cluster mit gcloud container aws clusters delete:
```
gcloud container aws clusters delete aws-cluster-0
```

Nächste Schritte

Anthos Config Management installieren