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

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

Informationen zu diesem Codelab

Zuletzt aktualisiert: Apr. 22, 2020

Verfasst von einem Google-Mitarbeiter

1. Hinweis

Kubernetes ist ein Open-Source-Projekt, das in vielen verschiedenen Umgebungen ausgeführt werden kann – von Laptops bis hin zu hochverfügbaren Clustern mit mehreren Knoten, von öffentlichen Clouds bis zu lokalen Bereitstellungen und von VM-Instanzen bis hin zu Bare-Metal-Servern.

In diesem Codelab stellen Sie eine einfache Spring-Boot-Java-Webanwendung auf Kubernetes in GKE bereit. Das Ziel ist, dass Ihre Webanwendung als replizierte Anwendung auf Kubernetes ausgeführt wird. Sie nehmen Code, den Sie auf Ihrem Computer entwickeln, in ein Docker-Container-Image um und führen das Image in GKE aus.

Sie verwenden GKE, einen vollständig verwalteten Kubernetes-Dienst in Google Cloud, damit Sie sich auf die Nutzung von Kubernetes konzentrieren können, anstatt die zugrunde liegende Infrastruktur einzurichten.

Wenn Sie Kubernetes auf Ihrem lokalen Computer, z. B. einem Entwicklungslaptop, ausführen möchten, sehen Sie sich Minikube an. Hier wird die einfache Einrichtung eines Kubernetes-Clusters mit einem einzelnen Knoten zu Entwicklungszwecken und Tests angeboten. Wenn Sie möchten, können Sie Minikube verwenden.

Im Codelab wird der Beispielcode aus der Anleitung Anwendung mit Spring Boot verwenden verwendet.

Voraussetzungen

• Kenntnisse in der Programmiersprache Java und in Tools
• Kenntnisse in standardmäßigen Linux-Texteditoren wie Vim, Emacs und nano

Aufgabe

• Eine einfache Java-Anwendung als Docker-Container verpacken.
• Kubernetes-Cluster in GKE erstellen
• Java-Anwendung in Kubernetes on GKE bereitstellen
• Skalieren Sie Ihren Dienst und führen Sie ein Upgrade aus.
• Dashboard aufrufen, eine webbasierte Kubernetes-Benutzeroberfläche.

Voraussetzungen

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

2. Einrichtung und Anforderungen

Umgebung im eigenen Tempo einrichten

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

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

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. In diesem Codelab wird sie später als PROJECT_ID bezeichnet.

Hinweis:Wenn Sie ein Gmail-Konto verwenden, können Sie die Standardeinstellung Keine Organisation beibehalten. Wenn Sie ein G Suite-Konto verwenden, wählen Sie einen für Ihre Organisation sinnvollen Standort aus.

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

Das Durcharbeiten dieses Codelabs sollte nicht mehr als ein paar Euro kosten. Es kann aber auch sein, dass du mehr Ressourcen benötigst oder wenn du sie nicht mehr nutzen möchtest.

Neuen Google Cloud-Nutzern steht ein kostenloser Testzeitraum im Wert 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, sehen Sie einen Zwischenbildschirm („Below the fold“ (mit Scrollen sichtbar) mit einer Beschreibung, worum es sich dabei handelt. Klicken Sie in diesem Fall auf Weiter. In diesem Fall wird es nicht wieder angezeigt. So sieht der einmalige Bildschirm aus:

Die Bereitstellung und Verbindung mit Cloud Shell dauert nur wenige Minuten.

Diese virtuelle Maschine verfügt über sämtliche Entwicklertools, die Sie benötigen. Es bietet ein 5-GB-Basisverzeichnis und wird in Google Cloud ausgeführt, was die Netzwerkleistung und Authentifizierung erheblich verbessert. In diesem Codelab lassen sich viele oder sogar alle Aufgaben ganz einfach über einen Browser oder Ihr Chromebook erledigen.

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

2. Führen Sie in Cloud Shell den folgenden Befehl aus, um zu bestätigen, dass 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 Befehlszeilentool gcloud ist das leistungsstarke und einheitliche Befehlszeilentool in Google Cloud. Cloud Shell ist in Cloud Shell vorinstalliert. Sie werden feststellen, dass der Tab vollständig unterstützt wird. Weitere Informationen finden Sie unter 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].

