Mit Jib containerisierte Micronaut-Anwendung in Google Kubernetes Engine bereitstellen

1. Übersicht

Micronaut

Micronaut ist ein modernes, JVM-basiertes Full-Stack-Framework zum Erstellen modularer, einfach testbarer Microservice- und serverloser Anwendungen. Micronaut zielt darauf ab, eine kurze Startzeit, einen schnellen Durchsatz und einen minimalen Speicherbedarf zu bieten. Entwickler können mit Micronaut in Java, Groovy oder Kotlin entwickeln.

Micronaut bietet:

• Schnelle Startzeit und geringer Arbeitsspeicherverbrauch: Reflexionsbasierte IoC-Frameworks laden und cachen Reflexionsdaten für jedes Feld, jede Methode und jeden Konstruktor in Ihrem Code. Bei Micronaut sind die Startzeit und der Arbeitsspeicherverbrauch Ihrer Anwendung jedoch nicht an die Größe Ihrer Codebasis gebunden.
• Deklarativer, reaktiver HTTP-Client zur Kompilierzeit: Sie können reaktive HTTP-Clients deklarativ erstellen, die zur Kompilierzeit implementiert werden, wodurch der Arbeitsspeicherverbrauch reduziert wird.
• Nicht blockierender HTTP-Server, der auf Netty basiert: Der HTTP-Server von Micronaut ist einfach zu erlernen und macht es so einfach wie möglich, APIs bereitzustellen, die von HTTP-Clients genutzt werden können.
• Schnelles und einfaches Testen: Sie können Server und Clients in Ihren Unit-Tests ganz einfach starten und sofort ausführen.
• Effiziente Compile-time-Abhängigkeitsinjektion und AOP: Micronaut bietet eine einfache API für aspektorientierte Programmierung (AOP) zur Compile-time, die keine Reflexion verwendet.
• Vollständig reaktive und nicht blockierende Apps erstellen: Micronaut unterstützt alle Frameworks, die Reactive Streams implementieren, einschließlich RxJava und Reactor.

Weitere Informationen finden Sie auf der Micronaut-Website.

Informationen zu Kubernetes

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 virtuelle Maschine oder Bare-Metal-Server.

In diesem Lab stellen Sie einen einfachen Groovy-basierten Micronaut-Mikrodienst in Kubernetes bereit, die in einer Kubernetes Engine ausgeführt wird.

Ziel dieses Codelabs ist es, Ihren Mikrodienst als replizierten Dienst auszuführen, der auf Kubernetes ausgeführt wird. 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 Kubernetes Engine aus.

In diesem Diagramm sehen Sie die verschiedenen Teile dieses Codelabs, um einen Eindruck zu gewinnen, wie alles miteinander zusammenhängt. Verwenden Sie es als Referenz, während Sie das Codelab absolvieren. Am Ende des Codelabs sollte alles schlüssig sein (fürs Erste können Sie es jedoch auch einfach ignorieren).

Für dieses Codelab sollten Sie eine verwaltete Umgebung wie die Kubernetes Engine verwenden. Das ist eine bei Google gehostete Version von Kubernetes, die in der Compute Engine ausgeführt wird. Dadurch können Sie sich auf Kubernetes konzentrieren, ohne erst die zugrundeliegende Infrastruktur einrichten zu müssen.

Wenn Sie wissen möchten, wie Sie Kubernetes auf Ihrem lokalen Computer ausführen, 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.

Informationen zu Jib

Jib ist ein Open-Source-Tool, mit dem Sie Docker- und OCI-Images für Ihre Java-Anwendungen erstellen können. Es ist als Plug-in für Maven und Gradle sowie als Java-Bibliothek verfügbar.

Jib soll Folgendes sein:

• Schnell: Änderungen schnell bereitstellen. Jib unterteilt Ihre Anwendung in mehrere Ebenen und trennt Abhängigkeiten von Klassen. Sie müssen jetzt nicht mehr warten, bis Docker Ihre gesamte Java-Anwendung neu erstellt hat, sondern können nur die geänderten Ebenen bereitstellen.
• Reproduzierbar: Wenn Sie Ihr Container-Image mit demselben Inhalt neu erstellen, wird immer dasselbe Image generiert. Nie wieder unnötige Updates auslösen
• Ohne Daemon: CLI-Abhängigkeiten reduzieren. Erstellen Sie Ihr Docker-Image in Maven oder Gradle und übertragen Sie es per Push in eine beliebige Registry. Sie müssen keine Dockerfiles mehr schreiben und „docker build/push“ aufrufen.

