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
  • Docker-Image in Artifact Registry hochladen
  • Einen GKE-Cluster installieren
  • Beispielanwendung im Cluster bereitstellen
  • Autoscaling für das Deployment verwalten
  • Beispielanwendung im Internet freigeben
  • Neue Version der Beispielanwendung bereitstellen

Hinweis

Führen Sie folgende Schritte aus, um die Kubernetes Engine API zu aktivieren:
  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 Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

  4. 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 Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

  7. Artifact Registry and Google Kubernetes Engine APIs aktivieren.

    Aktivieren Sie die APIs

Option A: Cloud Shell verwenden

Sie können diese Anleitung mit Cloud Shell ausführen, das mit den in dieser Anleitung verwendeten Befehlszeilentools gcloud, docker und kubectl vorinstalliert wird. Wenn Sie Cloud Shell verwenden, müssen Sie diese Befehlszeilentools nicht auf Ihrer Workstation installieren.

So verwenden Sie Cloud Shell:

  1. Gehen Sie zur Google Cloud Console.
  2. Klicken Sie im oberen Bereich des Cloud Console-Fensters auf Cloud Shell aktivieren Schaltfläche zum Aktivieren von Cloud Shell.

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

    Cloud Shell-Sitzung

Option B: Befehlszeilentools lokal verwenden

Wenn Sie diese Anleitung lieber auf Ihrer Workstation durcharbeiten möchten, folgen Sie für die Installation der erforderlichen Tools diesen Schritten:

  1. Installieren Sie das Cloud SDK. Das gcloud-Befehlszeilentool ist dort enthalten.

  2. Verwenden Sie das gcloud-Tool, um das Kubernetes-Befehlszeilentool zu installieren. kubectl wird für die Kommunikation mit Kubernetes verwendet, dem Clusterorchestrierungssystem für GKE-Cluster:

    gcloud components install kubectl
    
  3. Installieren Sie die Docker Community Edition (CE) auf Ihrer Workstation. Damit werden Sie ein Container-Image für die Anwendung erstellen.

  4. Installieren Sie das Tool Git Source Control, um die Beispielanwendung von GitHub herunterzuladen.

Repository erstellen

In dieser Anleitung speichern Sie ein Image in Artifact Registry und stellen es aus der Registry bereit. Artifact Registry ist die empfohlene Container-Registry in Google Cloud. 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 das gcloud-Befehlszeilentool 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/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
    

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. Wenn Sie Cloud Shell verwenden, klicken Sie auf die Schaltfläche Webvorschau Schaltfläche für Webvorschau und wählen Sie die Portnummer 8080 aus. GKE öffnet die Vorschau-URL im Proxy-Dienst in einem neuen Browserfenster.

  3. Öffnen Sie andernfalls ein neues Terminalfenster oder einen Cloud Shell-Tab und führen Sie den folgenden Befehl aus. Damit können Sie prüfen, ob der Container funktioniert und Anfragen mit „Hello, World!” beantworten:

    curl http://localhost:8080
    

    Nachdem eine erfolgreiche Antwort angezeigt wurde, können Sie den Container durch Drücken von Strg + C in dem Tab, in dem der Befehl docker run ausgeführt wird, herunterfahren.

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 Zone oder Region von Compute Engine fest. Geben Sie je nach verwendetem Betriebsmodus in GKE eine Standardzone oder -region an. Wenn Sie den Standardmodus verwenden, ist Ihr Cluster für diese Anleitung zonal. Legen Sie dann die Standard-Computing-Zone fest. Wenn Sie den Autopilot-Modus verwenden, ist Ihr Cluster regional. Legen Sie daher die Standard-Computing-Region fest. Wählen Sie die Zone oder Region aus, die dem von Ihnen erstellten Artifact Registry-Repository am nächsten liegt.

    • Standard-Cluster wie us-west1-a:

      gcloud config set compute/zone COMPUTE_ZONE
      
    • Autopilot-Cluster, wie us-west1:

      gcloud config set compute/region COMPUTE_REGION
      
  2. Erstellen Sie einen Cluster mit dem Namen hello-cluster:

    • Standard-Cluster:

      gcloud container clusters create hello-cluster
      
    • Autopilot-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.

  3. Führen Sie nach Abschluss des Befehls den folgenden Befehl aus, um die drei Knoten des Clusters aufzurufen:

    kubectl get nodes
    

    Ausgabe:

    NAME                                           STATUS   ROLES    AGE   VERSION
    gke-hello-cluster-default-pool-229c0700-cbtd   Ready    <none>   92s   v1.18.12-gke.1210
    gke-hello-cluster-default-pool-229c0700-fc5j   Ready    <none>   91s   v1.18.12-gke.1210
    gke-hello-cluster-default-pool-229c0700-n9l7   Ready    <none>   92s   v1.18.12-gke.1210
    

Console

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

    Zur Seite "Google Kubernetes Engine"

  2. Klicken Sie auf Erstellen.

  3. Wählen Sie den Standard- oder Autopilot-Modus aus und klicken Sie auf Konfigurieren.

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

  5. Wählen Sie eine Zone oder Region aus:

    • Standardcluster: Wählen Sie unter Standorttyp die Option Zonal und dann eine Compute Engine-Zone aus der Drop-down-Liste Zone, z. B. us-west1-a, aus.

    • Autopilot-Cluster: Wählen Sie eine Compute Engine-Region aus der Drop-down-Liste Region aus, z. B. us-west1.

  6. Klicken Sie auf Erstellen. Dadurch wird ein GKE-Cluster erstellt.

  7. Warten Sie, bis der Cluster erstellt wurde. Wenn der Cluster bereit ist, wird neben dem Clusternamen ein grünes 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 --zone COMPUTE_ZONE
    
  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          10s
    hello-app-784d7569bc-jfkz5   1/1     Running   0          10s
    hello-app-784d7569bc-mnrrl   1/1     Running   0          15s
    

Console

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

    Arbeitslasten aufrufen

  2. Klicken Sie auf Bereitstellen.

  3. Wählen Sie im Bereich Container 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 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 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 --zone COMPUTE_ZONE
    
  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