Container-Webanwendung bereitstellen

Autopilot Standard

In dieser Anleitung wird gezeigt, wie Sie eine Webanwendung in einem Docker-Container-Image verpacken und dieses Container-Image in einem GKE-Cluster (Google Kubernetes Engine) ausführen. Dann stellen Sie die Webanwendung als Replikatsatz mit Load-Balancing bereit, der sich an die Bedürfnisse Ihrer Nutzer anpassen lässt.

Ziele

Beispielwebanwendung in ein Docker-Image verpacken
das Docker-Image in Artifact Registry hochladen
einen GKE-Cluster installieren
Beispielanwendung im Cluster bereitstellen
Autoscaling für das Deployment verwalten
Beispielanwendung im Internet freigeben
eine neue Version der Beispielanwendung bereitstellen

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweis

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Enable the Compute Engine, Artifact Registry, and Google Kubernetes Engine APIs.

Enable the APIs

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Enable the Compute Engine, Artifact Registry, and Google Kubernetes Engine APIs.

Enable the APIs

Cloud Shell aktivieren

Die in dieser Anleitung verwendeten Befehlszeilentools gcloud, docker und kubectl sind in Cloud Shell vorinstalliert.

Öffnen Sie die Google Cloud Console.
Klicken Sie im oberen Bereich der Google Cloud Console auf Cloud Shell aktivieren .

Im unteren Bereich der Google Cloud Console wird ein neues Feld mit einer Cloud Shell-Sitzung und einer Befehlszeilen-Eingabeaufforderung geöffnet.

Repository erstellen

In dieser Anleitung speichern Sie ein Image in Artifact Registry und stellen es aus der Registry bereit. Für diese Kurzanleitung erstellen Sie ein Repository mit dem Namen hello-repo.

Legen Sie die Umgebungsvariable PROJECT_ID auf Ihre Google Cloud-Projekt-ID (PROJECT_ID) fest. Sie verwenden diese Umgebungsvariable, wenn Sie das Container-Image erstellen und in Ihr Repository übertragen.
```
export PROJECT_ID=PROJECT_ID
```
Bestätigen Sie, dass die Umgebungsvariable PROJECT_ID den richtigen Wert hat:
```
echo $PROJECT_ID
```
Legen Sie Ihre Projekt-ID für die Google Cloud CLI fest:
```
gcloud config set project $PROJECT_ID
```
Ausgabe:
```
Updated property [core/project].
```
Hinweis: Ihre gcloud CLI könnte bereits auf $PROJECT_ID eingestellt sein. Sie werden trotzdem die Updated property-Ausgabe sehen.
Erstellen Sie mit dem folgenden Befehl das Repository hello-repo:
```
gcloud artifacts repositories create hello-repo \
   --repository-format=docker \
   --location=REGION \
   --description="Docker repository"
```
Ersetzen Sie REGION durch eine Region für das Repository, z. B. us-west1. Führen Sie den folgenden Befehl aus, um eine Liste der verfügbaren Standorte aufzurufen:
```
 gcloud artifacts locations list
```

Container-Image erstellen

Im Rahmen dieser Anleitung stellen Sie eine Beispielwebanwendung namens hello-app bereit. Dies ist ein in Go geschriebener Webserver, der auf alle Anfragen mit der Nachricht Hello, World! an Port 8080 antwortet.

GKE akzeptiert Docker-Images als Deploymentformat von Anwendungen. Bevor Sie hello-app in GKE bereitstellen, müssen Sie den Quellcode hello-app als Docker-Image verpacken.

Zum Erstellen eines Docker-Images benötigen Sie Quellcode und ein Dockerfile. Ein Dockerfile enthält Anweisungen zum Erstellen des Images.

Laden Sie den hello-app-Quellcode und das Dockerfile mit den folgenden Befehlen herunter:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
cd kubernetes-engine-samples/quickstarts/hello-app

