Container-Webanwendung bereitstellen


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

  1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte 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.
  2. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

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

  4. Compute Engine, Artifact Registry, and Google Kubernetes Engine APIs aktivieren.

    Aktivieren Sie die APIs

  5. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

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

  7. Compute Engine, Artifact Registry, and Google Kubernetes Engine APIs aktivieren.

    Aktivieren Sie die APIs

Cloud Shell aktivieren

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

  1. Öffnen Sie die Google Cloud Console.
  2. Klicken Sie im oberen Bereich der Google Cloud Console auf Cloud Shell aktivieren Schaltfläche zum Aktivieren von Cloud Shell.

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

    Cloud Shell-Sitzung

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.

  1. 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
    
  2. Bestätigen Sie, dass die Umgebungsvariable PROJECT_ID den richtigen Wert hat:

    echo $PROJECT_ID
    
  3. Legen Sie Ihre Projekt-ID für die Google Cloud CLI fest:

    gcloud config set project $PROJECT_ID
    

    Ausgabe:

    Updated property [core/project].
    
  4. 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.

  1. 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
    
  2. 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.
  3. 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
    
  4. 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)

  1. 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
    
  2. Klicken Sie auf Webvorschau Schaltfläche für 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.

  1. Konfigurieren Sie das Docker-Befehlszeilentool für die Authentifizierung bei Artifact Registry:

    gcloud auth configure-docker REGION-docker.pkg.dev
    
  2. Ü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

  1. Legen Sie die 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.

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

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

    Zur Seite „Google Kubernetes Engine“

  2. Klicken Sie auf Erstellen.

  3. Klicken Sie für GKE Autopilot auf Konfigurieren.

  4. Geben Sie im Feld Name den Namen hello-cluster ein.

  5. Wählen Sie in der Drop-down-Liste Region eine Compute Engine-Region aus, z. B. us-west1.

  6. Klicken Sie auf Erstellen.

  7. 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-Ressource, die die Anzahl der Pods von 3 auf eine Zahl zwischen 1 und 5 skaliert, basierend auf der CPU-Auslastung.

Cloud Shell

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

    gcloud container clusters get-credentials hello-cluster --region REGION
    
  2. 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
    
  3. Legen Sie die Basisanzahl der Deployment-Replikate auf 3 fest.

    kubectl scale deployment hello-app --replicas=3
    
  4. Erstellen Sie eine HorizontalPodAutoscaler-Ressource für Ihr Deployment.

    kubectl autoscale deployment hello-app --cpu-percent=80 --min=1 --max=5
    
  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

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

    Arbeitslasten aufrufen

  2. Klicken Sie auf Bereitstellen.

  3. Wählen Sie im Bereich Container angeben die Option Bestehendes Container-Image aus.

  4. Klicken Sie im Feld Image-Pfad auf Auswählen.

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

  6. Klicken Sie im Abschnitt Container auf Fertig und dann auf Weiter.

  7. Geben Sie im Abschnitt Konfiguration unter Labels für Schlüssel app und für Wert hello-app ein.

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

  9. Klicken Sie auf Schließen und dann auf Bereitstellen.

  10. Wenn die Deployment-Pods bereit sind, wird die Seite Bereitstellungsdetails geöffnet.

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

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

  2. 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
    
  3. Kopieren Sie die EXTERNAL_IP-Adresse in die Zwischenablage (z. B. 203.0.113.0).

Console

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

    Zu Arbeitslasten

  2. Klicken Sie auf hello-app.

  3. Klicken Sie auf der Seite „Bereitstellungsdetails“ auf Aktionen > Freigeben.

  4. Legen Sie im Dialogfeld Freigeben den Zielport auf 8080 fest. Dies ist der Port, den der Container hello-app überwacht.

  5. Wählen Sie im Drop-down-Menü Diensttyp die Option Load-Balancer aus.

  6. Klicken Sie auf Freigeben, um einen Kubernetes-Dienst für hello-app zu erstellen.

  7. Wenn der Load-Balancer bereit ist, wird die Seite Dienstdetails geöffnet.

  8. 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 GKE-Feature Rolling Update 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.

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

  2. 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 .
    
  3. Ü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

  1. 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
    
  2. 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
    
  3. Ö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

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

    Zu Arbeitslasten

  2. Klicken Sie auf hello-app.

  3. Klicken Sie auf der Seite Bereitstellungsdetails auf Aktionen > Rolling Update.

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

  5. Klicken Sie auf Aktualisieren.

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

  7. Aktualisieren Sie die Seite nach einer kurzen Wartezeit. Unter Verwaltete Pods entsprechen jetzt alle Replikate von hello-app der Überarbeitung 2.

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

  1. Dienst löschen: Dadurch wird die Zuweisung des für Ihren Dienst erstellten Cloud-Load-Balancers aufgehoben:

    kubectl delete service hello-app-service
    
  2. 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
    
  3. 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

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