3. Quellcode abrufen

Nach dem Start von Cloud Shell können Sie den Beispielcode im Basisverzeichnis über die Befehlszeile klonen.

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

4. App lokal ausführen

1. Du kannst die Spring Boot App ganz normal 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.

5. Java-Anwendung als Docker-Container verpacken

Als Nächstes müssen Sie Ihre Anwendung so vorbereiten, dass sie auf Kubernetes ausgeführt werden kann. Dazu legen Sie zuerst den Container und seine Inhalte fest.

1. Erstellen Sie die JAR-Datei für die Anwendung.

$ ./mvnw -DskipTests package

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

$ gcloud services enable containerregistry.googleapis.com

3. Sie erstellen mit Jib das Container-Image und verschieben es in die Container Registry.

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

4. Wenn alles funktioniert, sehen Sie das Container-Image in der Konsole, indem Sie zu Container Registry > Images gehen. Sie haben jetzt ein projektweites Docker-Image, auf das Kubernetes zugreifen kann. Wie Sie in wenigen Minuten sehen, steht Kubernetes zur Verfügung.

Hinweis: Sie haben zwar eine allgemeine Domain für die Registry (gcr.io) verwendet, können jedoch auch spezifischere Angaben zur Zone und zum Bucket machen. Weitere Informationen finden Sie in der Dokumentation zu Container Registry.

5. Wenn der Vorgang abgeschlossen ist (es dauert etwas, bis Sie alles heruntergeladen und extrahiert haben), können Sie das Image mit dem folgenden Befehl lokal testen. Damit wird ein Docker-Container als Daemon auf Port 8080 aus dem neu erstellten Container-Image ausgeführt:

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

6. Nutzen Sie wieder die Webvorschaufunktion von Cloud Shell.

7. Sie sollten die Standardseite in einem neuen Tab sehen. Nachdem Sie bestätigt haben, dass die Anwendung lokal in einem Docker-Container ausgeführt wird, können Sie den ausgeführten Container durch Drücken von Control+C beenden.

6. Cluster erstellen

Sie können Ihren GKE-Cluster jetzt erstellen. Ein Cluster besteht aus einem Kubernetes API-Server, der von Google verwaltet wird, und aus einer Reihe von Worker-Knoten. Die Worker-Knoten sind Compute Engine-VMs.

1. Überprü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. Dies dauert einige Minuten.

$ 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: Sie können den Cluster auch in der Cloud Console erstellen. Klicken Sie dazu auf das Navigationsmenü > Kubernetes Engine > Cluster > Cluster erstellen. Sie können einen Cluster in einer anderen Zone erstellen. Es wird jedoch empfohlen, sich in derselben Region wie der von Container Registry verwendete Storage-Bucket zu bleiben.

Sie sollten jetzt einen voll funktionsfähigen Kubernetes-Cluster mit GKE haben.

Jetzt können Sie Ihre containerisierte Anwendung im Kubernetes-Cluster bereitstellen. Ab jetzt verwenden Sie die Befehlszeile kubectl (bereits in Ihrer Cloud Shell-Umgebung eingerichtet). Für den Rest des Codelabs müssen der Kubernetes-Client und die Serverversion mindestens 1.2 sein. kubectl version zeigt die aktuelle Version des Befehls an.

7. Ihre Anwendung auf Kubernetes bereitstellen

1. Bei einem Kubernetes-Deployment können mehrere Instanzen Ihrer Anwendung mit dem von Ihnen erstellten Container-Image erstellt, verwaltet und skaliert werden. Stellen Sie eine Instanz Ihrer Anwendung 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 den folgenden Befehl aus, um die von Ihnen erstellte Bereitstellung aufzurufen:

$ 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 durch das Deployment erstellten Anwendungsinstanzen anzusehen:

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

Der Container sollte aktuell unter Kubernetes verwaltet werden, Sie müssen ihn aber auch für die Außenwelt zugänglich machen.

8. Externen Traffic zulassen

Standardmäßig ist der Pod nur über seine interne IP-Adresse im Cluster zugänglich. Damit der hello-java-Container von außerhalb des Kubernetes-Netzwerks zugänglich ist, muss der Pod als Kubernetes-Dienst verfügbar gemacht werden.

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. Dieses Flag ist für die Erstellung einer extern zugänglichen IP-Adresse erforderlich.

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