Erstellen und taggen Sie das Docker-Image für hello-app:
```
docker build -t REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1 .
```
Dieser Befehl weist Docker an, den Image-Build mit dem Dockerfile im aktuellen Verzeichnis zu erstellen, in Ihrer lokalen Umgebung zu speichern und mit einem Namen wie us-west1-docker.pkg.dev/my-project/hello-repo/hello-app:v1 zu taggen. Das Image wird im nächsten Abschnitt in Artifact Registry übertragen.
- Die Variable PROJECT_ID verknüpft das Container-Image mit dem Repository hello-repo in Ihrem Google Cloud-Projekt.
- Das Präfix us-west1-docker.pkg.dev bezieht sich auf Artifact Registry, einen regionalen Host für Ihr Repository.
Hinweis: Autorisieren Sie Cloud Shell für Google Cloud API-Aufrufe, wenn Sie dazu aufgefordert werden.

Führen Sie den Befehl docker images aus, um zu prüfen, ob der Build erfolgreich war:

docker images

Ausgabe:

REPOSITORY                                                 TAG     IMAGE ID       CREATED          SIZE
us-west1-docker.pkg.dev/my-project/hello-repo/hello-app    v1      25cfadb1bf28   10 seconds ago   54 MB

Fügen Sie Ihrem Dienstkonto IAM-Richtlinienbindungen hinzu:

gcloud artifacts repositories add-iam-policy-binding hello-repo \
    --location=REGION \
    --member=serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com \
    --role="roles/artifactregistry.reader"

Ersetzen Sie PROJECT_NUMBER durch die Projektnummer Ihres Projekts.

Container lokal ausführen (optional)

Testen Sie das Container-Image mit Ihrer lokalen Docker-Engine:

docker run --rm -p 8080:8080 REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1

Klicken Sie auf Webvorschau und wählen Sie anschließend die Portnummer 8080 aus. GKE öffnet die Vorschau-URL im Proxy-Dienst in einem neuen Browserfenster.

Docker-Image in Artifact Registry veröffentlichen

Sie müssen das Container-Image in eine Registry hochladen, damit Ihr GKE-Cluster das Container-Image herunterladen und ausführen kann. In dieser Anleitung speichern Sie Ihren Container in Artifact Registry.

Konfigurieren Sie das Docker-Befehlszeilentool für die Authentifizierung bei Artifact Registry:
```
gcloud auth configure-docker REGION-docker.pkg.dev
```
Hinweis: Ignorieren Sie Warnungen zur langen Liste von Credential Helpers.
Übertragen Sie das soeben erstellte Docker-Image per Push in das Repository:
```
docker push REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1
```

GKE-Cluster erstellen

Nachdem das Docker-Image in Artifact Registry gespeichert wurde, erstellen Sie einen GKE-Cluster, um hello-app auszuführen. Ein GKE-Cluster besteht aus einem Pool von Compute Engine-VM-Instanzen, auf denen Kubernetes, das Open-Source-Cluster-Orchestrierungssystem von GKE, ausgeführt wird.

Cloud Shell

Legen Sie Ihre Compute Engine-Region fest:
```
 gcloud config set compute/region REGION
```
Legen Sie für zonale Standardcluster die Compute Engine-Zone fest, die dem Artifact Registry-Repository am nächsten ist.
Erstellen Sie einen Cluster mit dem Namen hello-cluster:
```
 gcloud container clusters create-auto hello-cluster
```
Es dauert einige Minuten, bis Ihr GKE-Cluster erstellt und für die Systemdiagnose geprüft wurde. Wenn Sie diese Anleitung für einen GKE-Standardcluster ausführen möchten, verwenden Sie stattdessen den gcloud container clusters create-Befehl.

Console

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

Zur Seite „Google Kubernetes Engine“
Klicken Sie auf Erstellen.
Klicken Sie für GKE-Autopilot auf Konfigurieren.
Geben Sie im Feld Name den Namen hello-cluster ein.
Wählen Sie eine Compute Engine-Region aus der Drop-down-Liste Region aus, z. B. us-west1.
Klicken Sie auf Erstellen.
Warten Sie, bis der Cluster erstellt wurde. Sobald der Cluster bereit ist, wird neben dem Clusternamen ein Häkchen angezeigt.

