Vor 25 Jahren trat Java seinen Siegeszug in die Programmiergemeinschaft an und wurde schließlich zu einem der Grundpfeiler, um die Anwendungs-Stacks aufgebaut sind. Heute wenden sich jedoch viele Personen und Organisationen, die Java über Jahre die Treue gehalten haben, der Plattform zu oder ziehen einen Wechsel in Betracht. oder ihren Derivaten wie oder .
Leider bringt Kubernetes eine steile Lernkurve mit sich und fügt dem gewohnten Entwicklungsprozess für Java-Entwickler eine weitere Betriebsebene hinzu. Heute werden wir erläutern, wie man , einsetzen kann, um diese zusätzlichen mit Kubernetes und Containern verbundenen Operationen zu vereinfachen und eine schmerzlose Migration zur Cloud-Plattform zu ermöglichen, während die vertraute Java-Umgebung erhalten bleibt. Darüber hinaus zeigen wir, wie man Java-Anwendungen mit dem OpenShift Maven-Plugin auf der OpenShift-Plattform bereitstellt.
Der traditionelle Java-Entwicklungsprozess
Der traditionelle Entwicklungsprozess (Abb. 1) bedeutet, dass ein Entwickler Code schreibt, dann Bereitstellungseinheiten in Form von JAR- oder WAR-Dateien erstellt und anschließend diese Dateien auf einem Web- oder Anwendungsserver bereitstellt und ausführt. In der Regel wird hierfür Maven über die Befehlszeile verwendet oder es werden IDEs wie IntelliJ oder Eclipse genutzt, um Anwendungen zu kodieren und zu paketieren. Entwickler sind daran gewöhnt, Änderungen im Code vorzunehmen und alles gründlich zu testen, bevor sie den Code festschreiben und in das Versionsverwaltungssystem übermitteln.
Abb. 1. Traditioneller Java-Entwicklungsprozess.
Java-Entwicklungsprozess für die Cloud
Beim Umstieg auf Cloud-Anwendungen werden Kubernetes und . Daher muss der Entwickler jetzt Java-Anwendungen in verpacken und Kubernetes-Manifestdateien erstellen, die diese Images beschreiben. Diese Manifestdateien werden dann auf dem Produktionsserver angewendet, auf dem Kubernetes läuft. Kubernetes zieht diese Images aus dem Repository und stellt die Anwendungen gemäß den Konfigurationen bereit, die wir in den Manifests festgelegt haben, die normalerweise YAML-Dateien sind.
Die Metamorphose des traditionellen Java-Entwicklungsprozesses beim Übergang zur Cloud ist in Abb. 2 dargestellt.
Abb. 2. Der Java-Entwicklungsprozess für die Cloud.
Eclipse JKube
Der Wechsel zu Kubernetes fügt dem Entwicklungsprozess eine weitere Betriebsebene hinzu, was viele Entwickler verunsichert, da sie sich auf ihre Kernaufgaben – die Logik der Anwendungen – konzentrieren möchten und nicht darauf, wie sie bereitgestellt werden. Hier kommt ins Spiel, das es Entwicklern ermöglicht, ihre Bibliotheken und Plugins ( , indem es oder ), um ohne großen Aufwand containerbezogene Operationen und Kubernetes-Aktivitäten durchzuführen, gemäß dem Schema in Abb. 2.
In diesem Artikel zeigen wir, wie der Java-Entwicklungsprozess in einer Kubernetes-Umgebung mithilfe von Eclipse JKube und dem Kubernetes Maven Plugin vereinfacht werden kann.
Der Entwicklungsprozess für die Cloud mit Eclipse JKube
Betrachten wir ein leicht modifiziertes Schema des Java-Entwicklungsprozesses für die Cloud aus Abb. 2, indem wir Eclipse JKube und das Kubernetes Maven Plugin einfügen, wie in Abb. 3 dargestellt.
Abb. 3. Der Java-Entwicklungsprozess für die Cloud mit Eclipse JKube.
Wie wir sehen, werden hier alle Operationen zur Interaktion mit Kubernetes und Containern (in der Abbildung rot hervorgehoben) standardmäßig durch die Goal-Aufgaben von Eclipse JKube ersetzt, die in Tabelle 1 aufgeführt sind.
Tabelle 1. Standardaufgaben von Eclipse JKube.
Ziel
Phase
Beschreibung
PRE_INTEGRATION_TEST
Erstellung von Docker-Images
INSTALLIEREN
Hochladen von Docker-Images in das Repository
PROCESS_RESOURCES
Generierung von K8s-Manifesten
KOMPILIEREN
Anwendung der generierten Manifeste auf K8s
UNDEPLOY
Entfernung von K8s-Ressourcen, die über k8s:apply und k8s:deploy bereitgestellt wurden
Hinweis: Wenn Sie nicht möchten, dass die Aufgaben diese festen Standardwerte (opinionated defaults) verwenden, können Sie Eclipse JKube manuell anpassen, da es die Konfiguration über unterstützt und .
Jetzt betrachten wir Beispiele für die Verwendung von Eclipse JKube und dem Kubernetes Maven Plugin bei der Arbeit mit Anwendungen.
Bereitstellung einer Java-Anwendung in Kubernetes mit Eclipse JKube
In diesem Beispiel werden wir eine einfache Java-Anwendung im Cluster bereitstellen mit Eclipse JKube. Mit dem Kubernetes Maven Plugin können wir Bereitstellungsparameter festlegen, ohne eine spezielle Konfiguration anzugeben.
Als Beispielanwendung verwenden wir , der JSON-Output an der Endpoint /random ausgibt:
~/work/repos/eclipse-jkube-demo-project : $ curl localhost:8080/random | jq .
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 45 0 45 0 0 818 0 --:--:-- --:--:-- --:--:-- 818
{
"id": "e80a4d10-c79b-4b9a-aaac-7c286cb37f3c"
}
Schritt 1. Laden Sie das Kubernetes Maven Plugin herunter
Das Kubernetes Maven Plugin befindet sich im Repository . Um Eclipse JKube zu verwenden, muss das Kubernetes Maven Plugin als Abhängigkeit in die pom.xml eingefügt werden:
org.eclipse.jkube
kubernetes-maven-plugin
${jkube.version}
Falls anstelle von reinem Kubernetes OpenShift verwendet wird, wird die pom.xml wie folgt modifiziert:
org.eclipse.jkube
openshift-maven-plugin
${jkube.version}
Schritt 2. Docker-Image erstellen
Die JAR-Datei der Anwendung kann mit dem Befehl mvn package erstellt werden, anschließend kann das Ziel mvn k8s:build verwendet werden, um das Docker-Image dieser Anwendung zu erstellen. Beachten Sie, dass wir den Standardnamen des Images mit dieser Eigenschaft überschrieben haben:
docker.io/rohankanojia/random-generator:${project.version}
Bevor Sie das Image erstellen, müssen Sie sicherstellen, dass der Docker-Dämon korrekt exponiert ist. Dies kann mit dem folgenden Befehl überprüft werden:
$ eval $(minikube docker-env)
Geben Sie dann den Befehl mvn k8s:build ein, und dies werden Sie auf dem Bildschirm sehen, während das Docker-Image mithilfe der Build-Aufgabe von Eclipse JKube erstellt wird:
~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:build
[INFO] Scanning for projects...
[INFO]
[INFO] ---------------------------------------------
[INFO] Building random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] k8s: Running in Kubernetes mode
[INFO] k8s: Building Docker image in Kubernetes mode
[INFO] k8s: Running generator spring-boot
[INFO] k8s: spring-boot: Using Docker image quay.io/jkube/jkube-java-binary-s2i:0.0.7 as base / builder
[INFO] k8s: [docker.io/rohankanojia/random-generator:0.0.1] "spring-boot": Created docker-build.tar in 251 milliseconds
[INFO] k8s: [docker.io/rohankanojia/random-generator:0.0.1] "spring-boot": Built image sha256:a20e5
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 5.053 s
[INFO] Finished at: 2020-08-10T11:28:23+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $
Schritt 3. Senden Sie das Image an das Docker-Registry
Nachdem wir das Docker-Image mit einem konfigurierten Push-Registry (in unserem Fall docker.io) erstellt haben, können wir dieses Image in die Registry senden. Folgendes wird angezeigt, nachdem wir Eclipse JKube aufgefordert haben, die Push-Aufgabe mvn k8s:push auszuführen:
~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:push
[INFO] Projekte werden gescannt...
[INFO]
[INFO] ---------------------------------------------
[INFO] Erstelle random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:push (default-cli) @ random-generator ---
[INFO] k8s: Betrieb im Kubernetes-Modus
[INFO] k8s: Docker-Image im Kubernetes-Modus erstellen
[INFO] k8s: Generator spring-boot wird ausgeführt
[INFO] k8s: spring-boot: Benutze Docker-Image quay.io/jkube/jkube-java-binary-s2i:0.0.7 als Basis / Builder
[INFO] k8s: Der Push bezieht sich auf das Repository [docker.io/rohankanojia/random-generator]
5dcd9556710f: Layer existiert bereits
b7139ad07aa8: Layer existiert bereits
b6f081e4b2b6: Layer existiert bereits
d8e1f35641ac: Layer existiert bereits
[INFO] k8s: 0.0.1: Digest: sha256:9f9eda2a13b8cab1d2c9e474248500145fc09e2922fe3735692f9bda4c76002d Größe: 1162
[INFO] k8s: docker.io/rohankanojia/random-generator:0.0.1 in 7 Sekunden gepusht
[INFO] ------------------------------------------------------------------------
[INFO] BUILD ERFOLGREICH
[INFO] ------------------------------------------------------------------------
[INFO] Gesamtzeit: 11.222 s
[INFO] Beendet am: 2020-08-10T11:35:37+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $
Nachdem das Image hochgeladen wurde, müssen wir überprüfen, ob es im Repository angekommen ist. In unserem Fall sehen wir es einfach im Docker Hub, wie in Abb. 4 dargestellt.
Abb. 4. Das in das Repository hochgeladene Image erscheint im Docker Hub.
Schritt 4. Erstellen von Manifesten für Kubernetes-Ressourcen für die Anwendung
Das Image der Anwendung haben wir jetzt gebaut, nun müssen wir die Kubernetes-Manifestdateien schreiben. Dazu gibt es in Eclipse JKube eine Aufgabe, die die festen Ressourcen-Manifestdateien basierend auf dem zugrunde liegenden Java-Framework generiert (, , Vert.x oder ein anderes). Außerdem kann das Manifest konfiguriert werden, indem eine XML-Konfigurationsdatei verwendet wird und die Rohfragmente (Fragmente des benötigten Ressourcen-Manifests) in den Ordner der Anwendung src/main/jkube gelegt werden. In diesem Fall wird Ihre Konfiguration in die generierten Manifeste überführt.
In unserem Beispiel lassen wir alles wie es ist, und deshalb generiert Eclipse JKube ein Manifest für das Standard-Deployment und den Dienst vom Typ ClusterIP. Danach modifizieren wir das Dienstmanifest, um den Typ des Dienstes auf NodePort zu ändern. Das Standardverhalten kann mit folgendem Property überschrieben werden:
NodePort
So sieht die Bildschirmausgabe aus, nachdem wir Eclipse JKube gebeten haben, die Resource-Aufgabe mvn k8s:resource auszuführen.
~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:resource
[INFO] Scanning for projects...
[INFO]
[INFO] ---------------------------------------------
[INFO] Erstelle random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:resource (default-cli) @ random-generator ---
[INFO] k8s: Starte Generator spring-boot
[INFO] k8s: spring-boot: Verwende Docker-Image quay.io/jkube/jkube-java-binary-s2i:0.0.7 als Basis / Builder
[INFO] k8s: jkube-controller: Füge ein standardmäßiges Deployment hinzu
[INFO] k8s: jkube-service: Füge einen Standarddienst 'random-generator' mit Ports [8080] hinzu
[INFO] k8s: jkube-healthcheck-spring-boot: Füge eine Readiness-Prüfung am Port 8080, Pfad='/actuator/health', Schema='HTTP', mit einer anfänglichen Verzögerung von 10 Sekunden hinzu
[INFO] k8s: jkube-healthcheck-spring-boot: Füge eine Liveness-Prüfung am Port 8080, Pfad='/actuator/health', Schema='HTTP', mit einer anfänglichen Verzögerung von 180 Sekunden hinzu
[INFO] k8s: jkube-revision-history: Füge ein Limit für die Verlaufshistorie von 2 hinzu
[INFO] ------------------------------------------------------------------------
[INFO] BUILD ERFOLGREICH
[INFO] ------------------------------------------------------------------------
[INFO] Gesamte Zeit: 3.344 s
[INFO] Fertiggestellt um: 2020-08-10T11:38:11+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $ ls target/classes/META-INF/jkube/kubernetes
random-generator-deployment.yml random-generator-service.yml
~/work/repos/eclipse-jkube-demo-project : $ cat target/classes/META-INF/jkube/kubernetes/random-generator-deployment.yml | head -n10
---
apiVersion: apps/v1
kind: Deployment
metadata:
annotations:
jkube.io/git-url: git@github.com:rohanKanojia/eclipse-jkube-demo-project.git
jkube.io/git-commit: 1ef9ef2ef7a6fcbf8eb64c293f26f9c42d026512
jkube.io/git-branch: master
jkube.io/scm-url: https://github.com/spring-projects/spring-boot/spring-boot-starter-parent/random-generator
jkube.io/scm-tag: HEAD
~/work/repos/eclipse-jkube-demo-project : $
Schritt 5. Anwendung im Kubernetes-Cluster bereitstellen
Nun sind wir bereit, die Anwendung bereitzustellen: Wir haben ihr Image erstellt und anschließend die Ressourcen-Manifestdateien automatisch generiert. Jetzt müssen wir dies nur noch auf das Kubernetes-Cluster anwenden. Um die Anwendung bereitstellen, können wir natürlich den Befehl kubectl apply -f verwenden, aber das Plugin kann dies für uns übernehmen. So wird der Bildschirm aussehen, nachdem wir Eclipse JKube darum gebeten haben, die mvn k8s:apply-Aufgabe auszuführen:
~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:apply
[INFO] Suche nach Projekten...
[INFO]
[INFO] ---------------------------------------------
[INFO] Erstelle random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] k8s: Verwendung von Kubernetes unter https://192.168.39.145:8443/ im Namespace default mit Manifest /home/rohaan/work/repos/eclipse-jkube-demo-project/target/classes/META-INF/jkube/kubernetes.yml
[INFO] k8s: Verwendung des Namespace: default
[INFO] k8s: Erstelle einen Service aus kubernetes.yml Namespace default Name random-generator
[INFO] k8s: Dienst erstellt: target/jkube/applyJson/default/service-random-generator.json
[INFO] k8s: Erstelle ein Deployment aus kubernetes.yml Namespace default Name random-generator
[INFO] k8s: Deployment erstellt: target/jkube/applyJson/default/deployment-random-generator.json
[INFO] k8s: HINWEIS: Verwenden Sie den Befehl `kubectl get pods -w`, um Ihre Pods beim Hochfahren zu beobachten
[INFO] ------------------------------------------------------------------------
[INFO] BUILD ERFOLGREICH
[INFO] ------------------------------------------------------------------------
[INFO] Gesamte Zeit: 7.306 s
[INFO] Fertiggestellt um: 2020-08-10T11:40:57+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $ kubectl get pods -w
NAME READY STATUS RESTARTS AGE
random-generator-58b7847d7f-9m9df 0/1 Läuft 0 7s
random-generator-58b7847d7f-9m9df 1/1 Läuft 0 17s
^C~/work/repos/eclipse-jkube-demo-project : $ kubectl get svc
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
io-openliberty-sample-getting-started NodePort 10.110.4.104 9080:30570/TCP 44h
kubernetes ClusterIP 10.96.0.1 443/TCP 18d
random-generator NodePort 10.97.172.147 8080:32186/TCP 22s
~/work/repos/eclipse-jkube-demo-project : $ curl `minikube ip`:32186/random | jq .
% Gesamt % Empfangen % Übertragung Durchschnittliche Geschwindigkeit Zeit Zeit Zeit Aktuell
Dload Upload Gesamt Ausgegeben Verbleibend Geschwindigkeit
100 45 0 45 0 0 1800 0 --:--:-- --:--:-- --:--:-- 1875
{
"id": "42e5571f-a20f-44b3-8184-370356581d10"
}
Schritt 6. Anwendung aus dem Kubernetes-Cluster undeployen
Dazu verwenden wir die undeploy-Aufgabe, die einfach alle Ressourcen entfernt, die im vorherigen Schritt, also bei der Ausführung der apply-Aufgabe, angewendet wurden. Das werden wir auf dem Bildschirm sehen, nachdem wir Eclipse JKube gebeten haben, die undeploy-Aufgabe mvn k8s:undeploy auszuführen:
~/work/repos/eclipse-jkube-demo-projekt : $ kubectl get all
NAME READY STATUS RESTARTS AGE
pod/random-generator-58b7847d7f-9m9df 1/1 Läuft 0 5m21s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/kubernetes ClusterIP 10.96.0.1 443/TCP 18d
service/random-generator NodePort 10.97.172.147 8080:32186/TCP 5m21s
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/random-generator 1/1 1 1 5m21s
NAME DESIRED CURRENT READY AGE
replicaset.apps/random-generator-58b7847d7f 1 1 1 5m21s
~/work/repos/eclipse-jkube-demo-projekt : $ mvn k8s:undeploy
[INFO] Scannen nach Projekten...
[INFO]
[INFO] ---------------------------------------------
[INFO] Baue random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:undeploy (default-cli) @ random-generator ---
[INFO] k8s: Verwende Kubernetes unter https://192.168.39.145:8443/ im Namespace standard mit Manifest /home/rohaan/work/repos/eclipse-jkube-demo-projekt/target/classes/META-INF/jkube/kubernetes.yml
[INFO] k8s: Verwende Namespace: standard
[INFO] k8s: Lösche Ressource Deployment standard/random-generator
[INFO] k8s: Lösche Ressource Service standard/random-generator
[INFO] k8s: HINWEIS: Verwende den Befehl `kubectl get pods -w`, um den Start deiner Pods zu verfolgen
[INFO] ------------------------------------------------------------------------
[INFO] BUILD ERFOLGREICH
[INFO] ------------------------------------------------------------------------
[INFO] Gesamtzeit: 3.412 s
[INFO] Beendet um: 2020-08-10T11:46:22+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-projekt : $ kubectl get pods -w
^C~/work/repos/eclipse-jkube-demo-projekt : $ kubectl get all
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/kubernetes ClusterIP 10.96.0.1 443/TCP 18d
~/work/repos/eclipse-jkube-demo-projekt : $
Was kann man noch mit Eclipse JKube machen?
Wir haben die grundlegenden Ziele von Eclipse JKube und dem Kubernetes Maven Plugin untersucht, die die Entwicklung von Java-Anwendungen für die Kubernetes-Plattform erleichtern. Wenn Sie nicht ständig diese Aufgaben manuell eingeben möchten, können Sie sie in der Plugin-Konfiguration festlegen, zum Beispiel so:
org.eclipse.jkube
kubernetes-maven-plugin
${project.version}
build
resource
apply
Es sollte erwähnt werden, dass wir in diesem Artikel bei weitem nicht alle Aufgaben behandelt haben, die in Eclipse JKube und dem Kubernetes Maven Plugin vorhanden sind. Daher finden Sie in Tabelle 2 eine Liste zusätzlicher Aufgaben, die ebenfalls nützlich sein können.
Tabelle 2. Zusätzliche Aufgaben von Eclipse JKube.
Ziel
Phase
Beschreibung
VALIDIEREN
Abrufen von Logs von einer auf Kubernetes betriebenen Anwendung.
PAKETIEREN
Öffnen eines Debugging-Ports zur Ausführung der Fehlersuche für eine auf Kubernetes betriebene Anwendung direkt aus der IDE.
INSTALLIEREN
Das Erstellen eines Forks für die Installationsaufgabe und die Anwendung der generierten Manifeste auf einem Kubernetes-Cluster erfolgt genau wie bei der Apply-Aufgabe.
PAKETIEREN
Automatisiertes Hot-Deployment der Anwendung durch die Überwachung ihres Namensraums.
Bereitstellung von Java-Anwendungen auf Red Hat OpenShift mit dem OpenShift Maven Plugin
Um die Anwendung aus unserem Beispiel auf der Red Hat OpenShift-Plattform bereitzustellen, verwenden wir das Plugin . Der einzige Unterschied besteht darin, dass das Aufgabenpräfix von k8s auf oc geändert wird. Standardmäßig führt das Kubernetes Maven Plugin -Bauten durch, während das OpenShift Maven Plugin -Bauten . Wir nehmen keine Änderungen an unserem Projekt vor, außer das Entfernen der Eigenschaft jkube.generator.name, da sie beim Pushen in das Registry nicht benötigt wird (in der Build-Phase platziert OpenShift das Image in seiner internen Registry). Und das wird auf dem Bildschirm angezeigt, wenn wir unser Beispiel ausführen, in dem wir übrigens die Aufgaben nicht einzeln, sondern alle auf einmal ausführen:
~/work/repos/eclipse-jkube-demo-projekt : $ mvn oc:build oc:resource oc:apply
[INFO] Scannt nach Projekten...
[INFO]
[INFO] ---------------------------------------------
[INFO] Erstelle random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] oc: Verwende OpenShift-Build mit Strategie S2I
[INFO] oc: Läuft im OpenShift-Modus
[INFO] oc: Generiere Spring-Boot-Anwendung
[INFO] oc: spring-boot: Verwende Docker-Image quay.io/jkube/jkube-java-binary-s2i:0.0.7 als Basis / Builder
[INFO] oc: [random-generator:0.0.1] "spring-boot": Erstellt Docker-Quell-Tar /home/rohaan/work/repos/eclipse-jkube-demo-projekt/target/docker/random-generator/0.0.1/tmp/docker-build.tar
[INFO] oc: Hinzufügen zu Secret pullsecret-jkube
[INFO] oc: Verwende Secret pullsecret-jkube
[INFO] oc: Erstelle BuildServiceConfig random-generator-s2i für Quell-Build
[INFO] oc: Erstelle ImageStream random-generator
[INFO] oc: Starte Build random-generator-s2i
[INFO] oc: Warte auf den Abschluss des Builds random-generator-s2i-1...
[INFO] oc: Caching Blobs unter "/var/cache/blobs".
[INFO] oc: Hole Bildquellen-Signaturen
[INFO] oc: Kopiere Blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Kopiere Blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Kopiere Blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Kopiere Konfiguration sha256:52d6788fcfdd39595264d34a3959464a5dabc1d4ef0ae188802b20fc2d6a857b
[INFO] oc: Schreibe Manifest an Bildziel
[INFO] oc: Speichere Signaturen
[INFO] oc: Generiere Dockerfile mit Builder-Image quay.io/jkube/jkube-java-binary-s2i:0.0.7
[INFO] oc: SCHRITT 1: VON quay.io/jkube/jkube-java-binary-s2i:0.0.7
[INFO] oc: SCHRITT 2: LABEL "io.openshift.build.source-location"="/tmp/build/inputs" "io.openshift.build.image"="quay.io/jkube/jkube-java-binary-s2i:0.0.7"
[INFO] oc: SCHRITT 3: ENV JAVA_APP_DIR="/deployments" OPENSHIFT_BUILD_NAME="random-generator-s2i-1" OPENSHIFT_BUILD_NAMESPACE="default"
[INFO] oc: SCHRITT 4: BENUTZER root
[INFO] oc: SCHRITT 5: KOPIEREN upload/src /tmp/src
[INFO] oc: SCHRITT 6: FÜHREN chown -R 1000:0 /tmp/src AUS
[INFO] oc: SCHRITT 7: BENUTZER 1000
[INFO] oc: SCHRITT 8: FÜHREN /usr/local/s2i/assemble AUS
[INFO] oc: INFO S2I-Quell-Build mit einfachen Binärdateien erkannt
[INFO] oc: INFO S2I-Binär-Build vom fabric8-maven-plugin erkannt
[INFO] oc: INFO Kopiere Binärdateien von /tmp/src/deployments nach /deployments ...
[INFO] oc: random-generator-0.0.1.jar
[INFO] oc: INFO Kopiere Deployments von deployments nach /deployments...
[INFO] oc: '/tmp/src/deployments/random-generator-0.0.1.jar' -> '/deployments/random-generator-0.0.1.jar'
[INFO] oc: SCHRITT 9: CMD /usr/local/s2i/run
[INFO] oc: SCHRITT 10: COMMIT temp.builder.openshift.io/default/random-generator-s2i-1:48795e41
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Image-Betriebssystem-Mismatch: Bild verwendet "", erwartet "linux""
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Image-Architektur-Mismatch: Bild verwendet "", erwartet "amd64""
[INFO] oc: Hole Bildquellen-Signaturen
[INFO] oc: Kopiere Blob sha256:d8e1f35641acb80b562f70cf49911341dfbe8c86f4d522b18efbf3732aa74223
[INFO] oc: Kopiere Blob sha256:b6f081e4b2b6de8be4b1dec132043d14c121e968384dd624fb69c2c07b482edb
[INFO] oc: Kopiere Blob sha256:b7139ad07aa8ce4ed5a132f7c5cc9f1de0f5099b5e155027a23d57f7fbe78b16
[INFO] oc: Kopiere Blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Kopiere Konfiguration sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Schreibe Manifest an Bildziel
[INFO] oc: Speichere Signaturen
[INFO] oc: --> 27aaadaf28e
[INFO] oc: 27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Hole Bildquellen-Signaturen
[INFO] oc:
[INFO] oc: Pushe Bild image-registry.openshift-image-registry.svc:5000/default/random-generator:0.0.1 ...
[INFO] oc: Kopiere Blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Kopiere Blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Kopiere Blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Kopiere Blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Kopiere Konfiguration sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Schreibe Manifest an Bildziel
[INFO] oc: Speichere Signaturen
[INFO] oc: Erfolgreich Bild image-registry.openshift-image-registry.svc:5000/default/random-generator@sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d gepusht
[INFO] oc: Push erfolgreich
[INFO] oc: Build random-generator-s2i-1 im Status Vollständig
[INFO] oc: Tag auf ImageStream random-generator gefunden: sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: ImageStream random-generator in /home/rohaan/work/repos/eclipse-jkube-demo-projekt/target/random-generator-is.yml geschrieben
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:resource (default-cli) @ random-generator ---
[INFO] oc: Verwende Docker-Image-Namen des Namespace: default
[INFO] oc: Generiere Spring-Boot-Anwendung
[INFO] oc: spring-boot: Verwende Docker-Image quay.io/jkube/jkube-java-binary-s2i:0.0.7 als Basis / Builder
[INFO] oc: jkube-controller: Füge eine Standard-DeploymentConfig hinzu
[INFO] oc: jkube-service: Füge einen Standarddienst 'random-generator' mit Ports [8080] hinzu
[INFO] oc: jkube-healthcheck-spring-boot: Füge Bereitstellungsprüfung am Port 8080, Pfad='/actuator/health', Schema='HTTP', mit einer anfänglichen Verzögerung von 10 Sekunden hinzu
[INFO] oc: jkube-healthcheck-spring-boot: Füge Lebensdauerprüfung am Port 8080, Pfad='/actuator/health', Schema='HTTP', mit einer anfänglichen Verzögerung von 180 Sekunden hinzu
[INFO] oc: jkube-revision-history: Füge eine Revisionverlaufsgrenze von 2 hinzu
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] oc: Verwende OpenShift unter https://api.crc.testing:6443/ im Namespace default mit Manifest /home/rohaan/work/repos/eclipse-jkube-demo-projekt/target/classes/META-INF/jkube/openshift.yml
[INFO] oc: OpenShift-Plattform erkannt
[INFO] oc: Verwende Projekt: default
[INFO] oc: Erstelle einen Dienst aus openshift.yml Namespace default Name random-generator
[INFO] oc: Dienst erstellt: target/jkube/applyJson/default/service-random-generator.json
[INFO] oc: Erstelle eine DeploymentConfig aus openshift.yml Namespace default Name random-generator
[INFO] oc: DeploymentConfig erstellt: target/jkube/applyJson/default/deploymentconfig-random-generator.json
[INFO] oc: Erstelle Route default:random-generator Host: null
[INFO] oc: HINWEIS: Verwenden Sie den Befehl `oc get pods -w`, um Ihre Pods zu beobachten
[INFO] ------------------------------------------------------------------------
[INFO] BUILD ERFOLGREICH
[INFO] ------------------------------------------------------------------------
[INFO] Gesamte Zeit: 01:07 min
[INFO] Fertiggestellt um: 2020-08-10T12:08:00+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-projekt : $ oc get pods -w
NAME READY STATUS RESTARTS AGE
random-generator-1-deploy 1/1 Laufend 0 14s
random-generator-1-vnrm9 0/1 Laufend 0 11s
random-generator-s2i-1-build 0/1 Abgeschlossen 0 1m
random-generator-1-vnrm9 1/1 Laufend 0 24s
random-generator-1-deploy 0/1 Abgeschlossen 0 28s
~/work/repos/eclipse-jkube-demo-projekt : $ oc get routes
NAME HOST/PORT PATH SERVICES PORT TERMINIERUNG WILDCARD
random-generator random-generator-default.apps-crc.testing random-generator 8080 Keine
~/work/repos/eclipse-jkube-demo-projekt : $ curl random-generator-default.apps-crc.testing/random
% Gesamt % Empfangene % Übertragen Durchschnittsgeschwindigkeit Zeit Zeit Zeit Aktuell
Dload Upload Gesamt Ausgegeben Übrig Geschwindigkeit
100 45 0 45 0 0 1666 0 --:--:-- --:--:-- --:--:-- 1730
{
"id": "d80052d9-2f92-43cb-b9eb-d7cffb879798"
}
~/work/repos/eclipse-jkube-demo-projekt : $
Video-Tutorial
Um mehr darüber zu erfahren, wie Sie die Kubernetes-Entwicklung mit Eclipse JKube vereinfachen können, schauen Sie sich das Video-Tutorial zur schnellen Bereitstellung einer einfachen Spring Boot-Anwendung auf Minikube an:
Fazit
In diesem Artikel haben wir gezeigt, wie Eclipse JKube das Leben eines Java-Entwicklers bei der Arbeit mit Kubernetes erleichtert. Weitere Informationen zu Eclipse JKube finden Sie unter und auf der .
Quelle: habr.com
