Vor 25 Jahren begann Java, sich in die breiten Programmierermassen zu integrieren, um letztendlich zu einem der Pfeiler zu werden, um die herum Anwendungsstacks aufgebaut werden. Heute sind jedoch viele Menschen und Organisationen, die über viele Jahre hinweg Java treu geblieben sind, damit beschäftigt, zu einer Plattform zu wechseln oder darüber nachzudenken. oder deren Abkömmlingen, wie oder .
Leider ist Kubernetes mit einer steilen Lernkurve verbunden und fügt eine weitere Betriebsebene in den gewohnten Entwicklungsprozess für Java-Programmierer ein. Heute werden wir erklären, wie man verwendet, um diese zusätzlichen Operationen im Zusammenhang mit Kubernetes und Containern zu vereinfachen und einen schmerzlosen Übergang auf eine Cloud-Plattform unter Beibehaltung des gewohnten Java-Ökosystems zu gewährleisten. Darüber hinaus zeigen wir, wie man Java-Anwendungen auf der OpenShift-Plattform mit dem OpenShift Maven-Plugin bereitstellt.
Der traditionelle Java-Entwicklungsprozess
Der traditionelle Entwicklungsprozess (Abb. 1) sieht vor, dass der Entwickler Code schreibt, anschließend Bereitstellungseinheiten in Form von JAR- oder WAR-Dateien erstellt und diese Dateien dann auf einem Webserver oder Anwendungsserver bereitstellt und ausführt. Hierfür wird hauptsächlich Maven über die Kommandozeile oder IDEs wie IntelliJ oder Eclipse verwendet, um Anwendungen zu codieren und zu verpacken. Entwickler sind es gewohnt, Änderungen am Code vorzunehmen und alles sorgfältig zu testen, bevor sie den Code festschreiben und in ein Versionskontrollsystem einpflegen.
Abb. 1. Traditioneller Java-Entwicklungsprozess.
Der Java-Entwicklungsprozess für die Cloud
Beim Übergang zu Cloud-Anwendungen wird das oben beschriebene Schema um Kubernetes und erweitert. Daher muss der Entwickler jetzt Java-Anwendungen in verpacken und Kubernetes-Manifeste erstellen, die diese Images beschreiben. Anschließend werden diese Manifeste auf dem Produktionsserver, auf dem Kubernetes läuft, angewendet. Kubernetes zieht dann diese Images aus dem Repository und stellt die Anwendungen gemäß den in den Manifesten festgelegten Konfigurationen bereit, die normalerweise in YAML-Dateien vorliegen.
Die Metamorphose des traditionellen Java-Entwicklungsprozesses beim Übergang zur Cloud ist in Abbildung 2 dargestellt.
Abb. 2. Der Java-Entwicklungsprozess für die Cloud.
Eclipse JKube
Der Übergang zu Kubernetes fügt einen weiteren operationellen Layer im Entwicklungsprozess hinzu, was viele Entwickler nervös macht, da sie sich auf ihre Kernaufgaben – die Anwendungslogik – konzentrieren möchten und nicht darauf, wie diese bereitgestellt werden. Und hier kommt ins Spiel, was Entwicklern ermöglicht, ihre Bibliotheken und Plugins ( zusammen mit oder ), um Container- und Kubernetes-bezogene Operationen mühelos durchzuführen, gemäß dem Schema in Abb. 2.
Im restlichen Teil dieses Artikels zeigen wir, wie der Java-Entwicklungsprozess in einer Kubernetes-Umgebung vereinfacht werden kann, indem wir Eclipse JKube mit dem Kubernetes Maven Plugin verwenden.
Entwicklungsprozess für die Cloud mit Eclipse JKube
Betrachten wir ein leicht modifiziertes Schema der Java-Entwicklung für die Cloud mit Abb. 2, wobei wir Eclipse JKube und das Kubernetes Maven Plugin integrieren, wie in Abb. 3 dargestellt.
Abb. 3. Java-Entwicklungsprozess für die Cloud mit Eclipse JKube.
Wie wir sehen, werden hier alle Interaktionen mit Kubernetes und Containern (in der Grafik rot hervorgehoben) durch die Standard-Goals von Eclipse JKube ersetzt, die in Tab. 1 aufgelistet sind.
Tab. 1. Standardaufgaben von Eclipse JKube.
Aufgabe
Die Phase
Beschreibung
PRE_INTEGRATION_TEST
Bau von Docker-Images
INSTALL
Hochladen der Docker-Images in das Repository
PROCESS_RESOURCES
Generierung von K8s-Manifeste
COMPILE
Anwendung der generierten Manifeste auf K8s
UNDEPLOY
Entfernung der K8s-Ressourcen, die über k8s:apply und k8s:deploy bereitgestellt wurden
Hinweis: Wenn Sie nicht möchten, dass die Aufgaben diese festen Vorgaben (meinungsbasierte Standardwerte) verwenden, können Sie Eclipse JKube manuell auf Ihre Bedürfnisse anpassen, da es die Konfiguration über 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 in einem Cluster bereitstellen mithilfe von Eclipse JKube. Mit dem Kubernetes Maven Plugin können wir Bereitstellungsparameter angeben, ohne eine Konfiguration festzulegen.
Als Beispielanwendung verwenden wir , der JSON-Ausgaben an dem Endpunkt /random ausgibt:
~\/work\/repos\/eclipse-jkube-demo-project : $ curl localhost:8080\/random | jq .\n % Total % Received % Xferd Average Speed Time Time Time Current\n Dload Upload Total Spent Left Speed\n100 45 0 45 0 0 818 0 --:--:-- --:--:-- --:--:-- 818\n{\n \
Schritt 1. Laden Sie das Kubernetes Maven Plugin hoch
Das Kubernetes Maven Plugin befindet sich im Repository . Um Eclipse JKube zu verwenden, muss das Kubernetes Maven Plugin in die pom.xml als Abhängigkeit hinzugefügt werden:
org.eclipse.jkube
kubernetes-maven-plugin
${jkube.version}
Wenn anstelle von reinem Kubernetes OpenShift verwendet wird, wird die pom.xml wie folgt modifiziert:
org.eclipse.jkube
openshift-maven-plugin
${jkube.version}
Schritt 2. Erstellen Sie das Docker-Image
Die JAR-Datei der Anwendung kann mit dem Befehl mvn package erstellt werden, und dann kann das Ziel mvn k8s:build verwendet werden, um das Docker-Image dieser Anwendung zu erstellen. Bitte beachten Sie, dass wir den Standard-Image-Namen mit dieser Eigenschaft überschrieben haben:
docker.io/rohankanojia/random-generator:${project.version}
Bevor Sie das Image erstellen, sollten Sie sicherstellen, dass der Docker-Daemon korrekt exponiert ist. Dies kann mit folgendem Befehl erfolgen:
$ eval $(minikube docker-env)
Geben Sie dann den Befehl mvn k8s:build ein, und das sehen wir auf dem Bildschirm, wenn das Docker-Image mit dem Build-Ziel von Eclipse JKube erstellt wird:
~work/repos/eclipse-jkube-demo-project : $ mvn k8s:build
[INFO] Scannen nach Projekten...
[INFO]
[INFO] ---------------------------------------------
[INFO] Erstellen von random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] k8s: Ausführung im Kubernetes-Modus
[INFO] k8s: Erstellen des Docker-Images im Kubernetes-Modus
[INFO] k8s: Ausführung des Generators spring-boot
[INFO] k8s: spring-boot: Verwendung des Docker-Images quay.io/jkube/jkube-java-binary-s2i:0.0.7 als Basis/Baustelle
[INFO] k8s: [docker.io/rohankanojia/random-generator:0.0.1] "spring-boot": Docker-build.tar in 251 Millisekunden erstellt
[INFO] k8s: [docker.io/rohankanojia/random-generator:0.0.1] "spring-boot": Image sha256:a20e5 erstellt
[INFO] ------------------------------------------------------------------------
[INFO] BUILD ERFOLGREICH
[INFO] ------------------------------------------------------------------------
[INFO] Gesamtzeit: 5.053 s
[INFO] Fertiggestellt um: 2020-08-10T11:28:23+05:30
[INFO] ------------------------------------------------------------------------
~work/repos/eclipse-jkube-demo-project : $
Schritt 3. Das Image in das Docker-Registry hochladen
Nachdem wir das Docker-Image mit dem konfigurierten Push-Registry (in unserem Fall ist es docker.io) erstellt haben, können wir dieses Image in das Registry hochladen. Folgendes wird auf dem Bildschirm 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] Scannen nach Projekten...
[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: Läuft im Kubernetes-Modus
[INFO] k8s: Docker-Image im Kubernetes-Modus erstellen
[INFO] k8s: Ausführender 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: Der Push bezieht sich auf das Repository [docker.io\/rohankanojia\/random-generator]
5dcd9556710f: Schicht existiert bereits
b7139ad07aa8: Schicht existiert bereits
b6f081e4b2b6: Schicht existiert bereits
d8e1f35641ac: Schicht 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] Gesamte Zeit: 11,222 s
[INFO] Fertiggestellt am: 2020-08-10T11:35:37+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $
Nach dem Push des Images muss überprüft werden, ob es im Registry angekommen ist. In unserem Fall sehen wir es einfach im Docker Hub, wie in Abb. 4 gezeigt.
Abb. 4. Das ins Registry hochgeladene Image erscheint im Docker Hub.
Schritt 4. Generierung von Kubernetes-Ressourcen-Manifests für die Anwendung
Also, das Image der Anwendung haben wir erstellt, jetzt müssen wir die Kubernetes-Manifeste schreiben. Dafür gibt es eine Aufgabe in Eclipse JKube, die die harten Manifeste der Ressourcen basierend auf dem zugrunde liegenden Java-Framework generiert (, , Vert.x oder einem anderen). Zudem kann das Manifest so angepasst werden, indem eine Konfigurations-XML-Datei genutzt wird und rohe Fragmente (Fragmente des benötigten Ressourcenmanifests) in den Ordner der Anwendung src\/main\/jkube gelegt werden. In diesem Fall wird Ihre Konfiguration in die generierten Manifeste übertragen.
In unserem Beispiel lassen wir alles wie es ist, und daher generiert Eclipse JKube ein Manifest für das Standard-Deployment und für den Service mit dem Typ ClusterIP. Danach modifizieren wir das Manifest des Services, um den Servicetyp auf NodePort zu ändern. Das Standardverhalten kann mit folgendem Attribut überschrieben werden:
NodePort
So sieht die Bildschirmausgabe aus, nachdem wir Eclipse JKube gebeten haben, die Ressource-Task mvn k8s:resource auszuführen.
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:resource
[INFO] Scannen nach Projekten...
[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 Standard-Deployment hinzu
[INFO] k8s: jkube-service: Füge einen Standarddienst 'random-generator' mit Ports [8080] hinzu
[INFO] k8s: jkube-healthcheck-spring-boot: Füge die Readiness-Probe an Port 8080, Pfad='\/actuator\/health', Schema='HTTP', mit einer Anfangsverzögerung von 10 Sekunden hinzu
[INFO] k8s: jkube-healthcheck-spring-boot: Füge die Liveness-Probe an Port 8080, Pfad='\/actuator\/health', Schema='HTTP', mit einer Anfangsverzögerung von 180 Sekunden hinzu
[INFO] k8s: jkube-revision-history: Füge eine Begrenzung der Versionshistorie auf 2 hinzu
[INFO] ------------------------------------------------------------------------
[INFO] BUILD ERFOLGREICH
[INFO] ------------------------------------------------------------------------
[INFO] Gesamtzeit: 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. Bereitstellung der Anwendung im Kubernetes-Cluster
Nun sind wir bereit, die Anwendung zu deployen: Wir haben das Image generiert und anschließend automatisch die Ressourcenmanifeste erstellt. Jetzt müssen wir nur noch alles auf den Kubernetes-Cluster anwenden. Für die Bereitstellung der Anwendung kann natürlich der Befehl kubectl apply -f verwendet werden, aber das Plugin kann das auch für uns erledigen. So sieht der Bildschirm aus, nachdem wir Eclipse JKube aufgefordert haben, die apply-Aufgabe mvn k8s:apply 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: Verwende 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: Verwende Namespace: default
[INFO] k8s: Erstelle einen Service aus kubernetes.yml Namespace default Name random-generator
[INFO] k8s: Service 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 den Start Ihrer Pods zu beobachten
[INFO] ------------------------------------------------------------------------
[INFO] BAU ERFOLGREICH
[INFO] ------------------------------------------------------------------------
[INFO] Gesamtzeit: 7.306 s
[INFO] Beendet am: 2020-08-10T11:40:57+05:30
[INFO] ------------------------------------------------------------------------
~ /work/repos/eclipse-jkube-demo-project : $ kubectl get pods -w
NAME READY STATUS RESTARTS ALTER
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) ALTER
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 % Erhalten % Übertragen Durchschnittsgeschwindigkeit Zeit Zeit Zeit Aktuell
Dload Upload Gesamt Ausgegeben Rest Geschwindigkeit
100 45 0 45 0 0 1800 0 --:--:-- --:--:-- --:--:-- 1875
{
"id": "42e5571f-a20f-44b3-8184-370356581d10"
}
Schritt 6. Anwendung aus dem Kubernetes-Cluster undeployen
Dafür wird die Aufgabe undeploy verwendet, die einfach alle Ressourcen entfernt, die im vorherigen Schritt, also bei der Ausführung der Aufgabe apply, 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-project : $ kubectl get all
NAME READY STATUS RESTARTS AGE
pod\/random-generator-58b7847d7f-9m9df 1\/1 Running 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-project : $ mvn k8s:undeploy
[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:undeploy (default-cli) @ random-generator ---
[INFO] k8s: Using Kubernetes at https:\/\/192.168.39.145:8443\/ in namespace default with manifest \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/classes\/META-INF\/jkube\/kubernetes.yml
[INFO] k8s: Using namespace: default
[INFO] k8s: Deleting resource Deployment default\/random-generator
[INFO] k8s: Deleting resource Service default\/random-generator
[INFO] k8s: HINT: Use the command `kubectl get pods -w` to watch your pods start up
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.412 s
[INFO] Finished at: 2020-08-10T11:46:22+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get pods -w
^C~\/work\/repos\/eclipse-jkube-demo-project : $ 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-project : $
Was kann man noch mit Eclipse JKube machen
Wir haben also die grundlegenden Ziele von Eclipse JKube und dem Kubernetes Maven Plugin betrachtet, die die Entwicklung von Java-Anwendungen für die Kubernetes-Plattform erleichtern. Wenn Sie diese Aufgaben nicht ständig über die Tastatur 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 sei darauf hingewiesen, dass wir in diesem Artikel bei weitem nicht alle Ziele behandelt haben, die in Eclipse JKube und im Kubernetes Maven Plugin verfügbar sind. Daher geben wir in Tabelle 2 eine Liste zusätzlicher Aufgaben an, die ebenfalls nützlich sein können.
Tabelle 2. Zusätzliche Ziele von Eclipse JKube.
Aufgabe
Die Phase
Beschreibung
VALIDIEREN
Abrufen von Protokollen von einer Anwendung, die auf Kubernetes läuft.
PAKETIEREN
Öffnung des Debugging-Ports, um die Debugging-Anwendung, die auf Kubernetes läuft, direkt aus der IDE durchzuführen.
INSTALL
Erstellung eines Forks für die Install-Aufgabe und Anwendung der generierten Manifestdateien auf den Kubernetes-Cluster genau wie bei der Apply-Aufgabe.
PAKETIEREN
Automatische Hot-Deployment der Anwendung durch Ü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 Präfix der Aufgaben von k8s auf oc geändert wird. Standardmäßig erstellt das Kubernetes Maven Plugin -Builds, während das OpenShift Maven Plugin -Builds . Wir nehmen keine Änderungen an unserem Projekt vor, außer der Entfernung der Eigenschaft jkube.generator.name, da sie beim Pushen in das Registry nicht erforderlich ist (in der Build-Phase platziert OpenShift das Image in seinem internen Registry). Und das wird auf dem Bildschirm erscheinen, wenn wir unser Beispiel ausführen, bei dem wir übrigens die Goal-Aufgaben nicht einzeln, sondern alle gleichzeitig ausführen:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn oc:build oc:resource oc:apply
[INFO] Projekte werden gescannt...
[INFO]
[INFO] ---------------------------------------------
[INFO] Baue random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] oc: Verwendung von OpenShift-Bau mit der Strategie S2I
[INFO] oc: Ausführung im OpenShift-Modus
[INFO] oc: Ausführung des Generators spring-boot
[INFO] oc: spring-boot: Verwendung des Docker-Images quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 als Basis \/ Builder
[INFO] oc: [random-generator:0.0.1] "spring-boot": Docker-Quell-Tar erstellt \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/docker\/random-generator\/0.0.1\/tmp\/docker-build.tar
[INFO] oc: Hinzufügen zu Secret pullsecret-jkube
[INFO] oc: Verwendung von Secret pullsecret-jkube
[INFO] oc: Erstelle BuildServiceConfig random-generator-s2i für Source-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: Abfrage von Bildquellensignaturen
[INFO] oc: Kopieren des Blobs sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Kopieren des Blobs sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Kopieren des Blobs sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Kopieren der Konfiguration sha256:52d6788fcfdd39595264d34a3959464a5dabc1d4ef0ae188802b20fc2d6a857b
[INFO] oc: Schreiben des Manifests an das Bildziel
[INFO] oc: Speichern der Signaturen
[INFO] oc: Generierung der Docker-Datei mit dem 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: BEZEICHNEN "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: USER root
[INFO] oc: SCHRITT 5: COPY upload\/src \/tmp\/src
[INFO] oc: SCHRITT 6: RUN chown -R 1000:0 \/tmp\/src
[INFO] oc: SCHRITT 7: USER 1000
[INFO] oc: SCHRITT 8: RUN \/usr\/local\/s2i\/assemble
[INFO] oc: INFO S2I-Quell-Build mit einfachen Binaries erkannt
[INFO] oc: INFO S2I-Binär-Build von fabric8-maven-plugin erkannt
[INFO] oc: INFO Kopieren der Binaries von \/tmp\/src\/deployments zu \/deployments ...
[INFO] oc: random-generator-0.0.1.jar
[INFO] oc: INFO Kopieren der 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="Bild-Betriebssystem-Mismatch: Bild verwendet "", erwartet "linux""
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Bild-Architektur-Mismatch: Bild verwendet "", erwartet "amd64""
[INFO] oc: Abfrage von Bildquellensignaturen
[INFO] oc: Kopieren des Blobs sha256:d8e1f35641acb80b562f70cf49911341dfbe8c86f4d522b18efbf3732aa74223
[INFO] oc: Kopieren des Blobs sha256:b6f081e4b2b6de8be4b1dec132043d14c121e968384dd624fb69c2c07b482edb
[INFO] oc: Kopieren des Blobs sha256:b7139ad07aa8ce4ed5a132f7c5cc9f1de0f5099b5e155027a23d57f7fbe78b16
[INFO] oc: Kopieren des Blobs sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Kopieren der Konfiguration sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Schreiben des Manifests an das Bildziel
[INFO] oc: Speichern der Signaturen
[INFO] oc: --> 27aaadaf28e
[INFO] oc: 27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Abfrage von Bildquellensignaturen
[INFO] oc:
[INFO] oc: Bild pushen image-registry.openshift-image-registry.svc:5000\/default\/random-generator:0.0.1 ...
[INFO] oc: Kopieren des Blobs sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Kopieren des Blobs sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Kopieren des Blobs sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Kopieren des Blobs sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Kopieren der Konfiguration sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Schreiben des Manifests an das Bildziel
[INFO] oc: Speichern der Signaturen
[INFO] oc: Erfolgreich gepusht image-registry.openshift-image-registry.svc:5000\/default\/random-generator@sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: Push erfolgreich
[INFO] oc: Build random-generator-s2i-1 im Status abgeschlossen
[INFO] oc: Tag auf ImageStream random-generator gefunden Tag: sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: ImageStream random-generator in /home/rohaan/work/repos/eclipse-jkube-demo-project/target/random-generator-is.yml gespeichert
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:resource (default-cli) @ random-generator ---
[INFO] oc: Verwendung des Docker-Image-Namens des Namensraums: default
[INFO] oc: Ausführung des Generators spring-boot
[INFO] oc: spring-boot: Verwendung des Docker-Images quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 als Basis \/ Builder
[INFO] oc: jkube-controller: Fügen Sie eine Standard-DeploymentConfig hinzu
[INFO] oc: jkube-service: Fügen Sie einen Standarddienst 'random-generator' mit Ports [8080] hinzu
[INFO] oc: jkube-healthcheck-spring-boot: Hinzufügen der Readiness-Prüfung am Port 8080, Pfad='\/actuator\/health', Schema='HTTP', mit anfänglicher Verzögerung von 10 Sekunden
[INFO] oc: jkube-healthcheck-spring-boot: Hinzufügen der Liveness-Prüfung am Port 8080, Pfad='\/actuator\/health', Schema='HTTP', mit anfänglicher Verzögerung von 180 Sekunden
[INFO] oc: jkube-revision-history: Hinzufügen einer Versionshistory-Begrenzung von 2
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] oc: Verwendung von OpenShift unter https:\/\/api.crc.testing:6443\/ im Namensraum default mit Manifest \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/classes\/META-INF\/jkube\/openshift.yml
[INFO] oc: OpenShift-Plattform erkannt
[INFO] oc: Verwendung des Projekts: default
[INFO] oc: Erstelle einen Dienst aus openshift.yml Namensraum default Name random-generator
[INFO] oc: Dienst erstellt: target\/jkube\/applyJson\/default\/service-random-generator.json
[INFO] oc: Erstelle eine DeploymentConfig aus openshift.yml Namensraum 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 zu sehen, wie Ihre Pods starten
[INFO] ------------------------------------------------------------------------
[INFO] BUILD ERFOLGREICH
[INFO] ------------------------------------------------------------------------
[INFO] Gesamtzeit: 01:07 min
[INFO] Beendet am: 2020-08-10T12:08:00+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $ oc get pods -w
NAME READY STATUS RESTARTS AGE
random-generator-1-deploy 1\/1 Laufen 0 14s
random-generator-1-vnrm9 0\/1 Laufen 0 11s
random-generator-s2i-1-build 0\/1 Abgeschlossen 0 1m
random-generator-1-vnrm9 1\/1 Laufen 0 24s
random-generator-1-deploy 0\/1 Abgeschlossen 0 28s
~\/work\/repos\/eclipse-jkube-demo-project : $ oc get routes
NAME HOST\/PORT PATH SERVICES PORT TERMINATION WILDCARD
random-generator random-generator-default.apps-crc.testing random-generator 8080 None
~\/work\/repos\/eclipse-jkube-demo-project : $ curl random-generator-default.apps-crc.testing\/random
% Gesamt % Empfangen % Xferd Durchschnittsgeschwindigkeit Zeit Zeit Zeit Aktuell
Dload Hochladen Gesamt Ausgegeben Verbleibend Geschwindigkeit
100 45 0 45 0 0 1666 0 --:--:-- --:--:-- --:--:-- 1730
{
"id": "d80052d9-2f92-43cb-b9eb-d7cffb879798"
}
~\/work\/repos\/eclipse-jkube-demo-project : $
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 von Java-Entwicklern bei der Arbeit mit Kubernetes erleichtert. Weitere Informationen zu Eclipse JKube finden Sie unter und auf .
Quelle: habr.com
