Spring Boot-Java-Anwendung in Kubernetes in Google Kubernetes Engine bereitstellen

Kubernetes ist ein Open-Source-Projekt, das sich in vielen verschiedenen Umgebungen ausführen lässt – ob Laptop oder hochverfügbarer Cluster mit mehreren Knoten, ob öffentliche Cloud oder lokales Deployment, ob VM-Instanz (virtuelle Maschine) oder Bare-Metal-Server.

In diesem Codelab stellen Sie eine einfache Spring Boot-Java-Webanwendung in Kubernetes auf GKE bereit. Ziel ist es, dass Sie Ihre Webanwendung als replizierte Anwendung in Kubernetes ausführen. Dazu verwenden Sie Code, den Sie auf Ihrem Computer entwickelt haben, wandeln ihn in ein Docker-Container-Image um und führen dieses dann in GKE aus.

Sie verwenden GKE, einen vollständig verwalteten Kubernetes-Dienst in Google Cloud, damit Sie sich auf Kubernetes konzentrieren können, anstatt die zugrunde liegende Infrastruktur einrichten zu müssen.

Wenn Sie Kubernetes auf Ihrem lokalen Computer ausführen möchten, z. B. auf einem Entwicklerlaptop, sollten Sie sich Minikube ansehen. Damit lässt sich ein Kubernetes-Cluster mit einem einzelnen Knoten zu Entwicklungs- und Testzwecken ganz einfach einrichten. Wenn Sie möchten, können Sie Minikube auch für dieses Codelab verwenden.

In diesem Codelab wird der Beispielcode aus dem Leitfaden App mit Spring Boot erstellen verwendet.

Voraussetzungen

• Kenntnisse der Java-Programmiersprache und der entsprechenden Tools
• Kenntnisse von standardmäßigen Linux-Texteditoren wie Vim, Emacs und Nano

Aufgabe

• Einfache Java-App als Docker-Container verpacken
• Erstellen Sie Ihren Kubernetes-Cluster in GKE.
• Stellen Sie Ihre Java-Anwendung in Kubernetes in GKE bereit.
• Den Dienst skalieren und ein Upgrade bereitstellen
• Greifen Sie auf das Dashboard zu, eine webbasierte Kubernetes-Benutzeroberfläche.

Voraussetzungen

• Ein Google Cloud-Projekt
• Ein Browser, z. B. Google Chrome

Einrichtung der Umgebung im eigenen Tempo

1. Melden Sie sich in der Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes Projekt. Wenn Sie noch kein Gmail- oder G Suite-Konto haben, müssen Sie eins erstellen.

Hinweis:Sie können ganz einfach auf die Cloud Console zugreifen, indem Sie sich die URL console.cloud.google.com merken.

Notieren Sie sich die Projekt-ID, also den projektübergreifend nur einmal vorkommenden Namen eines Google Cloud-Projekts. Der oben angegebene Name ist bereits vergeben und kann leider nicht mehr verwendet werden. Sie wird in diesem Codelab später als PROJECT_ID bezeichnet.

Hinweis:Wenn Sie ein Gmail-Konto verwenden, können Sie den Standardspeicherort auf Keine Organisation belassen. Wenn Sie ein G Suite-Konto verwenden, wählen Sie einen Standort aus, der für Ihre Organisation sinnvoll ist.

2. Als Nächstes müssen Sie die Abrechnung in der Cloud Console aktivieren, um Google Cloud-Ressourcen verwenden zu können.

Dieses Codelab sollte Sie nicht mehr als ein paar Dollar kosten, aber es könnte mehr sein, wenn Sie sich für mehr Ressourcen entscheiden oder wenn Sie sie laufen lassen.

Neuen Nutzern der Google Cloud steht eine kostenlose Testversion mit einem Guthaben von 300$ zur Verfügung.

Cloud Shell aktivieren

1. Klicken Sie in der Cloud Console auf Cloud Shell aktivieren .

Wenn Sie Cloud Shell noch nie gestartet haben, wird ein Zwischenbildschirm angezeigt, auf dem beschrieben wird, was Cloud Shell ist. Klicken Sie in diesem Fall auf Weiter. So sieht dieser einmalige Bildschirm aus:

Die Bereitstellung und Verbindung mit Cloud Shell sollte nur wenige Augenblicke dauern.

