Dieses Tutorial zeigt Ihnen, wie Sie eine Webanwendung in ein Docker-Container-Image packen und dieses Container-Image auf einem Google Kubernetes Engine (GKE)-Cluster ausführen. Anschließend stellen Sie die Webanwendung als Satz von Replikaten mit Lastenausgleich bereit, die entsprechend den Anforderungen Ihrer Benutzer skaliert werden können

## Ziele
– Packen Sie eine Beispiel-Webanwendung in ein Docker-Image

- Laden Sie das Docker-Image in Artifact Registry hoch

- Erstellen Sie einen GKE-Cluster

– Stellen Sie die Beispiel-App im Cluster bereit

- Autoscaling für die Bereitstellung verwalten

- Stellen Sie die Beispiel-App dem Internet zur Verfügung

- Stellen Sie eine neue Version der Beispiel-App bereit

## Kosten
In dieser Anleitung werden die folgenden kostenpflichtigen Komponenten von Google Cloud verwendet:
Um einen Kostenvoranschlag basierend auf Ihrer voraussichtlichen Nutzung zu erstellen,
nutzen Sie den Preisrechner

Wenn Sie dieses Lernprogramm abgeschlossen haben, können Sie eine fortgesetzte Abrechnung vermeiden, indem Sie die von Ihnen erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Aufräumen

## Bevor Sie beginnenFühren Sie die folgenden Schritte aus, um die Kubernetes Engine API zu aktivieren:
- Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie neu bei Google Cloud sind, erstellen Sie ein Konto, um die Leistung unserer Produkte in realen Szenarien zu bewerten. Neukunden erhalten außerdem 300 US-Dollar an kostenlosen Credits zum Ausführen, Testen und Bereitstellen von Workloads

-
Wählen Sie in der Google Cloud-Konsole auf der Projektauswahlseite ein Google Cloud-Projekt aus oder erstellen Sie es

-
Stellen Sie sicher, dass die Abrechnung für Ihr Cloud-Projekt aktiviert ist. Erfahren Sie, wie Sie prüfen, ob die Abrechnung für ein Projekt aktiviert ist

-
Aktivieren Sie die Artifact Registry- und Google Kubernetes Engine-APIs

-
Wählen Sie in der Google Cloud-Konsole auf der Projektauswahlseite ein Google Cloud-Projekt aus oder erstellen Sie es

-
Stellen Sie sicher, dass die Abrechnung für Ihr Cloud-Projekt aktiviert ist. Erfahren Sie, wie Sie prüfen, ob die Abrechnung für ein Projekt aktiviert ist

-
Aktivieren Sie die Artifact Registry- und Google Kubernetes Engine-APIs

 Option A: Verwenden Sie Cloud Shell
Sie können dieser Anleitung mit der mitgelieferten Cloud Shell folgen
vorinstalliert mit
gcloud,
Docker und
kubectl-Befehlszeilentools verwendet
in diesem Tutorial. Wenn Sie Cloud Shell verwenden, müssen Sie diese nicht installieren
Befehlszeilentools auf Ihrer Workstation

So verwenden Sie Cloud Shell:
- Gehen Sie zur Google Cloud-Konsole

Drücke den
Aktivieren Sie Cloud Shell
Schaltfläche oben im Fenster der Google Cloud-Konsole

Eine Cloud Shell-Sitzung wird in einem neuen Rahmen unten in der Google Cloud-Konsole geöffnet und zeigt eine Befehlszeilen-Eingabeaufforderung an

 Option B: Verwenden Sie lokale Befehlszeilentools
Wenn Sie diesem Lernprogramm lieber auf Ihrer Workstation folgen möchten, befolgen Sie diese Schritte, um die erforderlichen Tools zu installieren

Installieren Sie die Google Cloud-Befehlszeilenschnittstelle