Weitere Informationen zu Jib finden Sie auf der Projektseite auf GitHub.

Informationen zu dieser Anleitung

In dieser Anleitung wird der Beispielcode aus dem Jib-Tool verwendet, um Container für Java-Anwendungen zu erstellen.

Das Beispiel ist ein einfacher Hello World-Dienst, der das Micronaut-Framework und die Programmiersprache Apache Groovy verwendet.

Lerninhalte

• Eine einfache Java-Anwendung mit Jib als Docker-Container verpacken
• Einen Kubernetes-Cluster in Kubernetes Engine erstellen
• Micronaut-Dienst in Kubernetes in Kubernetes Engine bereitstellen
• Den Dienst skalieren und ein Upgrade bereitstellen
• Auf das Kubernetes Graphical-Dashboard zugreifen

Voraussetzungen

• Google Cloud Platform-Projekt
• Browser, z. B. Chrome oder Firefox
• Erfahrung mit standardmäßigen Linux-Texteditoren wie Vim, EMACs oder Nano

Wie werden Sie diese Anleitung verwenden?

Nur lesen Lesen und Übungen durchführen

Wie würden Sie Ihre Erfahrung mit der Entwicklung von HTML/CSS-Web-Apps bewerten?

Anfänger Mittelstufe Fortgeschrittene

Wie würden Sie Ihre Erfahrungen mit der Verwendung von Google Cloud Platform-Diensten bewerten?

Anfänger Mittelstufe Fortgeschritten

2. Einrichtung und Anforderungen

Umgebung zum selbstbestimmten Lernen einrichten

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 eines erstellen.

Hinweis:Wir empfehlen Ihnen, sich die URL console.cloud.google.com zu merken. Damit können Sie mühelos auf die Cloud Console zugreifen.

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 später in diesem Codelab 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.

Die Durchführung dieses Codelabs sollte keine oder nur geringe Kosten verursachen. Folgen Sie bitte der Anleitung im Abschnitt „Bereinigen“, in der Sie erfahren, wie Sie Ressourcen herunterfahren können, damit nach Abschluss dieser Anleitung keine Gebühren anfallen. Neue Nutzer von Google Cloud kommen für das Programm für den kostenlosen Testzeitraum mit einem Guthaben von 300$ infrage.

3. Micronaut-Beispielquellcode abrufen

Nachdem Cloud Shell gestartet wurde, können Sie über die Befehlszeile den Beispielquellcode im Basisverzeichnis klonen und in das Verzeichnis mit unserem Beispieldienst wechseln:

$ git clone https://github.com/GoogleContainerTools/jib.git
$ cd jib/examples/micronaut/

Das Jib-Projekt-Repository enthält auch Beispielprojekte für andere Frameworks wie Spring Boot oder Vert.x, falls Sie auch mit anderen Beispielen experimentieren möchten.

4. Kurzer Blick auf den Code

Unser einfacher Micronaut-Dienst besteht aus einem Controller, der die berühmte „Hello World“-Nachricht ausgibt:

@Controller("/hello")
class HelloController {
    @Get("/")
    String index() {
        "Hello World"
    }
}

Der HelloController-Controller reagiert auf Anfragen unter dem Pfad /hello und die index()-Methode akzeptiert die HTTP-GET-Anfragen.

Außerdem ist eine Spock-Testklasse verfügbar, mit der geprüft werden kann, ob die richtige Meldung in der Ausgabe angezeigt wird.

class HelloControllerSpec extends Specification {
    @Shared
    @AutoCleanup
    EmbeddedServer embeddedServer = ApplicationContext.run(EmbeddedServer)

    @Shared
    @AutoCleanup
    RxHttpClient client = embeddedServer.applicationContext.createBean(RxHttpClient, embeddedServer.getURL()) 

    void "test hello world response"() {
        when:
        HttpRequest request = HttpRequest.GET('/hello')
        String rsp  = client.toBlocking().retrieve(request)

        then:
        rsp == "Hello World"
    }
}

Dieser Test ist mehr als ein einfacher Einheitentest. Er führt denselben Micronaut-Server-Stack (basierend auf dem Netty-Framework) aus, der auch in der Produktion ausgeführt wird. Das Verhalten Ihres Codes ist also im Produkt genauso wie in Ihren Tests.

Führen Sie zum Ausführen der Tests den folgenden Befehl aus, um zu prüfen, ob alles in Ordnung ist:

./gradlew test

5. Anwendung lokal ausführen

Sie können den Micronaut-Dienst mit dem folgenden Gradle-Befehl normal starten:

$ ./gradlew run