Beispielanwendung in GKE bereitstellen

Sie können nun das erstellte Docker-Image in Ihrem GKE-Cluster bereitstellen.

Kubernetes stellt Anwendungen als Pods dar. Dies sind skalierbare Einheiten, die einen oder mehrere Container enthalten. Der Pod ist die kleinste bereitstellbare Einheit in Kubernetes. In der Regel werden Pods als ein Satz von Replikaten bereitgestellt, die skaliert und über den Cluster verteilt werden können. Eine Möglichkeit, um einen Satz von Replikaten bereitzustellen, ist ein Kubernetes-Deployment.

In diesem Abschnitt erstellen Sie ein Kubernetes-Deployment, um hello-app auf Ihrem Cluster auszuführen. Dieses Deployment hat Replikate (Pods). Ein Deployment-Pod enthält nur einen Container: das Docker-Image hello-app. Sie erstellen außerdem eine HorizontalPodAutoscaler, die die Anzahl der Pods von 3 auf eine Zahl zwischen 1 und 5 skaliert, basierend auf der CPU-Auslastung.

Cloud Shell

Prüfen Sie, ob Sie mit Ihrem GKE-Cluster verbunden sind.

gcloud container clusters get-credentials hello-cluster --region REGION

Erstellen Sie ein Kubernetes-Deployment für Ihr Docker-Image hello-app.

kubectl create deployment hello-app --image=REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1

Legen Sie die Basisanzahl der Deployment-Replikate auf 3 fest.
```
kubectl scale deployment hello-app --replicas=3
```

Erstellen Sie eine HorizontalPodAutoscaler-Ressource für Ihr Deployment.

kubectl autoscale deployment hello-app --cpu-percent=80 --min=1 --max=5

Führen Sie den folgenden Befehl aus, um die erstellten Pods anzeigen zu lassen:

kubectl get pods

Ausgabe:

NAME                         READY   STATUS    RESTARTS   AGE
hello-app-784d7569bc-hgmpx   1/1     Running   0          90s
hello-app-784d7569bc-jfkz5   1/1     Running   0          90s
hello-app-784d7569bc-mnrrl   1/1     Running   0          95s

Console

Öffnen Sie in der Google Cloud Console die Seite Arbeitslasten:

Arbeitslasten aufrufen
Klicken Sie auf Bereitstellen.
Wählen Sie im Bereich Container angeben die Option Bestehendes Container-Image aus.
Klicken Sie im Feld Image-Pfad auf Auswählen.
Wählen Sie im Bereich Container-Image auswählen das hello-app-Image aus, das Sie in Artifact Registry hochgeladen haben, und klicken Sie auf Auswählen.
Klicken Sie im Abschnitt Container auf Fertig und dann auf Weiter.
Geben Sie im Abschnitt Konfiguration unter Labels für Schlüssel app und für Wert hello-app ein.
Klicken Sie unter Konfigurations-YAML auf YAML aufrufen. Damit wird eine YAML-Konfigurationsdatei geöffnet, die die beiden Kubernetes API-Ressourcen darstellt, die in Ihrem Cluster bereitgestellt werden sollen: ein Deployment und ein HorizontalPodAutoscaler für dieses Deployment.
Klicken Sie auf Schließen und dann auf Bereitstellen.
Wenn die Deployment-Pods bereit sind, wird die Seite Bereitstellungsdetails geöffnet.
Notieren Sie sich unter Verwaltete Pods die drei ausgeführten Pods für das Deployment hello-app.

Beispielanwendung im Internet freigeben

Pods haben zwar individuell zugewiesene IP-Adressen, diese IP-Adressen sind jedoch nur innerhalb Ihres Clusters erreichbar. Außerdem sind GKE-Pods sitzungsspezifisch und werden je nach Skalierungsanforderungen gestartet oder gestoppt. Wenn ein Pod aufgrund eines Fehlers abstürzt, stellt GKE diesen Pod automatisch noch einmal bereit und weist jedes Mal eine neue Pod-IP-Adresse zu.

