1. Übersicht
Über Micronaut
Micronaut ist ein modernes, JVM-basiertes Full-Stack-Framework zum Erstellen modularer, leicht testbarer Mikrodienste und serverloser Anwendungen. Micronaut hat sich zum Ziel gesetzt, eine hervorragende Startzeit und einen schnellen Durchsatz bei minimalem Arbeitsspeicherbedarf zu bieten. Entwickler können Anwendungen mit Micronaut in Java, Groovy oder Kotlin entwickeln.
Micronaut bietet:
- Schnelle Startzeit und Geringer Arbeitsspeicherverbrauch: Reflexionsbasierte IoC-Frameworks laden und speichern Reflexionsdaten für jedes Feld, jede Methode und jeden Konstruktor in Ihrem Code und speichern sie im Cache. Bei Micronaut hingegen sind die Startzeit Ihrer Anwendung und der Arbeitsspeicherverbrauch nicht an die Größe Ihrer Codebasis gebunden.
- Deklarativer, reaktiver HTTP-Client mit Kompilierungszeit: Erstellen Sie deklarativ reaktive HTTP-Clients, die bei der Kompilierung implementiert werden, wodurch der Arbeitsspeicherverbrauch reduziert wird.
- Nicht blockierender HTTP-Server auf Basis von Netty – Dank der reibungslosen Lernkurve des HTTP-Servers von Micronaut ist es so einfach wie möglich, APIs bereitzustellen, die von HTTP-Clients genutzt werden können.
- Schnelle und einfache Tests – Sie können ganz einfach Server und Clients in Ihren Einheitentests einrichten und sofort ausführen.
- Effiziente Injektion bei der Kompilierungszeit und AOP – Micronaut bietet eine einfache, aspektorientierte Programmier-API zur Kompilierungszeit, die keine Reflexion verwendet.
- Vollständig reaktive und nicht blockierende Apps erstellen: Micronaut unterstützt jedes Framework, das reaktive Streams implementiert, 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, der auf Kubernetes Engine ausgeführt wird.
In diesem Codelab erfahren Sie, wie Sie Ihren Mikrodienst als replizierten Dienst auf Kubernetes ausführen. Sie verwenden Code, den Sie auf Ihrem Computer entwickelt haben, wandeln ihn in ein Docker-Container-Image um und führen dieses Image dann in Kubernetes Engine aus.
Im Folgenden finden Sie ein Diagramm der verschiedenen Teile in diesem Codelab, damit Sie besser verstehen, wie die einzelnen Teile zusammenpassen. Verwenden Sie es als Referenz, während Sie das Codelab durcharbeiten. Am Ende sollte alles einen Sinn ergeben (aber fürs Erste können Sie dies ignorieren).
In diesem Codelab können Sie sich mit einer verwalteten Umgebung wie Kubernetes Engine (einer von Google gehosteten Version von Kubernetes, die auf Compute Engine ausgeführt wird) mehr auf die Arbeit mit Kubernetes konzentrieren, anstatt die zugrunde liegende Infrastruktur einzurichten.
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 dieses Codelab mit Minikube durchgehen.
Über Jib
Jib ist ein Open-Source-Tool, mit dem Sie Docker- und OCI-Images für Ihre Java-Anwendungen erstellen können. Sie ist als Plug-ins für Maven und Gradle sowie als Java-Bibliothek verfügbar.
Jib möchte:
- Schnell: Sie können Änderungen schnell bereitstellen. Jib trennt Ihre Anwendung in mehrere Schichten und teilt Abhängigkeiten von Klassen auf. Sie müssen jetzt nicht mehr darauf warten, dass Docker Ihre gesamte Java-Anwendung neu erstellt hat – stellen Sie einfach die geänderten Schichten bereit.
- Reproduzierbar: Wenn Sie ein Container-Image mit demselben Inhalt neu erstellen, wird immer dasselbe Image generiert. Lösen Sie nie wieder ein unnötiges Update aus.
- Daemonless: Reduzieren Sie die Befehlszeilenabhängigkeiten. Erstellen Sie das Docker-Image in Maven oder Gradle und übertragen Sie es per Push in eine Registry Ihrer Wahl. Es ist nicht mehr notwendig, Dockerfiles zu schreiben und Docker build/push aufzurufen.
Weitere Informationen zu Jib finden Sie auf der GitHub-Projektseite.
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
- Einfache Java-Anwendung mit Jib als Docker-Container verpacken
- So erstellen Sie einen Kubernetes-Cluster in Kubernetes Engine.
- Micronaut-Dienst in Kubernetes in Kubernetes Engine bereitstellen
- Den Dienst skalieren und ein Upgrade bereitstellen
- So greifen Sie auf das Kubernetes Graphical-Dashboard zu.
Voraussetzungen
- Google Cloud Platform-Projekt
- Browser, z. B. Chrome oder Firefox
- Erfahrung mit standardmäßigen Linux-Texteditoren wie Vim, EMACs oder Nano
Wie möchten Sie diese Anleitung nutzen?
<ph type="x-smartling-placeholder">Wie würden Sie Ihre Erfahrung mit der Erstellung von HTML/CSS-Web-Apps bewerten?
<ph type="x-smartling-placeholder">Wie würden Sie Ihre Erfahrungen im Umgang mit Google Cloud Platform-Diensten bewerten?
<ph type="x-smartling-placeholder">2. Einrichtung und Anforderungen
Umgebung für das selbstbestimmte Lernen einrichten
- 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 ein Konto erstellen.
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.
- Als Nächstes müssen Sie in der Cloud Console die Abrechnung aktivieren, um Google Cloud-Ressourcen nutzen zu können.
Dieses Codelab sollte möglichst wenig kosten. Folgen Sie der Anleitung im Abschnitt „Bereinigen“, . Hier erfahren Sie, wie Sie Ressourcen herunterfahren, damit Ihnen über dieses Tutorial hinaus keine Kosten entstehen. Neue Google Cloud-Nutzer können an einem kostenlosen Testzeitraum mit 300$Guthaben teilnehmen.
3. Micronaut-Beispielquellcode abrufen
Nach dem Start von Cloud Shell können Sie mit der Befehlszeile den Beispielquellcode in das Basisverzeichnis klonen und mit „cd“ in das Verzeichnis einfügen, das unseren Beispieldienst enthält:
$ git clone https://github.com/GoogleContainerTools/jib.git
$ cd jib/examples/micronaut/
4. Ein kurzer Blick auf den Code
Unser einfacher Mikronaut-Dienst besteht aus einem Controller, der die berüchtigte Hello World-Nachricht ausgibt:
@Controller("/hello")
class HelloController {
@Get("/")
String index() {
"Hello World"
}
}
Der HelloController-Controller antwortet auf Anfragen unter dem Pfad /hello und die Methode index() akzeptiert die HTTP GET-Anfragen.
Mithilfe der Spock lässt sich außerdem prüfen, ob die richtige Nachricht ausgegeben 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 führt nicht nur einen einfachen Einheitentest, sondern auch denselben Micronaut-Serverstack aus (basierend auf dem Netty-Framework), der auch in der Produktion ausgeführt wird. Ihr Code verhält sich also im Produkt genauso wie in Ihren Tests.
Um die Tests auszuführen, können Sie den folgenden Befehl ausführen, um zu prüfen, ob alles in Ordnung ist:
./gradlew test
5. Anwendung lokal ausführen
Sie können den Micronaut-Dienst ganz normal mit dem folgenden Gradle-Befehl starten:
$ ./gradlew run
Nachdem die Anwendung gestartet wurde, können Sie über das kleine Pluszeichen eine weitere Cloud Shell-Instanz öffnen und mit curl prüfen, ob Sie die erwartete Ausgabe erhalten:
$ curl localhost:8080/hello
Nun sollte eine einfache "Hallo Welt"- angezeigt.
6. Anwendung als Docker-Container mit Jib verpacken
Als Nächstes bereiten Sie die App darauf vor, auf Kubernetes ausgeführt zu werden. Dafür nutzen wir Jib, um die harte Arbeit für uns zu erledigen, da wir Dockerfile nicht selbst bearbeiten müssen.
Führen Sie den folgenden Befehl aus, um den Container zu erstellen:
$ ./gradlew jibDockerBuild
Hier ist die Ausgabe, die Sie sehen sollten:
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
Nachdem das Image erstellt wurde, prüfen wir, ob die Willkommensnachricht angezeigt wird. Führen Sie dazu unser Docker-Image im 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
Da unser Dienst ausgeführt wird, können wir nun den curl-Befehl in unserem zweiten Cloud Shell-Tab starten, um zu sehen, 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. Containerdienst in die Registry übertragen
Wenn das Image nun wie vorgesehen funktioniert, können Sie es in die Google Container Registry übertragen. Dies 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 Sie Daten in die Registry hochladen können, sollten Sie überprüfen, ob Container Registry für Ihr Projekt aktiviert ist. Rufen Sie dazu Tools > Container Registry Wenn sie nicht aktiviert ist, sollte das folgende Dialogfeld angezeigt werden. Klicken Sie darin auf Container Registry API aktivieren. um sie zu aktivieren:
Sobald die Registry bereit ist, führen Sie die folgenden Befehle aus, um das Image in die Registry hochzuladen:
$ 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 obigen Befehlen kann das gcloud SDK Docker konfigurieren und autorisieren, Images per Push-Befehl an Ihre Container Registry-Instanz zu übertragen, das Image so zu taggen, dass es auf seinen Speicherort in der Registry verweist, und es dann per Push in die Registry zu übertragen.
Wenn alles in Ordnung ist, sollte das Container-Image nach kurzer Zeit in der Konsole angezeigt werden: Tools > Container Registry 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.
8. Cluster erstellen
Sie können jetzt Ihren Kubernetes Engine-Cluster erstellen. Gehen Sie vorher in der Webkonsole zum Abschnitt „Google Kubernetes Engine“ 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. Erstellen Sie nun mit der gcloud-Befehlszeile aus Ihrer Cloud Shell-Sitzung einen Cluster mit zwei n1-standard-1-Knoten. 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
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 kubectl-Befehlszeile, die bereits in Ihrer Cloud Shell-Umgebung eingerichtet ist. Für den Rest dieses Codelabs müssen sowohl der Kubernetes-Client als auch die Serverversion 1.2 oder höher sein. kubectl version zeigt Ihnen die aktuelle Version des Befehls an.
9. Anwendung in Kubernetes bereitstellen
Mit einem Kubernetes-Deployment können Sie mithilfe des gerade erstellten Container-Images mehrere Instanzen Ihrer Anwendung erstellen, verwalten und skalieren. Lassen Sie uns mit dem Befehl kubectl create deployment ein Deployment Ihrer Anwendung in Kubernetes erstellen:
$ kubectl create deployment hello-micronaut \ --image=gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.1
Führen Sie einfach den folgenden Befehl aus, um die soeben erstellte Bereitstellung anzuzeigen:
$ 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
Zu diesem Zeitpunkt sollte Ihr Container unter der Kontrolle von Kubernetes ausgeführt werden, Sie müssen ihn aber noch für die Außenwelt 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 ist, muss der Pod als Kubernetes-Dienst verfügbar gemacht werden.
Über Cloud Shell können Sie den Pod mit dem Befehl kubectl expose und dem Flag --type=LoadBalancer für das öffentliche Internet freigeben. 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 das Lastenausgleichsmodul verwenden, das von der zugrunde liegenden Infrastruktur bereitgestellt wird (in diesem Fall das Lastenausgleichsmodul von Compute Engine). 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.
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 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
Beachten Sie, dass für Ihren Dienst zwei IP-Adressen aufgeführt sind, 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, indem Sie Ihren Browser auf diese Adresse verweisen: http://<EXTERNAL_IP>:8080/hello
11. Dienst skalieren
Eine der leistungsstarken Funktionen von Kubernetes ist die einfache Skalierbarkeit Ihrer Anwendung. Angenommen, Sie benötigen plötzlich mehr Kapazität für Ihre Anwendung. können Sie den Replikations-Controller einfach 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
Beachten Sie hier den deklarativen Ansatz. Anstatt neue Instanzen zu starten oder zu beenden, geben Sie an, wie viele Instanzen gleichzeitig ausgeführt werden sollen. Die Abgleichsschleifen von Kubernetes sorgen einfach dafür, dass die Realität Ihren Anforderungen entspricht, und ergreifen bei Bedarf Maßnahmen.
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 von 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 Image-Version von 0.1 auf 0.2, indem wir diese Zeile aktualisieren:
version '0.2'
Erstellen Sie dann die Anwendung neu und verpacken Sie sie mit den neuesten Änderungen:
$ ./gradlew jibDockerBuild
Fügen Sie das Image mit Tags hinzu und übertragen Sie es 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
Sie können nun mit Kubernetes den Replikations-Controller problemlos auf die neue App-Version aktualisieren. Wenn Sie das Image-Label für Ihren laufenden Container ändern möchten, müssen Sie das vorhandene hello-micronaut deployment bearbeiten und das Image von gcr.io/PROJECT_ID/micronaut-jib:0.1 in gcr.io/PROJECT_ID/micronaut-jib:0.2 ändern.
Mit dem Befehl kubectl set image können Sie Kubernetes anweisen, die neue Version Ihrer Anwendung instanzisch im gesamten Cluster mit Rolling Update bereitzustellen:
$ kubectl set image deployment/hello-micronaut \
micronaut-jib=gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.2
deployment.apps "hello-micronaut" image updated
Prüfen Sie http://EXTERNAL_IP:8080 noch einmal, um festzustellen, ob die neue Antwort zurückgegeben wird.
13. Rollback durchführen
Hoppla! Ist Ihnen bei der neuen Version der Anwendung ein Fehler unterlaufen? Möglicherweise ist in der neuen Version ein Fehler aufgetreten und Sie müssen schnell ein Rollback durchführen. Mit Kubernetes können Sie ganz einfach ein Rollback zum vorherigen Status durchführen. Lassen Sie uns mit dem folgenden Befehl ein Rollback der Anwendung durchführen:
$ kubectl rollout undo deployment/hello-micronaut
Wenn Sie sich die Ausgabe des Dienstes ansehen, sind wir wieder zu unserem ursprünglichen "Hello World"- angezeigt.
14. Zusammenfassung
In diesem Schritt haben Sie einen einfachen Apache Groovy-basierten Micronaut-Hello World-Dienst von Micronaut direkt in Cloud Shell eingerichtet, als Container mit Jib verpackt und in Google Kubernetes Engine bereitgestellt.
15. Glückwunsch!
Sie haben gelernt, wie Sie in Google Kubernetes Engine einen neuen webbasierten Mikrodienst Apache Groovy / Micronaut in Kubernetes erstellen und bereitstellen.
Weitere Informationen
- Jib-Dokumentation und Beispiele: https://github.com/GoogleContainerTools/jib/
- Micronaut-Website: http://micronaut.io/
- Java auf der Google Cloud Platform: https://cloud.google.com/java/
- Für Java-Beispiele: https://cloud.google.com/java/samples
- Ein ausführlicheres Kubernetes-Tutorial finden Sie unter bit.ly/k8s-lab. Dort werden Sie durch die Bereitstellung einer Full-Stack-Anwendung geführt.
Lizenz
Dieser Text ist mit einer Creative Commons Attribution 2.0 Generic License lizenziert.