Schnellstart

In dieser Kurzanleitung stellen Sie eine einfache Webserver-Containeranwendung in einem Google Kubernetes Engine-Cluster (GKE) bereit. Sie erfahren, wie Sie einen Cluster erstellen und die Anwendung im Cluster bereitstellen, damit Nutzer darauf zugreifen können.

In dieser Kurzanleitung werden Grundkenntnisse in Kubernetes vorausgesetzt.

Hinweis

Führen Sie folgende Schritte aus, um die Kubernetes Engine API zu aktivieren:

1. Rufen Sie in der Google Cloud Console die Seite Kubernetes Engine auf.
2. Erstellen Sie ein Projekt oder wählen Sie eines aus.
3. Warten Sie, bis die API und die zugehörigen Dienste aktiviert worden sind. Dieser Vorgang kann einige Minuten dauern.

4. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

Sie benötigen ein verfügbares Kontingent für:

• 1 Compute Engine-CPU in der Region Ihres Clusters
• 1 IP-Adresse in Verwendung

In der Cloud Console können Sie Ihr verfügbares Kontingent prüfen.

Cloud Shell aufrufen

In dieser Anleitung verwenden Sie Cloud Shell, eine Shell-Umgebung zur Verwaltung von in Google Cloud gehosteten Ressourcen.

Die gcloud- und kubectl-Befehlszeilentools sind in Cloud Shell vorinstalliert. Das gcloud-Tool ist die primäre Befehlszeile für Google Cloud und kubectl ist die primäre Befehlszeile zum Ausführen von Befehlen für Kubernetes-Cluster.

Cloud Shell aufrufen

1. Öffnen Sie die Google Cloud Console.

   Google Cloud Console

2. Klicken Sie in der oberen rechten Ecke der Console auf die Schaltfläche Cloud Shell aktivieren:

In einem Frame im unteren Teil der Console wird eine Cloud Shell-Sitzung geöffnet. In dieser Shell führen Sie gcloud- und kubectl-Befehle aus.

Standardeinstellungen für das gcloud-Tool festlegen

Konfigurieren Sie mit dem gcloud-Tool folgende Standardeinstellungen: Ihr Standardprojekt, die Compute-Zone und die Compute-Region.

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

Die Compute-Zone ist ein Standort in der Region, in der sich Ihre Cluster und deren Ressourcen befinden. Beispielsweise ist us-west1-a eine Zone in der Region us-west. Die Compute-Region ist die Region, in der sich Ihre Cluster und deren Ressourcen befinden (z. B. us-west).

Wenn Sie diese Standardeinstellungen konfigurieren, erleichtert dies die Ausführung von gcloud-Befehlen, da Sie für gcloud das Projekt und den Speicherort angeben müssen, in denen Sie arbeiten möchten. Sie können diese Einstellungen auch angeben oder Standardeinstellungen mit Flags wie --project, --zone, --region und --clusterin Ihren gcloud-Befehlen überschreiben.

Hinweis: Das gcloud-Tool gibt möglicherweise einen Fehler zurück, wenn diese Einstellungen nicht konfiguriert oder nicht angegeben wurden.

Wenn Sie nach dem Konfigurieren des Standardprojekts, der Zone und der Region GKE-Ressourcen erstellen, werden die Ressourcen automatisch in diesem Projekt, dieser Zone und dieser Region erstellt.

Führen Sie in Cloud Shell folgende Schritte aus:

1. Legen Sie das Standardprojekt fest:

   gcloud config set project PROJECT_ID
   

   Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID.

2. Legen Sie die Standardzone fest:

   gcloud config set compute/zone COMPUTE_ZONE
   

   Ersetzen Sie COMPUTE_ZONE durch Ihre Compute-Zone, z. B. us-west1-a.

3. Sie müssen auch die Standardregion festlegen:

   gcloud config set compute/region COMPUTE_REGION
   

   Ersetzen Sie COMPUTE_REGION durch Ihre Compute-Region, z. B. us-west1.

GKE-Cluster erstellen

Ein Cluster besteht aus mindestens einer Cluster-Steuerungsebene und mehreren Worker-Maschinen, die Knoten genannt werden. Knoten sind Compute Engine-VM-Instanzen, auf denen die erforderlichen Kubernetes-Prozesse ausgeführt werden, um die Knoten zu einem Teil des Clusters zu machen. In diesem Fall stellen Sie Anwendungen für Cluster bereit und die Anwendungen werden auf den Knoten ausgeführt.

Um Cluster in GKE zu erstellen, müssen Sie einen Betriebsmodus auswählen: "Standard" oder "Autopilot". Wenn Sie den Standardmodus verwenden, ist der Cluster zonal (in dieser Anleitung). Wenn Sie den Autopilot-Modus verwenden, ist der Cluster regional.

Standard

Erstellen Sie einen Standardcluster mit dem Namen hello-cluster mit einem Knoten:

gcloud container clusters create hello-cluster --num-nodes=1

Autopilot

Erstellen Sie einen Autopilot-Cluster mit dem Namen hello-cluster:

 gcloud container clusters create-auto hello-cluster

Es kann einige Minuten dauern, bis der Cluster erstellt ist.

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 clusters get-credentials hello-cluster