Das bedeutet, dass die IP-Adressen für aktive Pods für jedes Deployment dynamisch sind. Wir benötigen nun eine Möglichkeit, um zum einen Pods zu einem statischen Hostnamen als Gruppe zusammenzufassen und um zum anderen eine Gruppe von Pods außerhalb des Clusters für das Internet freizugeben.

Kubernetes-Dienste bieten eine Lösung für beide Anforderungen. Dienste gruppieren Pods in einer statischen IP-Adresse, die von jedem Pod im Cluster aus erreichbar ist. GKE weist dieser statischen IP-Adresse außerdem einen DNS-Hostnamen zu. Beispiel: hello-app.default.svc.cluster.local

Der standardmäßige Diensttyp in GKE ist ClusterIP, wobei der Dienst eine IP-Adresse erhält, die nur innerhalb des Clusters erreichbar ist. Zur Freigabe eines Kubernetes-Dienstes außerhalb des Clusters erstellen Sie einen Dienst vom Typ LoadBalancer. Dieser Diensttyp generiert eine externe Load-Balancer-IP-Adresse für einen Satz von Pods, die über das Internet erreichbar sind.

In diesem Abschnitt geben Sie das hello-app-Deployment mithilfe eines Dienstes vom Typ LoadBalancer im Internet frei.

Cloud Shell

Verwenden Sie den Befehl kubectl expose, um einen Kubernetes-Dienst für das Deployment hello-app zu generieren.
```
kubectl expose deployment hello-app --name=hello-app-service --type=LoadBalancer --port 80 --target-port 8080
```
Hier gibt das Flag --port die im Load-Balancer konfigurierte Portnummer und das Flag --target-port die Portnummer an, die der Container hello-app überwacht.

Führen Sie den folgenden Befehl aus, um die Dienstdetails für hello-app-service abzurufen.

kubectl get service

Ausgabe:

NAME                 CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
hello-app-service    10.3.251.122    203.0.113.0     80:30877/TCP     10s

Kopieren Sie die EXTERNAL_IP-Adresse in die Zwischenablage (z. B. 203.0.113.0).

Hinweis: Es kann einige Minuten dauern, bis der Load-Balancer bereitgestellt ist. Bis der Load-Balancer bereitgestellt ist, wird möglicherweise eine <pending>-IP-Adresse angezeigt.

Console

Rufen Sie in der Google Cloud Console die Seite Arbeitslasten auf.

Zu Arbeitslasten
Klicken Sie auf hello-app.
Klicken Sie auf der Seite „Bereitstellungsdetails“ auf Aktionen > Freigeben.
Legen Sie im Dialogfeld Freigeben den Zielport auf 8080 fest. Dies ist der Port, den der Container hello-app überwacht.
Wählen Sie im Drop-down-Menü Diensttyp die Option Load-Balancer aus.
Klicken Sie auf Freigeben, um einen Kubernetes-Dienst für hello-app zu erstellen.
Wenn der Load-Balancer bereit ist, wird die Seite Dienstdetails geöffnet.
Scrollen Sie nach unten zum Feld Externe Endpunkte und kopieren Sie die IP-Adresse.

Da die hello-app-Pods jetzt über einen Kubernetes-Dienst im Internet zugänglich sind, können Sie einen neuen Browsertab öffnen und die Service-IP-Adresse aufrufen, die Sie in die Zwischenablage kopiert haben. Eine Hello, World!-Meldung wird zusammen mit dem Feld Hostname angezeigt. Der Hostname entspricht einem der drei hello-app-Pods, die Ihre HTTP-Anfrage an Ihren Browser senden.

Neue Version der Beispielanwendung bereitstellen

In diesem Abschnitt führen Sie ein Upgrade von hello-app auf eine neue Version durch. Dazu erstellen Sie ein neues Docker-Image und stellen es in Ihrem GKE-Cluster bereit.