Diese virtuelle Maschine verfügt über sämtliche Entwicklertools, die Sie benötigen. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Die meisten, wenn nicht alle Aufgaben in diesem Codelab können einfach mit einem Browser oder Ihrem Chromebook erledigt werden.

Sobald Sie mit Cloud Shell verbunden sind, sollten Sie sehen, dass Sie bereits authentifiziert sind und das Projekt bereits auf Ihre Projekt-ID eingestellt ist.

2. Führen Sie in Cloud Shell den folgenden Befehl aus, um zu prüfen, ob Sie authentifiziert sind:

gcloud auth list

Befehlsausgabe

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Hinweis : Das gcloud-Befehlszeilentool ist das leistungsstarke und einheitliche Befehlszeilentool in Google Cloud. Das Tool ist in Cloud Shell vorinstalliert. Sie werden feststellen, dass die Tab-Vervollständigung unterstützt wird. Weitere Informationen finden Sie in der Übersicht über das gcloud-Befehlszeilentool.

gcloud config list project

Befehlsausgabe

[core]
project = <PROJECT_ID>

Ist dies nicht der Fall, können Sie die Einstellung mit diesem Befehl vornehmen:

gcloud config set project <PROJECT_ID>

Befehlsausgabe

Updated property [core/project].

Nachdem Cloud Shell gestartet wurde, können Sie über die Befehlszeile den Beispielquellcode im Basisverzeichnis klonen.

$ git clone https://github.com/spring-guides/gs-spring-boot.git
$ cd gs-spring-boot/complete

1. Sie können die Spring Boot-App wie gewohnt mit dem Spring Boot-Plug-in starten.

$ ./mvnw -DskipTests spring-boot:run

2. Klicken Sie nach dem Start der App in der Cloud Shell-Symbolleiste auf Webvorschau und wählen Sie Vorschau auf Port 8080 aus.

Im Browser wird ein Tab geöffnet und eine Verbindung zum soeben gestarteten Server hergestellt.

Als Nächstes müssen Sie Ihre App darauf vorbereiten, in Kubernetes ausgeführt zu werden. Dazu legen Sie zuerst den Container und seine Inhalte fest.

1. Erstellen Sie das bereitstellbare JAR für die App.

$ ./mvnw -DskipTests package

2. Aktivieren Sie Container Registry, um das Container-Image zu speichern, das Sie erstellen.

$ gcloud services enable containerregistry.googleapis.com

3. Verwenden Sie Jib, um das Container-Image zu erstellen und in die Container Registry zu übertragen.

$ ./mvnw -DskipTests com.google.cloud.tools:jib-maven-plugin:build \
  -Dimage=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

4. Wenn alles gut geht, sollte das Container-Image in der Konsole unter Container Registry > Images aufgeführt sein. Ihnen steht nun ein Docker-Image für das gesamte Projekt zur Verfügung, das sich mit Kubernetes aufrufen und orchestrieren lässt, wie Sie gleich sehen werden.

Hinweis:Statt der generischen Domain, die hier für die Registry (gcr.io) verwendet wurde, können Sie auch genauere Angaben zur Zone und zum Bucket machen, die verwendet werden sollen. Weitere Informationen finden Sie in der Dokumentation zu Container Registry.

5. Nachdem der Vorgang abgeschlossen ist (es dauert einige Zeit, bis alles heruntergeladen und extrahiert wurde), können Sie das Image lokal mit dem folgenden Befehl testen. Dadurch wird ein Docker-Container als Daemon von Ihrem neu erstellten Container-Image auf Port 8080 ausgeführt:

$ docker run -ti --rm -p 8080:8080 \
  gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

6. Sie können dazu wieder die Webvorschau von Cloud Shell nutzen.

7. Sie sollten nun die Standardseite in einem neuen Tab sehen. Nachdem Sie überprüft haben, dass die App lokal in einem Docker-Container ausgeführt wird, können Sie den Container durch Drücken von Control+C stoppen.

Sie können jetzt Ihren GKE-Cluster erstellen. Ein Cluster besteht aus einem von Google verwalteten Kubernetes API-Server und einer Reihe von Worker-Knoten. Bei den Worker-Knoten handelt es sich um Compute Engine-VMs.

1. Prüfen Sie zuerst, ob die zugehörigen API-Funktionen aktiviert sind.

$ gcloud services enable compute.googleapis.com container.googleapis.com
Operation "operations/..." finished successfully