Installieren Sie mit der gcloud-Befehlszeilenschnittstelle das Kubernetes-Befehlszeilentool
kubectlis zur Kommunikation mit Kubernetes, dem Cluster-Orchestrierungssystem von GKE-Clustern:
gcloud-Komponenten installieren kubectl
Installieren Sie Docker Community Edition (CE) auf Ihrer Workstation. Sie verwenden dies, um ein Container-Image für die Anwendung zu erstellen

Installieren Sie das Git-Quellcodeverwaltungstool, um die Beispielanwendung von GitHub abzurufen

## Erstellen Sie ein Repository
In diesem Lernprogramm speichern Sie ein Image in Artifact Registry und stellen es bereit
aus der Registrierung. Artifact Registry ist die empfohlene Containerregistrierung
Google-Cloud. Für diesen Schnellstart erstellen Sie ein Repository mit dem Namen
hallo repo

Stellen Sie die ein
PROJECT_IDenvironment-Variable zu Ihrer Google Cloud-Projekt-ID (
). Sie verwenden diese Umgebungsvariable, wenn Sie das Container-Image erstellen und in Ihr Repository übertragen

PROJEKT_ID
export PROJECT_ID=
PROJEKT_ID
Bestätigen Sie, dass die
Die Variable PROJECT_IDenvironment hat den richtigen Wert:
echo $PROJEKT_ID
Legen Sie Ihre Projekt-ID für die Google Cloud CLI fest:
gcloud-Konfigurationssatzprojekt $PROJECT_ID
Ausgabe:
Aktualisierte Eigenschaft [Kern/Projekt]

Erstellen Sie die
hello-Repository mit dem folgenden Befehl:
gcloud-Artefakt-Repositorys erstellen hello-repo \ --repository-format=docker \ --location=
REGION\ --description="Docker-Repository"Ersetzen
mit einer Region für das Repository, wie z
REGION
us-west1. Führen Sie den folgenden Befehl aus, um eine Liste der verfügbaren Speicherorte anzuzeigen:
Liste der Speicherorte von gcloud-Artefakten
## Erstellen des Container-Images
In diesem Lernprogramm stellen Sie ein Beispielweb bereit
Anwendung aufgerufen
hallo-app, ein Webserver geschrieben
in Go, die auf alle Anfragen mit der Nachricht antwortet
Hallo Welt! auf Port 8080

GKE akzeptiert Docker-Images als Anwendungsbereitstellungsformat

Vor der Bereitstellung
hello-app zu GKE, müssen Sie paketieren
Die
hello-app-Quellcode als Docker-Image

Um ein Docker-Image zu erstellen, benötigen Sie Quellcode und ein Dockerfile. Ein Dockerfile enthält Anweisungen, wie das Image erstellt wird

Laden Sie die herunter
hello-appsource code und Dockerfile, indem Sie die folgenden Befehle ausführen:
Git-Klon httpsgithub.com/GoogleCloudPlatform/kubernetes-engine-samples cd kubernetes-engine-samples/hello-app
Erstellen und taggen Sie das Docker-Image für
Hallo-App:
Docker-Build -t
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v1

Dieser Befehl weist Docker an, das Image mithilfe von zu erstellen
Dockerfile im aktuellen Verzeichnis, speichern Sie es in Ihrer lokalen Umgebung und kennzeichnen Sie es mit einem Namen, z
us-west1-docker.pkg.dev/my-project/hello-repo/hello-app:v1. Das Bild wird im nächsten Abschnitt in die Artifact Registry übertragen

- Das
Die PROJECT_ID-Variable ordnet das Container-Image dem zu
hello-reporepository in Ihrem Google Cloud-Projekt

- Das
us-west1-docker.pkg.devprefix bezieht sich auf Artifact Registry, den regionalen Host für Ihr Repository