Mit dem Rolling Update von Kubernetes können Sie Ihre Deployments ohne Ausfallzeiten aktualisieren. Bei einem Rolling Update ersetzt Ihr GKE-Cluster die vorhandenen hello-app-Pods schrittweise durch Pods, die das Docker-Image für die neue Version enthalten. Während der Aktualisierung leitet der Load-Balancer-Dienst Traffic nur an verfügbare Pods weiter.

Kehren Sie zu Cloud Shell zurück, wo Sie den Quellcode für "hello-app" und das Dockerfile geklont haben. Aktualisieren Sie die Funktion hello() in der Datei main.go, um die neue Version 2.0.0 zu melden.

Erstellen Sie ein neues Docker-Image für hello-app und taggen Sie es.

docker build -t REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2 .

Übertragen Sie das Image in Artifact Registry.

docker push REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2

Sie können nun Ihr Kubernetes-Deployment hello-app aktualisieren, um ein neues Docker-Image zu verwenden.

Cloud Shell

Wenden Sie ein Rolling Update auf das vorhandene hello-app-Deployment an, mit einem Image-update mit dem Befehl kubectl set image.
```
kubectl set image deployment/hello-app hello-app=REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2
```

Achten Sie darauf, dass die ausgeführten Pods, auf denen das Image v1 ausgeführt wird, gestoppt und neue Pods mit dem Image v2 gestartet werden.

watch kubectl get pods

Ausgabe:

NAME                        READY   STATUS    RESTARTS   AGE
hello-app-89dc45f48-5bzqp   1/1     Running   0          2m42s
hello-app-89dc45f48-scm66   1/1     Running   0          2m40s

Öffnen Sie in einem separaten Tab noch einmal die externe IP-Adresse hello-app-service. Nun sollte für Version der Wert 2.0.0. angezeigt werden.

Console

Rufen Sie in der Google Cloud Console die Seite Arbeitslasten auf.

Zu Arbeitslasten
Klicken Sie auf hello-app.
Klicken Sie auf der Seite Bereitstellungsdetails auf Aktionen > Rolling Update.
Legen Sie im Dialogfeld Rolling Update das Feld Image von hello-app auf REGION-docker.pkg.dev/PROJECT_ID/hello-repo/hello-app:v2 fest.
Klicken Sie auf Aktualisieren.
Prüfen Sie auf der Seite Bereitstellungsdetails den Abschnitt Aktive Überarbeitungen. Es sollten jetzt die beiden Überarbeitungen 1 und 2 angezeigt werden. Überarbeitung 1 entspricht dem ersten Deployment, das Sie zuvor erstellt haben. Überarbeitung 2 ist das Rolling Update, das Sie gerade gestartet haben.
Aktualisieren Sie die Seite nach einer kurzen Wartezeit. Unter Verwaltete Pods entsprechen jetzt alle Replikate von hello-app der Überarbeitung 2.
Gehen Sie in einem separaten Tab zu der Dienst-IP-Adresse, die Sie kopiert haben. Der Version sollte 2.0.0. lauten.

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Dienst löschen: Dadurch wird die Zuweisung des für Ihren Dienst erstellten Cloud-Load-Balancers aufgehoben:
```
kubectl delete service hello-app-service
```
Cluster löschen: Dadurch werden die Ressourcen des Clusters gelöscht, z. B. die Compute-Instanzen, Laufwerke und Netzwerkressourcen:
```
gcloud container clusters delete hello-cluster --region REGION
```

Container-Images löschen: Dadurch werden die Docker-Images gelöscht, die Sie in Artifact Registry hochgeladen haben.

gcloud artifacts docker images delete \
    REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1 \
    --delete-tags --quiet
gcloud artifacts docker images delete \
    REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2 \
    --delete-tags --quiet

Nächste Schritte

Mehr über Preise für GKE und über die Kostenschätzung mit dem Preisrechner erfahren
Mehr über erweiterte Load-Balancing-Konfigurationen für Webanwendungen in der Anleitung zu Load-Balancer erfahren
Statische IP-Adresse und Domainnamen für Ihre Anwendung konfigurieren
Weitere Kubernetes-Anleitungen
Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center

Jetzt testen

Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit von GKE in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

GKE kostenlos testen