Nachdem die Anwendung gestartet wurde, können Sie über das kleine Pluszeichen eine zusätzliche Cloud Shell-Instanz öffnen und dann mit „curl“ prüfen, ob Sie die erwartete Ausgabe erhalten:

$ curl localhost:8080/hello

Es sollte eine einfache „Hello World“-Meldung angezeigt werden.

6. Anwendung mit Jib als Docker-Container verpacken

Als Nächstes bereiten Sie die App darauf vor, auf Kubernetes ausgeführt zu werden. Dazu nutzen wir Jib, damit wir uns nicht selbst um ein Dockerfile kümmern müssen.

Führen Sie den Befehl zum Erstellen des Containers aus:

$ ./gradlew jibDockerBuild

Die Ausgabe sollte so aussehen:

Tagging image with generated image reference micronaut-jib:0.1. If you'd like to specify a different tag, you can set the jib.to.image parameter in your build.gradle, or use the --im
age=<MY IMAGE> commandline flag.

Containerizing application to Docker daemon as micronaut-jib:0.1...
warning: Base image 'gcr.io/distroless/java' does not use a specific image digest - build may not be reproducible
Getting base image gcr.io/distroless/java...
Building dependencies layer...
Building resources layer...
Building classes layer...
Finalizing...

Container entrypoint set to [java, -cp, /app/resources:/app/classes:/app/libs/*, example.micronaut.Application]
Loading to Docker daemon...

Built image to Docker daemon as micronaut-jib:0.1

Jib erstellt ein Docker-Image mit verschiedenen Ebenen: für Ihre Abhängigkeiten, für Ihre Ressourcen und für Ihren kompilierten Code. Wenn Sie beispielsweise Ihren Code ändern, wird nur die Ebene mit den kompilierten Klassen geändert. So wird die Build-Zeit verkürzt, da die vorherigen Ebenen, die nicht geändert wurden, wiederverwendet werden.

Nachdem das Image erstellt wurde, prüfen wir, ob wir unsere freundliche Begrüßungsnachricht sehen können. Dazu führen wir das Docker-Image auf dem ersten Tab von Cloud Shell aus:

$ docker run -it -p 8080:8080 micronaut-jib:0.1
16:57:20.255 [main] INFO  i.m.context.env.DefaultEnvironment - Established active environments: [cloud, gcp]
16:57:23.203 [main] INFO  io.micronaut.runtime.Micronaut - Startup completed in 2926ms. Server Running: http://97b7d76ccf3f:8080

Unser Dienst wird ausgeführt. Wir können jetzt in unserem zweiten Cloud Shell-Tab den curl-Befehl ausführen, um zu prüfen, ob er wie erwartet funktioniert:

$ curl localhost:8080/hello
Hello World

Sie können den Container beenden, indem Sie in Cloud Shell Ctrl+C drücken.

7. Containerisierten Dienst in die Registry übertragen

Wenn nun das Image wie gewünscht funktioniert, laden Sie es in die Google Container Registry hoch. Das ist ein privates Repository für Ihre Docker-Images, auf die von jedem Google Cloud-Projekt aus (aber auch von außerhalb der Google Cloud Platform) zugegriffen werden kann.

Bevor wir in die Registry hochladen können, müssen wir sicherstellen, dass die Container Registry für unser Projekt aktiviert ist. Rufen Sie dazu Tools > Container Registry auf. Wenn sie nicht aktiviert ist, wird das folgende Dialogfeld angezeigt. Klicken Sie dann auf Container Registry API aktivieren, um sie zu aktivieren:

Wenn die Registry bereit ist, führen Sie die folgenden Befehle aus, um das Image in die Registry zu übertragen:

$ gcloud auth configure-docker
$ docker tag micronaut-jib:0.1 \
         gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.1
$ docker push gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.1

Mit den oben genannten Befehlen wird das gcloud SDK so konfiguriert und autorisiert, dass Docker Images in Ihre Container Registry-Instanz übertragen kann. Außerdem wird das Image mit einem Tag versehen, das auf seinen Speicherort in der Registry verweist, und dann in die Registry übertragen.

Wenn alles gut geht, sollte das Container-Image nach einiger Zeit in der Konsole unter Tools > Container Registry 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 unter https://cloud.google.com/container-registry/docs/#pushing_to_the_registry.

8. Cluster erstellen

Sie können jetzt Ihren Kubernetes Engine-Cluster erstellen. Rufen Sie dazu den Bereich „Google Kubernetes Engine“ in der Webkonsole auf und warten Sie, bis das System initialisiert wurde. Das sollte nur wenige Sekunden dauern.

Ein Cluster besteht aus einem von Google verwalteten Kubernetes Master API-Server und einer Reihe von Worker-Knoten. Bei den Worker-Knoten handelt es sich um virtuelle Compute Engine-Maschinen. Verwenden Sie die gcloud-Befehlszeile aus Ihrer Cloud Shell-Sitzung, um einen Cluster mit zwei n1-standard-1-Knoten zu erstellen. Das kann einige Minuten dauern:

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

Am Ende sollten Sie den erstellten Cluster sehen.

Creating cluster hello-cluster in us-central1-c...done.
Created [https://container.googleapis.com/v1/projects/mn-gke-test/zones/us-central1-c/clusters/hello-cluster].
To inspect the contents of your cluster, go to: https://console.cloud.google.com/kubernetes/workload_/gcloud/us-central1-c/hello-cluster?project=mn-gke-test
kubeconfig entry generated for hello-cluster.
NAME           LOCATION       MASTER_VERSION  MASTER_IP       MACHINE_TYPE   NODE_VERSION  NUM_NODES  STATUS
hello-cluster  us-central1-c  1.9.7-gke.7     35.239.224.115  n1-standard-1  1.9.7-gke.7   2          RUNNING

Alternativ können Sie diesen Cluster auch über die oben gezeigte Konsole erstellen: Compute > Kubernetes Engine > Container-Cluster > Container-Cluster erstellen.

Sie können den Cluster zwar auch in einer anderen Zone erstellen, aber es wird empfohlen, ihn in derselben Region zu speichern, in der sich der von der Container-Registry verwendete Storage-Bucket befindet (siehe vorheriger Schritt).

Sie sollten jetzt einen voll funktionsfähigen Kubernetes-Cluster haben, der von Google Kubernetes Engine bereitgestellt wird:

Und nun stellen Sie Ihre eigene 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 dieses 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.

9. Anwendung in Kubernetes bereitstellen

Mit einem Kubernetes-Deployment können mehrere Instanzen Ihrer Anwendung mit dem gerade erstellten Container-Image erstellt, verwaltet und skaliert werden. Erstellen wir nun ein Deployment Ihrer Anwendung in Kubernetes mit dem Befehl kubectl create deployment:

$ kubectl create deployment hello-micronaut \
  --image=gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.1

Führen Sie einfach den folgenden Befehl aus, um sich das gerade erstellte Deployment anzeigen zu lassen:

$ kubectl get deployments
NAME              DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-micronaut   1         1         1            1           5m

Führen Sie den folgenden Befehl aus, um die von der Bereitstellung erstellten Anwendungsinstanzen aufzurufen:

$ kubectl get pods
NAME                               READY     STATUS    RESTARTS   AGE
hello-micronaut-5647fb98c5-lh5h7   1/1       Running   0          5m

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

10. Externen Traffic zulassen

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

Von Cloud Shell aus können Sie den Pod mit dem Befehl kubectl expose und dem Flag --type=LoadBalancer dem öffentlichen Internet zugänglich machen. Dieses Flag wird für die Erstellung einer extern zugänglichen IP benötigt:

$ kubectl expose deployment hello-micronaut --type=LoadBalancer --port=8080

Das in diesem Befehl verwendete Flag gibt an, dass Sie den Load-Balancer nutzen, der von der zugrundeliegenden Infrastruktur bereitgestellt wird. Das ist in diesem Fall der Compute Engine-Load-Balancer. Hinweis: Sie machen das Deployment und nicht den Pod direkt verfügbar. Als Folge führt der resultierende Dienst den Traffic-Lastenausgleich 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 Lastenausgleich und die zugehörigen Compute Engine-Weiterleitungsregeln, Zielpools und Firewallregeln, um den Dienst von außerhalb der Google Cloud Platform vollständig zugänglich zu machen.

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              TYPE           CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
hello-micronaut   LoadBalancer   10.39.243.251   aaa.bbb.ccc.ddd 8080:30354/TCP   1m
kubernetes        ClusterIP      10.39.240.1     <none>          443/TCP          31m

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.

Hinweis: Für den Dienst sind zwei IP-Adressen aufgelistet, die beide Port 8080 bedienen. Eine davon ist die interne IP, die nur in Ihrem virtuellen Cloudnetzwerk sichtbar ist. Die andere ist die externe Load-Balancer-IP. In diesem Beispiel lautet die externe IP-Adresse aaa.bbb.ccc.ddd.

Sie sollten den Dienst jetzt erreichen können. Verweisen Sie dazu Ihren Browser auf diese Adresse: http://<EXTERNAL_IP>:8080/hello

11. Dienst skalieren

Eine der leistungsstarken Funktionen von Kubernetes ist die einfache Skalierbarkeit Ihrer Anwendung. Falls Sie plötzlich mehr Kapazität für Ihre Anwendung benötigen, können Sie den Replikationscontroller anweisen, eine neue Anzahl von Replikaten für Ihre Anwendungsinstanzen zu verwalten:

$ kubectl scale deployment hello-micronaut --replicas=3
deployment.extensions "hello-micronaut" scaled

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

Hier wird ein deklarativer Ansatz verwendet. Anstatt neue Instanzen zu starten oder anzuhalten, bestimmen 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.

12. Upgrade für Ihren Dienst bereitstellen

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

Ändern wir zuerst die Anwendung. Öffnen Sie den Code-Editor über Cloud Shell.

Rufen Sie /jib/examples/micronaut/src/main/groovy/example/micronaut/HelloController.groovy auf und aktualisieren Sie den Wert der Antwort:

@Controller("/hello")
class HelloController {
    @Get("/")
    String index() {
        "Hello Kubernetes World"
    }
}

In /jib/examples/micronaut/build.gradle aktualisieren wir die Version unseres Bildes von 0.1 auf 0.2, indem wir diese Zeile aktualisieren:

version '0.2'

Erstellen Sie die Anwendung dann mit den neuesten Änderungen neu und packen Sie sie:

$ ./gradlew jibDockerBuild

Taggen Sie das Image und übertragen Sie es per Push in die Container-Image-Registry:

$ docker tag micronaut-jib:0.2 \
         gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.2
$ docker push gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.2

Das Erstellen und Hochladen dieses aktualisierten Images sollte dank Caching deutlich schneller gehen.

Sie können nun mit Kubernetes den Replikations-Controller problemlos auf die neue App-Version aktualisieren. Um das Image-Label Ihres Containers zu ändern, müssen Sie das bestehende hello-micronaut deployment bearbeiten und das Image von gcr.io/PROJECT_ID/micronaut-jib:0.1 zu gcr.io/PROJECT_ID/micronaut-jib:0.2 ändern.

Mit dem Befehl kubectl set image können Sie Kubernetes auffordern, die neue Version Ihrer Anwendung mit einem Rolling Update im gesamten Cluster bereitzustellen:

$ kubectl set image deployment/hello-micronaut \
          micronaut-jib=gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.2

deployment.apps "hello-micronaut" image updated

Während dies geschieht, kann es zu Unterbrechungen für die Nutzer der Dienste kommen. Das liegt daran, dass keine Systemdiagnose konfiguriert war. Das ist eine etwas komplexere Konfiguration. In diesem Lab fügen wir keine Systemdiagnose hinzu.

Rufen Sie noch einmal http://EXTERNAL_IP:8080 auf, um zu sehen, dass die neue Antwort zurückgegeben wird.

13. Rollback durchführen

Hoppla – ist Ihnen bei einer neuen Version der Anwendung ein Fehler unterlaufen? Vielleicht enthält die neue Version einen Fehler und Sie müssen schnell ein Rollback durchführen. Mit Kubernetes können Sie ganz einfach zum vorherigen Status zurückkehren. Führen Sie den folgenden Befehl aus, um ein Rollback der Anwendung durchzuführen:

$ kubectl rollout undo deployment/hello-micronaut

Wenn Sie sich die Ausgabe des Dienstes ansehen, sehen Sie wieder die ursprüngliche Nachricht „Hello World“.

14. Zusammenfassung

In diesem Schritt haben Sie einen einfachen Apache Groovy-basierten Micronaut-Hello World-Dienst eingerichtet und direkt in Cloud Shell ausgeführt, ihn mit Jib als Container verpackt und in Google Kubernetes Engine bereitgestellt.

15. Glückwunsch!

Sie haben gelernt, wie Sie einen neuen webbasierten Apache Groovy-/Micronaut-Mikrodienst für Kubernetes in Google Kubernetes Engine erstellen und bereitstellen.

Weitere Informationen

• Jib-Dokumentation und -Beispiele: https://github.com/GoogleContainerTools/jib/
• Micronaut-Website: http://micronaut.io/
• Java in der Google Cloud Platform: https://cloud.google.com/java/
• Java-Beispiele: https://cloud.google.com/java/samples
• Eine längere und vollständigere Anleitung zu Kubernetes finden Sie unter bit.ly/k8s-lab. Dort wird die Bereitstellung einer Full-Stack-Anwendung beschrieben.

Lizenz

Dieser Text ist mit einer Creative Commons Attribution 2.0 Generic License lizenziert.