- Das
Führen Sie die aus
docker imagesBefehl, um zu überprüfen, ob der Build erfolgreich war:
Docker-Bilder
Ausgabe:
REPOSITORY-TAG BILD-ID ERSTELLTE GRÖSSE us-west1-docker.pkg.dev/my-project/hello-repo/hello-app v1 25cfadb1bf28 Vor 10 Sekunden 54 MB
## Container lokal ausführen (optional)
Testen Sie Ihr Container-Image mit Ihrer lokalen Docker-Engine:
docker run --rm -p 8080:8080
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v1
Wenn Sie Cloud Shell verwenden, klicken Sie auf die
Schaltfläche Webvorschau
und wählen Sie dann die aus
8080Portnummer. GKE öffnet die Vorschau-URL auf seinem Proxydienst in einem neuen Browserfenster

Öffnen Sie andernfalls ein neues Terminalfenster (oder einen Cloud Shell-Tab) und führen Sie den folgenden Befehl aus, um zu überprüfen, ob der Container funktioniert und auf Anfragen mit „Hello, World
curl httplocalhost:8080
Nachdem Sie eine erfolgreiche Antwort gesehen haben, können Sie den Container herunterfahren, indem Sie drücken
Strg+Cin der Registerkarte, wo die
docker runcommand läuft

## Docker-Image an Artifact Registry übertragen
Sie müssen das Container-Image in eine Registrierung hochladen, damit Ihr GKE-Cluster das Container-Image herunterladen und ausführen kann. In diesem Tutorial 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
Pushen Sie das Docker-Image, das Sie gerade erstellt haben, in das Repository:
Docker-Push
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v1
## Erstellen eines GKE-Clusters
Nachdem das Docker-Image nun in Artifact Registry gespeichert ist, erstellen Sie ein GKE
Cluster
laufen
hallo-app. Ein GKE-Cluster besteht aus einem Pool von Compute Engine-VM-Instanzen
Ausführen von Kubernetes, der Open-Source-Cluster-Orchestrierung
System, das GKE antreibt

 Cloud-Shell
Legen Sie Ihre Compute Engine-Zone oder -Region fest. Geben Sie je nach Betriebsmodus, den Sie in GKE verwenden möchten, eine Standardzone oder -region an. Wenn Sie den Standardmodus verwenden, ist Ihr Cluster zonal (für dieses Tutorial), legen Sie also Ihre Standardcomputezone fest. Wenn Sie den Autopilot-Modus verwenden, ist Ihr Cluster regional, legen Sie also Ihre standardmäßige Compute-Region fest. Wählen Sie eine Zone oder Region aus, die dem von Ihnen erstellten Artifact Registry-Repository am nächsten liegt

Standardcluster, wie z
us-west1-a:
gcloud config set compute/zone
COMPUTE_ZONE Autopilotcluster, wie z
us-west1:
gcloud config set compute/region
COMPUTE_REGION
-
Erstellen Sie einen Cluster mit dem Namen
hallo-cluster:
Standardcluster:
gcloud-Container-Cluster erstellen hello-cluster
Autopilotcluster:
gcloud container clusters create-auto hallo-cluster
Es dauert einige Minuten, bis Ihr GKE-Cluster erstellt und überprüft wurde

-
Führen Sie nach Abschluss des Befehls den folgenden Befehl aus, um die drei Knoten des Clusters anzuzeigen:
kubectl erhält Knoten
Ausgabe:
NAME STATUS ROLLEN ALTER VERSION gke-hello-cluster-default-pool-229c0700-cbtd Bereit 92s v1.18.12-gke.1210 gke-hello-cluster-default-pool-229c0700-fc5j Ready  91s v1.18.12-gke.1210 gke-hello-cluster-default-pool-229c0700-n9l7 Ready  92s v1.18.12-gke.1210
 Console
Go to the
Google Kubernetes Enginepage in the Google Cloud console

Go to Google Kubernetes Engine
Click
Create

Choose Standard or Autopilot mode and click
Configure

In the
Namefield, enter the name
hello-cluster

Select a zone or region:
Standardcluster: Under Location type, select Zonaland then select a Compute Engine zone from the Zonedrop-down list, such as
us-west1-a

Autopilotcluster: Select a Compute Engine region from the Regiondrop-down list, such as
us-west1

-
Click
Create. This creates a GKE cluster