Das im Befehl verwendete Flag gibt an, dass Sie den Load-Balancer verwenden, der von der zugrunde liegenden Infrastruktur bereitgestellt wird. Beachten Sie, dass Sie das Deployment direkt bereitstellen, nicht den Pod. Dies führt dazu, dass der entsprechende Dienst den Traffic auf allen von der Bereitstellung verwalteten Pods auslastet (in diesem Fall nur ein 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 vollständig von außerhalb von Google Cloud zugänglich zu machen.

2. Wenn Sie die öffentlich zugängliche IP-Adresse des Dienstes ermitteln möchten, fordern Sie einfach kubectl an, um alle Clusterdienste aufzulisten.

$ 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 EXTERNAL-IP verfügbar und sichtbar ist. Wenn EXTERNAL-IP nicht vorhanden ist, warten Sie ein paar Minuten und versuchen Sie es dann noch einmal.

3. Für Ihren Dienst werden zwei IP-Adressen angegeben, die beide Port 8080 bereitstellen. Dies ist die interne IP-Adresse, die nur in Ihrer Virtual Private Cloud sichtbar ist. Die andere ist die externe IP-Adresse mit Load-Balancing. Im Beispiel lautet die externe IP-Adresse aaa.bbb.ccc.ddd. Sie sollten den Dienst jetzt erreichen, indem Sie Ihren Browser auf http://<EXTERNAL_IP>:8080 verweisen.

9. Dienste skalieren

Eine der leistungsstarken Funktionen von Kubernetes ist die einfache Skalierung Ihrer Anwendung. Angenommen, Sie benötigen plötzlich eine größere Kapazität für Ihre Anwendung. Sie können einfach den Replikations-Controller anweisen, eine neue Anzahl von Replikaten für Ihre Anwendungsinstanzen 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 die deklarative Herangehensweise. Anstatt neue Instanzen zu starten oder anzuhalten, deklarieren Sie, wie viele Instanzen zu jeder Zeit ausgeführt werden sollen. Beim Abgleich von Kubernetes-Abgleichsschleifen wird lediglich sichergestellt, dass die Realität Ihren Anforderungen entspricht und bei Bedarf Maßnahmen ergriffen werden.

10. Upgrade für Ihren Dienst bereitstellen

Die Produktions-App, die Sie bereitstellen möchten, muss bald behoben oder mit zusätzlichen Funktionen ausgestattet werden. Mit Kubernetes können Sie eine neue Version in der Produktion bereitstellen, 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. Sie können mit Jib eine neue Version des Container-Images erstellen und übertragen.

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

Hinweis: Wenn Sie das Caching optimal nutzen möchten, sollte das aktualisierte Image viel schneller erstellt und übertragen werden.

Sie können jetzt den Replikations-Controller von Kubernetes reibungslos auf die neue Version der Anwendung aktualisieren.

4. Wenn Sie das Image-Label für Ihren ausgeführten Container ändern möchten, müssen Sie das vorhandene hello-java-Deployment bearbeiten und das Image von gcr.io/PROJECT_ID/hello-java:v1 in gcr.io/PROJECT_ID/hello-java:v2 ändern.

5. Mit dem Befehl kubectl set image können Sie Kubernetes bitten, die neue Version Ihrer Anwendung mit den rollierenden Updates nacheinander 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ährend dies passiert, können bei den Nutzern der Dienste Unterbrechungen auftreten. Das ist jedoch nicht möglich, weil keine Systemdiagnose konfiguriert wurde. Das ist eine etwas komplexere Konfiguration, die über den Rahmen des Codelabs hinausgeht.

6. Überprüfen Sie http://EXTERNAL_IP:8080 noch einmal, ob die neue Antwort zurückgegeben wird.

11. Rollback durchführen

Hoppla! Haben Sie einen Fehler mit einer neuen Version der App gemacht? Möglicherweise enthielt die neue Version einen Fehler und Sie müssen schnell ein Rollback durchführen. Mit Kubernetes können Sie ganz einfach den vorherigen Zustand wiederherstellen. Führen Sie mit dem folgenden Befehl ein Rollback der Anwendung durch:

$ kubectl rollout undo deployment/hello-java

12. Glückwunsch

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 on GKE – Grundlagen für Fortgeschrittene