Mit diesem Befehl wird kubectl für die Verwendung des von Ihnen erstellten Clusters konfiguriert.

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.

GKE verwendet Kubernetes-Objekte, um die Clusterressourcen zu erstellen und zu verwalten. Kubernetes enthält das Deployment-Objekt, mit dem Sie zustandslose Anwendungen wie Webserver bereitstellen können. Mit Dienstobjekten werden Regeln und das Load-Balancing 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=gcr.io/google-samples/hello-app:1.0

Der Kubernetes-Befehl kubectl create deployment erstellt ein Deployment namens hello-server. Der Pod des Deployments führt das Container-Image hello-app aus.

Dabei gilt:

• --image gibt das bereitzustellende Container-Image an. In diesem Fall ruft der Befehl das Beispiel-Image aus einem Container Registry-Bucket namens gcr.io/google-samples/hello-app ab. :1.0 gibt die jeweils abzurufende Image-Version an. Wenn Sie keine Version angeben, wird die neueste Version verwendet.

Hinweis: In dieser Anleitung verwenden Sie ein Container-Image aus Container Registry. Google Cloud bietet außerdem den universellen Paketverwaltungsdienst Artifact Registry. Artifact Registry unterstützt Container und andere Formate und bietet mehr Flexibilität und Kontrolle über Ihre Artefakte. Weitere Informationen zu den Unterschieden zwischen diesen Registries finden Sie unter Featurevergleich.

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 Compute Engine-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 Load-Balancing von Compute Engine berechnet.

Anwendung prüfen und ansehen

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

2. 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 warten. Wenn die externe IP-Adresse der Anwendung <pending> lautet, führen Sie kubectl get noch einmal aus.

3. 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 Container-Webanwendung in GKE bereitgestellt.

Bereinigen

Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud-Konto die in dieser Kurzanleitung verwendeten Ressourcen in Rechnung gestellt werden:

1. Löschen Sie den Dienst der Anwendung mit kubectl delete:

   kubectl delete service hello-server
   

   Dieser Befehl löscht den Compute Engine-Load-Balancer, den Sie beim Freigeben des Deployments erstellt haben.

2. Löschen Sie den Cluster mit gcloud container clusters delete:

   gcloud container clusters delete hello-cluster
   

   Hinweis: Wenn Sie keine Standardzone oder -region festgelegt haben, übergeben Sie die Flags für Region (--region=COMPUTE_REGION) oder Zone (--zone=COMPUTE_ZONE) des Clusters an das gcloud-Tool.

Optional: hello-app-Codeüberprüfung

hello-app ist eine einfache Webserveranwendung, die aus zwei Dateien besteht: main.go und einem Dockerfile.

hello-app ist als Docker-Container-Image verpackt. Container-Images werden in einer beliebigen Docker-Image-Registry wie Container Registry gespeichert. Wir hosten hello-app in einem Container Registry-Bucket namens gcr.io/google-samples/hello-app.

main.go

main.go ist eine Webserverimplementierung, die in der Programmiersprache Go geschrieben wurde. Der Server antwortet auf jede HTTP-Anfrage mit der Nachricht "Hello, world!".

hello-app/main.go

Auf GitHub ansehen

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
)

func main() {
	// register hello function to handle all requests
	mux := http.NewServeMux()
	mux.HandleFunc("/", hello)

	// use PORT environment variable, or default to 8080
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	// start the web server on port and accept requests
	log.Printf("Server listening on port %s", port)
	log.Fatal(http.ListenAndServe(":"+port, mux))
}

// hello responds to the request with a plain-text "Hello, world" message.
func hello(w http.ResponseWriter, r *http.Request) {
	log.Printf("Serving request: %s", r.URL.Path)
	host, _ := os.Hostname()
	fmt.Fprintf(w, "Hello, world!\n")
	fmt.Fprintf(w, "Version: 1.0.0\n")
	fmt.Fprintf(w, "Hostname: %s\n", host)
}

Dockerfile

Dockerfile beschreibt das Image, das Docker erstellen soll, einschließlich aller seiner Ressourcen und Abhängigkeiten. Außerdem ist dort angegeben, welchen Netzwerkport die Anwendung freigeben soll. Weitere Informationen zur Funktionsweise dieser Datei finden Sie in der Docker-Dokumentation unter Dockerfile reference.

hello-app/Dockerfile

Auf GitHub ansehen

FROM golang:1.8-alpine
ADD . /go/src/hello-app
RUN go install hello-app

FROM alpine:latest
COPY --from=0 /go/bin/hello-app .
ENV PORT 8080
CMD ["./hello-app"]

Weitere Informationen

• Weitere Informationen zur Erstellung von Clustern
• Weitere Informationen zu Kubernetes
• Lesen Sie die Referenzdokumentation zu kubectl.
• Informationen, wie Sie eine einfache Webserveranwendung verpacken, hosten und bereitstellen.
• Eine Gästebuch-Anwendung mit Redis und PHP bereitstellen.
• Eine zustandsorientierte WordPress-Anwendung mit nichtflüchtigem Speicher und MySQL bereitstellen.
• Kubernetes-Anwendung mit Cloud Code für VS Code oder Cloud Code for IntelliJ erstellen und ausführen.

Jetzt testen

Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie einfach 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