Wait for the cluster to be created. When the cluster is ready, a green check mark appears next to the cluster name

## Deploying the sample app to GKE
You are now ready to deploy the Docker image you built to your GKE cluster

Kubernetes represents applications as Pods, which are scalable units holding one or more containers. The Pod is the smallest deployable unit in Kubernetes. Usually, you deploy Pods as a set of replicas that can be scaled and distributed together across your cluster. One way to deploy a set of replicas is through a Kubernetes Deployment

In this section, you create a Kubernetes Deployment to run
hello-app on your
cluster. This Deployment has replicas (Pods). One Deployment Pod contains only
one container: the
hello-app Docker image

You also create a HorizontalPodAutoscaler resource that scales the number
of Pods from 3 to a number between 1 and 5, based on CPU load

 Cloud Shell
Ensure that you are connected to your GKE cluster

gcloud container clusters get-credentials hello-cluster --zone
COMPUTE_ZONE
Create a Kubernetes Deployment for your
hello-appDocker image

kubectl create deployment hello-app --image=
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v1
Set the baseline number of Deployment replicas to 3

kubectl scale deployment hello-app --replicas=3
Create a
HorizontalPodAutoscalerresource for your Deployment

kubectl autoscale deployment hello-app --cpu-percent=80 --min=1 --max=5
To see the Pods created, run the following command:
kubectl get pods
Output:
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
Go to the
Workloadspage in the Google Cloud console

Click
Deploy

In the
Specify containersection, select Existing container image

In the
Image pathfield, click Select

In the
Select container imagepane, select the
hello-appimage you pushed to Artifact Registry and click
Select

In the
Containersection, click Done, then click Continue

In the
Configurationsection, under Labels, enter
appfor
Keyand
hello-appfor
Value

Under
Configuration YAML, click View YAML. This opens a YAML configuration file representing the two Kubernetes API resources about to be deployed into your cluster: one Deployment, and one
HorizontalPodAutoscalerfor that Deployment

Click
Close, then click Deploy

When the Deployment Pods are ready, the
Deployment detailspage opens

Under
Managed pods, note the three running Pods for the
hello-appDeployment

## Exposing the sample app to the internet
While Pods do have individually-assigned IP addresses, those IPs can only be reached from inside your cluster. Also, GKE Pods are designed to be ephemeral, starting or stopping based on scaling needs. And when a Pod crashes due to an error, GKE automatically redeploys that Pod, assigning a new Pod IP address each time

What this means is that for any Deployment, the set of IP addresses corresponding to the active set of Pods is dynamic. We need a way to 1) group Pods together into one static hostname, and 2) expose a group of Pods outside the cluster, to the internet

Kubernetes Services solve for both of these problems

Services group Pods
into one static IP address, reachable from any Pod inside the cluster

GKE also assigns a DNS hostname
to that static IP. For example,
hello-app.default.svc.cluster.local

The default Service type in GKE is called ClusterIP,
where the Service gets an IP address reachable only from inside the cluster

To expose a Kubernetes Service outside the cluster, create a Service of
type
LoadBalancer

This type of Service spawns an External Load Balancer IP for a set of Pods,
reachable through the internet

In this section, you expose the
hello-app Deployment to the internet using a
Service of type
LoadBalancer

 Cloud Shell
Use the
kubectl exposecommand to generate a Kubernetes Service for the
hello-appdeployment:
kubectl expose deployment hello-app --name=hello-app-service --type=LoadBalancer --port 80 --target-port 8080
Here, the
--portflag specifies the port number configured on the Load Balancer, and the
--target-portflag specifies the port number that the
hello-appcontainer is listening on

Run the following command to get the Service details for
hello-app-service:
kubectl get service
Output:

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-app-service 10.3.251.122 203.0.113.0 80:30877/TCP 10s
Copy the
EXTERNAL_IPaddress to the clipboard (for instance:
203.0.113.0)

 Console
Go to the
Workloadspage in the Google Cloud console

Click
hello-app

From the Deployment details page, click
Actions > Expose