2. Erstellen Sie einen Cluster mit zwei n1-standard-1-Knoten. Das kann einige Minuten dauern.

$ gcloud container clusters create hello-java-cluster \
  --num-nodes 2 \
  --machine-type n1-standard-1 \
  --zone us-central1-c

Am Ende sollten Sie den erstellten Cluster sehen.

Creating cluster hello-java-cluster...done.
Created [https://container.googleapis.com/v1/projects/...].
kubeconfig entry generated for hello-dotnet-cluster.
NAME                  ZONE            MASTER_VERSION  
hello-java-cluster  us-central1-c  ...

Hinweis : Alternativ können Sie den Cluster in der Cloud Console erstellen. Klicken Sie dazu auf das Navigationsmenü > Kubernetes Engine> Cluster> Cluster erstellen. Sie können einen Cluster auch in einer anderen Zone erstellen, aber es wird empfohlen, ihn in derselben Region zu speichern, in der sich der von Container Registry verwendete Storage-Bucket befindet.

Sie sollten jetzt einen voll funktionsfähigen Kubernetes-Cluster haben, der von GKE bereitgestellt wird.

Und nun stellen Sie Ihre containerisierte Anwendung auf den Kubernetes-Clustern bereit. Ab jetzt verwenden Sie die Befehlszeile kubectl, die bereits in Ihrer Cloud Shell-Umgebung eingerichtet ist. Für den Rest des Codelabs ist es erforderlich, dass sowohl der Kubernetes-Client als auch der Server mindestens die Versionsnummer 1.2 hat. Mit kubectl version wird die aktuelle Version des Befehls angezeigt.

1. Mit einem Kubernetes-Deployment können mehrere Instanzen Ihrer App mit dem von Ihnen erstellten Container-Image erstellt, verwaltet und skaliert werden. Stellen Sie eine Instanz Ihrer App mit dem Befehl kubectl run in Kubernetes bereit.

$ kubectl create deployment hello-java \
  --image=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

2. Führen Sie einfach den folgenden Befehl aus, um sich das erstellte Deployment anzusehen:

$ kubectl get deployments
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-java   1         1         1            1           37s

3. Führen Sie den folgenden Befehl aus, um die von der Bereitstellung erstellten App-Instanzen aufzurufen:

$ kubectl get pods
NAME                         READY     STATUS    RESTARTS   AGE
hello-java-714049816-ztzrb   1/1       Running   0          57s

Der Container wird nun unter Kubernetes ausgeführt. Sie müssen ihn jedoch noch für die Öffentlichkeit zugänglich machen.

Standardmäßig kann nur die interne IP innerhalb des Clusters auf den Pod zugreifen. Damit der hello-java-Container von außerhalb des virtuellen Kubernetes-Netzwerks zugänglich wird, müssen Sie den Pod als Kubernetes-Dienst zur Verfügung stellen.

1. In Cloud Shell können Sie den Pod mit dem Befehl kubectl expose und dem Flag --type=LoadBalancer dem öffentlichen Internet zugänglich machen. Das Flag ist für die Erstellung einer extern zugänglichen IP erforderlich.

$ kubectl create service loadbalancer hello-java --tcp=8080:8080

Das im Befehl verwendete Flag gibt an, dass Sie den Load-Balancer nutzen, der von der zugrundeliegenden Infrastruktur bereitgestellt wird. Hinweis: Sie machen das Deployment und nicht den Pod direkt verfügbar. Als Folge führt der resultierende Dienst ein Load Balancing des Traffics für alle vom Deployment verwalteten Pods durch (in diesem Fall nur für einen Pod, später werden jedoch weitere Replikate hinzugefügt).

Der Kubernetes-Master erstellt den Load Balancer und die zugehörigen Compute Engine-Weiterleitungsregeln, Zielpools und Firewallregeln, um den Dienst von außerhalb von Google Cloud vollständig zugänglich zu machen.

2. Die öffentlich zugängliche IP-Adresse des Dienstes erhalten Sie, wenn Sie den Befehl kubectl ausführen. Damit können Sie sich alle Clusterdienste auflisten lassen.

$ kubectl get services
NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
Hello-java   10.3.253.62    aaa.bbb.ccc.ddd  8080/TCP    1m
kubernetes   10.3.240.1     <none>           443/TCP    5m

Hinweis : Es kann einige Minuten dauern, bis die EXTERNAL-IP verfügbar und sichtbar ist. Wenn EXTERNAL-IP fehlt, warten Sie einige Minuten und versuchen Sie es dann noch einmal.

3. Hinweis: Für den Dienst sind zwei IP-Adressen aufgelistet, die beide Port 8080 bedienen. Eine davon ist die interne IP-Adresse, die nur in Ihrer Virtual Private Cloud sichtbar ist. Die andere ist die externe IP-Adresse mit Lastenausgleich. Im Beispiel lautet die externe IP-Adresse aaa.bbb.ccc.ddd. Sie sollten den Dienst jetzt erreichen können. Verweisen Sie dazu Ihren Browser auf http://<EXTERNAL_IP>:8080.

Eine der leistungsstarken Funktionen von Kubernetes ist die einfache Skalierung Ihrer App. Angenommen, Sie benötigen plötzlich mehr Kapazität für Ihre App. Sie können den Replikationscontroller einfach anweisen, eine neue Anzahl von Replikaten für Ihre App-Instanzen zu verwalten.

$ kubectl scale deployment hello-java --replicas=3
deployment "hello-java" scaled

$ kubectl get deployment
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-java   3         3         3            3           22m

Beachten Sie den deklarativen Ansatz. Anstatt neue Instanzen zu starten oder anzuhalten, deklarieren Sie, wie viele Instanzen zu jeder Zeit ausgeführt werden sollen. Die Abstimmungsschleifen von Kubernetes sorgen dafür, dass dies tatsächlich passiert und bei Bedarf Maßnahmen ergriffen werden.

Früher oder später sind für die App, die Sie für die Produktion bereitgestellt haben, Fehlerbehebungen oder zusätzliche Funktionen erforderlich. Kubernetes unterstützt Sie bei der Bereitstellung einer neuen Version für die Produktion, ohne Ihre Nutzer zu beeinträchtigen.

1. Öffnen Sie den Code-Editor. Klicken Sie dazu im Cloud Shell-Menü auf Editor starten .
2. Rufen Sie src/main/java/hello/HelloController.java auf und aktualisieren Sie den Wert der Antwort.

package hello;

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
public class HelloController {    
    @RequestMapping("/")
    public String index() {
        return "Greetings from Google Kubernetes Engine!";
    }
}

3. Verwenden Sie Jib, um eine neue Version des Container-Images zu erstellen und per Push zu übertragen.

$ ./mvnw -DskipTests package \
  com.google.cloud.tools:jib-maven-plugin:build \
  -Dimage=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v2

Hinweis : Das Erstellen und Hochladen des aktualisierten Images sollte dank Caching deutlich schneller gehen.

Sie können nun mit Kubernetes den Replikations-Controller problemlos auf die neue App-Version aktualisieren.

4. Um das Image-Label Ihres Containers zu ändern, müssen Sie das bestehende hello-java-Deployment bearbeiten und das Image von gcr.io/PROJECT_ID/hello-java:v1 zu gcr.io/PROJECT_ID/hello-java:v2 ändern.

5. Mit dem Befehl kubectl set image können Sie Kubernetes anweisen, die neue Version Ihrer App mit Rolling Updates im gesamten Cluster bereitzustellen.

$ kubectl set image deployment/hello-java \
  hello-java=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v2

deployment "hello-java" image updated

Hinweis : Währenddessen kann es zu Unterbrechungen für die Nutzer der Dienste kommen. Das liegt daran, dass keine Systemdiagnose konfiguriert wurde. Das ist eine etwas fortgeschrittenere Konfiguration, die über den Rahmen dieses Codelabs hinausgeht.

6. Rufen Sie noch einmal http://EXTERNAL_IP:8080 auf, um zu prüfen, ob die neue Antwort zurückgegeben wird.

Hoppla! Haben Sie einen Fehler in einer neuen Version der App gemacht? Vielleicht enthält die neue Version einen Fehler und Sie müssen sie schnell zurücksetzen. Mit Kubernetes können Sie ganz einfach zum vorherigen Status zurückkehren. Machen Sie die App mit dem folgenden Befehl rückgängig:

$ kubectl rollout undo deployment/hello-java

Sie haben gelernt, wie Sie eine neue Java-basierte Webanwendung in Kubernetes in GKE erstellen und bereitstellen.

Weitere Informationen

• Java in Google Cloud
• Java-Codebeispiele
• Kubernetes in GKE – Grundlagen bis fortgeschrittene Themen