Vor 25 Jahren trat Java in den Mainstream der Programmierung ein und wurde schließlich zu einem der Kernelemente, um die herum Anwendungs-Stacks aufgebaut sind. Heutzutage sind jedoch viele Menschen und Organisationen, die Java seit vielen Jahren treu bleiben, mit der Migration auf die Plattform beschäftigt oder erwägen dies. oder seine Derivate wie z oder .
Leider weist Kubernetes eine steile Lernkurve auf und führt eine weitere operative Ebene in den Entwicklungsprozess ein, an die Java-Programmierer gewöhnt sind. Heute erklären wir Ihnen, wie Sie es verwenden , um diese zusätzlichen Vorgänge im Zusammenhang mit Kubernetes und Containern zu vereinfachen und eine reibungslose Migration zur Cloud-Plattform unter Beibehaltung des vertrauten Java-Ökosystems sicherzustellen. Darüber hinaus zeigen wir, wie Sie Java-Anwendungen mithilfe des OpenShift Maven-Plugins auf der OpenShift-Plattform bereitstellen.
Traditioneller Java-Entwicklungsprozess
Traditioneller Entwicklungsprozess (Abbildung 1) beinhaltet, dass der Entwickler Code schreibt, dann Bereitstellungseinheiten in Form von JAR- oder WAR-Dateien erstellt und diese Dateien dann auf einem Web- oder Anwendungsserver bereitstellt und ausführt. Dies geschieht hauptsächlich über die Verwendung von Maven über die Befehlszeile oder die Verwendung einer IDE wie IntelliJ oder Eclipse zum Codieren und Verpacken der Anwendungen. Entwickler sind es gewohnt, Codeänderungen vorzunehmen und alles gründlich zu testen, bevor sie den Code festschreiben und der Versionskontrolle übergeben.
Reis. 1. Traditioneller Java-Entwicklungsprozess.
Java-Entwicklungsprozess für die Cloud
Bei der Umstellung auf Cloud-Anwendungen, Kubernetes und . Daher muss der Entwickler jetzt Java-Anwendungen einpacken und erstellen Sie Kubernetes-Manifeste, die diese Bilder beschreiben. Diese Manifeste werden dann auf den Produktionsserver angewendet, auf dem Kubernetes ausgeführt wird. Kubernetes wiederum entnimmt diese Images der Registrierung und stellt Anwendungen gemäß den Konfigurationen bereit, die wir in Manifesten geschrieben haben, bei denen es sich normalerweise um YAML-Dateien handelt.
Die Metamorphose des traditionellen Java-Entwicklungsprozesses beim Übergang zur Cloud ist in Abb. dargestellt. 2.
Reis. 2. Java-Entwicklungsprozess für die Cloud.
Eclipse JKube
Die Migration zu Kubernetes fügt dem Entwicklungsprozess eine weitere operative Ebene hinzu, und viele Entwickler sind deswegen nervös, weil sie sich auf ihre Kernarbeit – die Anwendungslogik – konzentrieren möchten und nicht darauf, wie man sie bereitstellt. Und hier kommt es ins Spiel. , wodurch Entwickler ihre Bibliotheken und Plugins verwenden können ( mit oder ), um Container- und Kubernetes-bezogene Vorgänge mühelos durchzuführen, indem Sie dem Diagramm in Abbildung folgen. 2.
Im Rest dieses Artikels zeigen wir Ihnen, wie Sie den Java-Entwicklungsprozess in der Kubernetes-Umgebung vereinfachen, indem Sie Eclipse JKube mit dem Kubernetes Maven Plugin verwenden.
Cloud-Entwicklungsprozess mit Eclipse JKube
Betrachten wir ein leicht modifiziertes Java-Entwicklungsschema für die Cloud aus Abb. 2, in das wir Eclipse JKube und das Kubernetes Maven Plugin einführen, wie in Abb. gezeigt. 3.
Reis. 3. Java-Entwicklungsprozess für die Cloud mit Eclipse JKube.
Wie wir sehen können, werden hier alle Vorgänge zur Interaktion mit Kubernetes und Containern (im Diagramm rot hervorgehoben) durch standardmäßige Eclipse-JKube-Zielaufgaben ersetzt, die in der Tabelle aufgeführt sind. 1.
Tisch 1. Eclipse JKube-Standardaufgaben.
Aufgabe
Bühne
Beschreibung
PRE_INTEGRATION_TEST
Docker-Images erstellen
INSTALLIEREN
Docker-Images in die Registrierung hochladen
PROZESS_RESSOURCEN
Generieren von K8-Manifesten
KOMPILIEREN
Anwenden generierter Manifeste auf K8s
UNDEPLOY
Entfernen von K8s-Ressourcen, die mit k8s:apply und k8s:deploy bereitgestellt wurden
Hinweis: Wenn Sie nicht möchten, dass Aufgaben diese vorgegebenen Standardeinstellungen verwenden, können Sie Eclipse JKube manuell für sich selbst konfigurieren, da es die Konfiguration über unterstützt и .
Schauen wir uns nun Beispiele für die Verwendung des Eclipse JKube- und Kubernetes Maven-Plugins bei der Arbeit mit Anwendungen an.
Bereitstellen einer Java-Anwendung auf Kubernetes mit Eclipse JKube
In diesem Beispiel werden wir eine einfache Java-Anwendung auf einem Cluster bereitstellen mit Eclipse JKube. Mit dem Kubernetes Maven Plugin können wir Bereitstellungsparameter festlegen, ohne eine Konfiguration schreiben zu müssen.
Als Beispielanwendung verwenden wir , was eine JSON-Ausgabe am /random-Endpunkt erzeugt:
~/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 verwenden zu können, müssen Sie das Kubernetes Maven Plugin als Abhängigkeit zu Ihrer pom.xml hinzufügen:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>kubernetes-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Wenn OpenShift anstelle von reinem Kubernetes verwendet wird, wird pom.xml wie folgt geändert:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>openshift-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Schritt 2. Erstellen Sie das Docker-Image
Die JAR-Datei der Anwendung kann mit dem Befehl mvn package erstellt werden. Anschließend kann mit der MVN-Zielaufgabe k8s:build ein Docker-Image der Anwendung erstellt werden. Beachten Sie, dass wir den Standardbildnamen mit dieser Eigenschaft überschrieben haben:
<jkube.generator.name>docker.io/rohankanojia/random-generator:${project.version}</jkube.generator.name>
Bevor Sie das Image erstellen, müssen Sie sicherstellen, dass der Docker-Daemon korrekt verfügbar gemacht wird. Dies kann mit dem folgenden Befehl erfolgen:
$ eval $(minikube docker-env)
Dann geben wir den Befehl mvn k8s:build ein und Folgendes sehen wir auf dem Bildschirm, wenn wir das Docker-Image mit der Eclipse-JKube-Build-Aufgabe erstellen:
~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:build
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[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: Laden Sie das Bild in die Docker-Registrierung hoch
Nachdem wir das Docker-Image mit konfigurierter Push-Registrierung erstellt haben (in unserem Fall ist es docker.io), können wir dieses Image an die Registry senden. Folgendes wird angezeigt, nachdem wir Eclipse JKube gebeten haben, die Push-Aufgabe mvn k8s:push auszuführen:
~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:push
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Building random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:push (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: The push refers to repository [docker.io/rohankanojia/random-generator]
5dcd9556710f: Layer already exists
b7139ad07aa8: Layer already exists
b6f081e4b2b6: Layer already exists
d8e1f35641ac: Layer already exists
[INFO] k8s: 0.0.1: digest: sha256:9f9eda2a13b8cab1d2c9e474248500145fc09e2922fe3735692f9bda4c76002d size: 1162
[INFO] k8s: Pushed docker.io/rohankanojia/random-generator:0.0.1 in 7 seconds
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 11.222 s
[INFO] Finished at: 2020-08-10T11:35:37+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $
Nachdem Sie das Bild gesendet haben, müssen Sie überprüfen, ob es in der Registrierung enthalten ist. In unserem Fall sehen wir es einfach im Docker Hub, wie in Abb. 4.
Reis. 4. Das an die Registrierung gesendete Image wurde im Docker Hub angezeigt.
Schritt 4: Generieren Sie Kubernetes-Ressourcenmanifeste für die Anwendung
Wir haben also das Anwendungsimage zusammengestellt und müssen nun Kubernetes-Manifeste schreiben. Zu diesem Zweck verfügt Eclipse JKube über eine Aufgabe, die starre Ressourcenmanifeste basierend auf dem zugrunde liegenden Java-Framework generiert (, , Vert.x oder ein anderes). Sie können das Manifest auch anpassen, indem Sie eine XML-Konfigurationsdatei verwenden und Rohfragmente (Fragmente des erforderlichen Ressourcenmanifests) im Anwendungsordner src/main/jkube platzieren. In diesem Fall wird Ihre Konfiguration in die generierten Manifeste hochgeladen.
In unserem Beispiel lassen wir alles so, wie es ist, und daher generiert Eclipse JKube ein Manifest für die Standardbereitstellung und für den Dienst vom Typ ClusterIP. Und erst dann ändern wir das Dienstmanifest, um den Diensttyp in NodePort zu ändern. Sie können das Standardverhalten mit der folgenden Eigenschaft überschreiben:
<jkube.enricher.jkube-service.type>NodePort</jkube.enricher.jkube-service.type>
So sieht die Bildschirmausgabe aus, nachdem wir Eclipse JKube gebeten haben, die Ressourcenaufgabe „mvn k8s:resource“ auszuführen.
~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:resource
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Building random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:resource (default-cli) @ random-generator ---
[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: jkube-controller: Adding a default Deployment
[INFO] k8s: jkube-service: Adding a default service 'random-generator' with ports [8080]
[INFO] k8s: jkube-healthcheck-spring-boot: Adding readiness probe on port 8080, path='/actuator/health', scheme='HTTP', with initial delay 10 seconds
[INFO] k8s: jkube-healthcheck-spring-boot: Adding liveness probe on port 8080, path='/actuator/health', scheme='HTTP', with initial delay 180 seconds
[INFO] k8s: jkube-revision-history: Adding revision history limit to 2
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.344 s
[INFO] Finished at: 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: [email protected]: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: Stellen Sie die Anwendung im Kubernetes-Cluster bereit
Jetzt können wir die Anwendung bereitstellen: Wir haben ihr Image und dann automatisch Ressourcenmanifeste generiert. Jetzt müssen wir das alles nur noch auf den Kubernetes-Cluster anwenden. Um die Anwendung bereitzustellen, können Sie natürlich den Befehl kubectl apply -f verwenden, aber das Plugin kann dies für uns erledigen. Dies wird auf dem Bildschirm angezeigt, nachdem wir Eclipse JKube gebeten haben, die Apply-Aufgabe „mvn k8s:apply“ auszuführen:
~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:apply
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Building random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:apply (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: Creating a Service from kubernetes.yml namespace default name random-generator
[INFO] k8s: Created Service: target/jkube/applyJson/default/service-random-generator.json
[INFO] k8s: Creating a Deployment from kubernetes.yml namespace default name random-generator
[INFO] k8s: Created Deployment: target/jkube/applyJson/default/deployment-random-generator.json
[INFO] k8s: HINT: Use the command `kubectl get pods -w` to watch your pods start up
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 7.306 s
[INFO] Finished at: 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 Running 0 7s
random-generator-58b7847d7f-9m9df 1/1 Running 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 <none> 9080:30570/TCP 44h
kubernetes ClusterIP 10.96.0.1 <none> 443/TCP 18d
random-generator NodePort 10.97.172.147 <none> 8080:32186/TCP 22s
~/work/repos/eclipse-jkube-demo-project : $ curl `minikube ip`:32186/random | jq .
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 45 0 45 0 0 1800 0 --:--:-- --:--:-- --:--:-- 1875
{
"id": "42e5571f-a20f-44b3-8184-370356581d10"
}
Schritt 6: Deinstallieren Sie Anwendungen aus dem Kubernetes-Cluster
Hierzu wird der Undeploy-Task verwendet, der einfach alle Ressourcen entfernt, die im vorherigen Schritt, also bei Ausführung des Apply-Tasks, angewendet wurden. Folgendes sehen wir auf dem Bildschirm, 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 <none> 443/TCP 18d
service/random-generator NodePort 10.97.172.147 <none> 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] ----------------------< meetup:random-generator >-----------------------
[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 <none> 443/TCP 18d
~/work/repos/eclipse-jkube-demo-project : $
Was können Sie sonst noch mit Eclipse JKube machen?
Deshalb haben wir uns die Hauptzielaufgaben von Eclipse JKube und Kubernetes Maven Plugin angesehen, 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 beispielsweise so schreiben:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>kubernetes-maven-plugin</artifactId>
<version>${project.version}</version>
<executions>
<execution>
<goals>
<goal>build</goal>
<goal>resource</goal>
<goal>apply</goal>
</goals>
</execution>
</executions>
</plugin>
Es muss gesagt werden, dass wir in diesem Artikel nicht alle Zielaufgaben berücksichtigt haben, die in Eclipse JKube und dem Kubernetes Maven Plugin enthalten sind. Daher stellen wir in Tabelle 2 eine Liste zusätzlicher Aufgaben bereit, die auch für Sie nützlich sein können.
Tisch 2. Zusätzliche Eclipse JKube-Zielaufgaben.
Aufgabe
Bühne
Beschreibung
BESTÄTIGEN
Empfangen von Protokollen von einer Anwendung, die auf Kubernetes ausgeführt wird.
PAKET
Öffnen Sie einen Debug-Port, damit Sie Ihre auf Kubernetes ausgeführte Anwendung direkt von der IDE aus debuggen können.
INSTALLIEREN
Erstellen Sie einen Fork für die Install-Aufgabe und wenden Sie die generierten Manifeste auf die gleiche Weise wie bei der Apply-Aufgabe auf den Kubernetes-Cluster an.
PAKET
Automatische Hot-Bereitstellung einer Anwendung durch Verfolgung ihres Namespace.
Bereitstellen 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 sich das Aufgabenpräfix von k8s in oc ändert. Standardmäßig ist dies beim Kubernetes Maven-Plugin der Fall -Assemblys und das OpenShift Maven-Plugin – Assemblys . Wir nehmen keine Änderungen an unserem Projekt vor, außer der Entfernung der Eigenschaft jkube.generator.name, da diese beim Pushen in die Registrierung nicht erforderlich ist (Während der Erstellungsphase platziert OpenShift das Image in seiner internen Registrierung). Und das wird auf dem Bildschirm erscheinen, wenn wir unser Beispiel ausführen, in dem wir übrigens Zielaufgaben nicht einzeln, sondern alle auf einmal ausführen:
~/work/repos/eclipse-jkube-demo-project : $ mvn oc:build oc:resource oc:apply
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Building random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] oc: Using OpenShift build with strategy S2I
[INFO] oc: Running in OpenShift mode
[INFO] oc: Running generator spring-boot
[INFO] oc: spring-boot: Using Docker image quay.io/jkube/jkube-java-binary-s2i:0.0.7 as base / builder
[INFO] oc: [random-generator:0.0.1] "spring-boot": Created docker source tar /home/rohaan/work/repos/eclipse-jkube-demo-project/target/docker/random-generator/0.0.1/tmp/docker-build.tar
[INFO] oc: Adding to Secret pullsecret-jkube
[INFO] oc: Using Secret pullsecret-jkube
[INFO] oc: Creating BuildServiceConfig random-generator-s2i for Source build
[INFO] oc: Creating ImageStream random-generator
[INFO] oc: Starting Build random-generator-s2i
[INFO] oc: Waiting for build random-generator-s2i-1 to complete...
[INFO] oc: Caching blobs under "/var/cache/blobs".
[INFO] oc: Getting image source signatures
[INFO] oc: Copying blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Copying blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Copying blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Copying config sha256:52d6788fcfdd39595264d34a3959464a5dabc1d4ef0ae188802b20fc2d6a857b
[INFO] oc: Writing manifest to image destination
[INFO] oc: Storing signatures
[INFO] oc: Generating dockerfile with builder image quay.io/jkube/jkube-java-binary-s2i:0.0.7
[INFO] oc: STEP 1: FROM quay.io/jkube/jkube-java-binary-s2i:0.0.7
[INFO] oc: STEP 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: STEP 3: ENV JAVA_APP_DIR="/deployments" OPENSHIFT_BUILD_NAME="random-generator-s2i-1" OPENSHIFT_BUILD_NAMESPACE="default"
[INFO] oc: STEP 4: USER root
[INFO] oc: STEP 5: COPY upload/src /tmp/src
[INFO] oc: STEP 6: RUN chown -R 1000:0 /tmp/src
[INFO] oc: STEP 7: USER 1000
[INFO] oc: STEP 8: RUN /usr/local/s2i/assemble
[INFO] oc: INFO S2I source build with plain binaries detected
[INFO] oc: INFO S2I binary build from fabric8-maven-plugin detected
[INFO] oc: INFO Copying binaries from /tmp/src/deployments to /deployments ...
[INFO] oc: random-generator-0.0.1.jar
[INFO] oc: INFO Copying deployments from deployments to /deployments...
[INFO] oc: '/tmp/src/deployments/random-generator-0.0.1.jar' -> '/deployments/random-generator-0.0.1.jar'
[INFO] oc: STEP 9: CMD /usr/local/s2i/run
[INFO] oc: STEP 10: COMMIT temp.builder.openshift.io/default/random-generator-s2i-1:48795e41
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Image operating system mismatch: image uses "", expecting "linux""
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Image architecture mismatch: image uses "", expecting "amd64""
[INFO] oc: Getting image source signatures
[INFO] oc: Copying blob sha256:d8e1f35641acb80b562f70cf49911341dfbe8c86f4d522b18efbf3732aa74223
[INFO] oc: Copying blob sha256:b6f081e4b2b6de8be4b1dec132043d14c121e968384dd624fb69c2c07b482edb
[INFO] oc: Copying blob sha256:b7139ad07aa8ce4ed5a132f7c5cc9f1de0f5099b5e155027a23d57f7fbe78b16
[INFO] oc: Copying blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Copying config sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Writing manifest to image destination
[INFO] oc: Storing signatures
[INFO] oc: --> 27aaadaf28e
[INFO] oc: 27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Getting image source signatures
[INFO] oc:
[INFO] oc: Pushing image image-registry.openshift-image-registry.svc:5000/default/random-generator:0.0.1 ...
[INFO] oc: Copying blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Copying blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Copying blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Copying blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Copying config sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Writing manifest to image destination
[INFO] oc: Storing signatures
[INFO] oc: Successfully pushed image-registry.openshift-image-registry.svc:5000/default/random-generator@sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: Push successful
[INFO] oc: Build random-generator-s2i-1 in status Complete
[INFO] oc: Found tag on ImageStream random-generator tag: sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: ImageStream random-generator written to /home/rohaan/work/repos/eclipse-jkube-demo-project/target/random-generator-is.yml
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:resource (default-cli) @ random-generator ---
[INFO] oc: Using docker image name of namespace: default
[INFO] oc: Running generator spring-boot
[INFO] oc: spring-boot: Using Docker image quay.io/jkube/jkube-java-binary-s2i:0.0.7 as base / builder
[INFO] oc: jkube-controller: Adding a default DeploymentConfig
[INFO] oc: jkube-service: Adding a default service 'random-generator' with ports [8080]
[INFO] oc: jkube-healthcheck-spring-boot: Adding readiness probe on port 8080, path='/actuator/health', scheme='HTTP', with initial delay 10 seconds
[INFO] oc: jkube-healthcheck-spring-boot: Adding liveness probe on port 8080, path='/actuator/health', scheme='HTTP', with initial delay 180 seconds
[INFO] oc: jkube-revision-history: Adding revision history limit to 2
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] oc: Using OpenShift at https://api.crc.testing:6443/ in namespace default with manifest /home/rohaan/work/repos/eclipse-jkube-demo-project/target/classes/META-INF/jkube/openshift.yml
[INFO] oc: OpenShift platform detected
[INFO] oc: Using project: default
[INFO] oc: Creating a Service from openshift.yml namespace default name random-generator
[INFO] oc: Created Service: target/jkube/applyJson/default/service-random-generator.json
[INFO] oc: Creating a DeploymentConfig from openshift.yml namespace default name random-generator
[INFO] oc: Created DeploymentConfig: target/jkube/applyJson/default/deploymentconfig-random-generator.json
[INFO] oc: Creating Route default:random-generator host: null
[INFO] oc: HINT: Use the command `oc get pods -w` to watch your pods start up
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 01:07 min
[INFO] Finished at: 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 Running 0 14s
random-generator-1-vnrm9 0/1 Running 0 11s
random-generator-s2i-1-build 0/1 Completed 0 1m
random-generator-1-vnrm9 1/1 Running 0 24s
random-generator-1-deploy 0/1 Completed 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
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 45 0 45 0 0 1666 0 --:--:-- --:--:-- --:--:-- 1730
{
"id": "d80052d9-2f92-43cb-b9eb-d7cffb879798"
}
~/work/repos/eclipse-jkube-demo-project : $
Videolektion
Um mehr darüber zu erfahren, wie Sie die Kubernetes-Entwicklung mit Eclipse JKube vereinfachen können, sehen Sie sich dieses Video-Tutorial zur schnellen Bereitstellung einer einfachen Spring Boot-Anwendung auf Minikube an:
Abschluss
In diesem Artikel haben wir gezeigt, wie Eclipse JKube einem Java-Entwickler das Leben bei der Arbeit mit Kubernetes erleichtert. Weitere Informationen zu Eclipse JKube finden Sie unter und .
Source: habr.com