In the
Exposedialog, set the Target portto
8080. This is the port the
hello-appcontainer listens on

From the
Service typedrop-down list, select Load balancer

Click
Exposeto create a Kubernetes Service for
hello-app

When the Load Balancer is ready, the
Service detailspage opens

Scroll down to the
External endpointsfield, and copy the IP address

Now that the
hello-app Pods are exposed to the internet through a Kubernetes Service,
you can open a new browser tab, and navigate to the Service IP address you copied
to the clipboard. A
Hello, World! message appears, along with a
Hostname
field. The
Hostname corresponds to one of the three
hello-app Pods serving your
HTTP request to your browser

## Deploying a new version of the sample app
In this section, you upgrade
hello-app to a new version by building and deploying
a new Docker image to your GKE cluster

GKE's rolling update feature
lets you update your Deployments without downtime. During a rolling update, your GKE cluster
incrementally replaces the existing
hello-app Pods with Pods containing the Docker image for the new version

During the update, your load balancer service routes traffic only into available Pods

Return to Cloud Shell, where you have cloned the hello app source code and Dockerfile. Update the function
hello()in the
main.gofile to report the new version
2.0.0

Build and tag a new
hello-appDocker image

docker build -t
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v2 

Push the image to Artifact Registry

docker push
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v2
Now you're ready to update your
hello-app Kubernetes Deployment to use a new Docker image

 Cloud Shell
Apply a rolling update to the existing
hello-appDeployment with an image update using the
kubectl set imagecommand:
kubectl set image deployment/hello-app hello-app=
REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v2
Watch the running Pods running the
v1image stop, and new Pods running the
v2image start

watch kubectl get pods
Output:
NAME READY STATUS RESTARTS AGE hello-app-89dc45f48-5bzqp 1/1 Running 0 2m42s hello-app-89dc45f48-scm66 1/1 Running 0 2m40s
In a separate tab, navigate again to the
hello-app-serviceExternal IP. You should now see the
Versionset to
2.0.0

 Console
Go to the
Workloadspage in the Google Cloud console

Click
hello-app

On the

Deployment detailspage, click Actions > Rolling update

In the
Rolling updatedialog, set the Image of hello-appfield to


REGION-docker.pkg.dev/ PROJECT_ID/hello-repo/hello-app:v2
Click
Update

On the
Deployment detailspage, inspect the Active Revisionssection. You should now see two Revisions, 1 and 2. Revision 1 corresponds to the initial Deployment you created earlier. Revision 2 is the rolling update you just started

After a few moments, refresh the page. Under
Managed pods, all of the replicas of
hello-appnow correspond to Revision 2

In a separate tab, navigate again to the Service IP address you copied. The
Versionshould be
2.0.0

## Clean up
To avoid incurring charges to your Google Cloud account for the resources used in this tutorial, either delete the project that contains the resources, or keep the project and delete the individual resources

Delete the Service:This deallocates the Cloud Load Balancer created for your Service:
kubectl delete service hello-app-service
Delete the cluster:This deletes the resources that make up the cluster, such as the compute instances, disks, and network resources:
gcloud container clusters delete hello-cluster --zone
COMPUTE_ZONE Delete your container images:This deletes the Docker images you pushed to Artifact Registry

gcloud artifacts docker images delete REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v1 \ --delete-tags --quiet gcloud artifacts docker images delete \ REGION-docker.pkg.devPROJECT_ID}/hello-repo/hello-app:v2 \ --delete-tags --quiet
## What's next
Learn about Pricing for GKE and use the Pricing Calculator to estimate costs

Read the Load Balancers tutorial, which demonstrates advanced load balancing configurations for web applications

Configure a static IP and domain name for your application

Explore other Kubernetes Engine tutorials

Explore reference architectures, diagrams, tutorials, and best practices about Google Cloud. Take a look at our Cloud Architecture Center

## Try it for yourself
If you're new to Google Cloud, create an account to evaluate how GKE performs in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.Try GKE free