Leider hat Kubernetes eine steile Lernkurve und führt eine weitere operative Ebene in den Java-Entwicklungsprozess ein. Heute zeigen wir Ihnen, wie Sie Eclipse JKube verwendenVereinfachung dieser zusätzlichen Vorgänge in Bezug auf Kubernetes und Container sowie Bereitstellung einer schmerzlosen Migration auf die Cloud-Plattform unter Beibehaltung des bekannten Java-Ökosystems. Darüber hinaus zeigen wir, wie Java-Anwendungen mithilfe des OpenShift Maven-Plugins auf der OpenShift-Plattform bereitgestellt werden.
Traditioneller Java-Entwicklungsprozess
Der traditionelle Java- Entwicklungsprozess (Abbildung 1) bedeutet, dass ein Entwickler Code schreibt, dann Bereitstellungseinheiten als JAR- oder WAR-Dateien erstellt und diese Dateien dann auf einem Web- oder Anwendungsserver bereitstellt und ausführt. Meistens verwenden sie Maven über die Befehlszeile oder verwenden eine IDE wie IntelliJ oder Eclipse, um Anwendungen zu codieren und zu verpacken. Entwickler sind es gewohnt, Änderungen am Code vorzunehmen und alles gründlich zu testen, bevor sie den Code festschreiben und an die Quellcodeverwaltung senden.
Zahl: 1. Der traditionelle Java-Entwicklungsprozess.
Java-Entwicklungsprozess für die Cloud
Wenn Sie zu Cloud-Anwendungen wechseln , werden dem obigen Schema Kubernetes und Container hinzugefügt . Daher muss der Entwickler jetzt Java-Anwendungen in Container-Images verpacken und Kubernetes-Manifeste erstellen, die diese Images beschreiben. Diese Manifeste werden dann auf den Produktionsserver angewendet, auf dem Kubernetes ausgeführt wird. Kubernetes wiederum nimmt diese Bilder aus der Registrierung und stellt Anwendungen gemäß den Konfigurationen bereit, die wir in den Manifesten geschrieben haben, bei denen es sich normalerweise um YAML-Dateien handelt.
Die Metamorphose der traditionellen Java-Entwicklung beim Übergang in die Cloud ist in Abb. 2 dargestellt. 2.
Zahl: 2. Java-Entwicklungsprozess für die Cloud.
Eclipse JKube
Der Wechsel zu Kubernetes fügt dem Entwicklungsprozess eine weitere betriebliche Ebene hinzu. Dies ist für viele Entwickler beunruhigend, da sie ihre Hauptaufgabe - die Logik der Anwendungen - erledigen möchten und nicht, wie sie bereitgestellt werden sollen. Hier kommt Eclipse JKube ins Spiel , mit dem Entwickler ihre Bibliotheken und Plugins ( JKube Kit zusammen mit dem Kubernetes Maven Plugin oder OpenShift Maven Plugin ) verwenden können, um mühelos Container- und Kubernetes-bezogene Vorgänge gemäß dem Diagramm in Abb. 1 auszuführen. 2.
Im Rest dieses Artikels zeigen wir Ihnen, wie Sie den Java-Entwicklungsprozess auf Kubernetes mithilfe von Eclipse JKube mit dem Kubernetes Maven Plugin vereinfachen können.
Cloud-Entwicklungsprozess mit Eclipse JKube
Schauen wir uns das leicht modifizierte Java-Entwicklungsframework für die Cloud aus Abbildung 2 an, in dem das Eclipse JKube- und Kubernetes Maven-Plugin eingeführt wird (siehe Abbildung 2). 3.
Zahl: 3. Java-Entwicklungsprozess für die Cloud mit Eclipse JKube.
Wie wir sehen können, werden hier alle Vorgänge für die Interaktion mit Kubernetes und Containern (im Diagramm rot hervorgehoben) durch Standard-Eclipse JKube-Zielaufgaben ersetzt, die in der Tabelle aufgeführt sind. 1.
Tab. 1. Eclipse JKube-Standardaufgaben.
| Aufgabe | Bühne | Beschreibung |
|---|---|---|
| k8s: bauen | PRE_INTEGRATION_TEST | Erstellen von Docker-Bildern |
| k8s: drücken | INSTALLIEREN | Hochladen von Docker-Bildern in die Registrierung |
| k8s: Ressource | PROCESS_RESOURCES | Das Generieren von K8s manifestiert sich |
| k8s: anwenden | KOMPILIEREN | Generierte Manifeste auf K8s anwenden |
| k8s: Bereitstellung aufheben | UNDEPLOY | Entfernen von K8s-Assets, die mit k8s: apply und k8s: deploy bereitgestellt wurden |
Hinweis: Wenn Sie nicht möchten, dass Aufgaben diese Standardeinstellungen verwenden, können Sie Eclipse JKube manuell anpassen, da es die Konfiguration über XML und Ressourcen unterstützt .
Schauen wir uns nun Beispiele für die Verwendung des Eclipse JKube- und Kubernetes Maven-Plugins bei der Arbeit mit Anwendungen an.
Stellen Sie die Java-Anwendung mit Eclipse JKube auf Kubernetes bereit
In diesem Beispiel stellen wir mithilfe von Eclipse JKube eine einfache Java-Anwendung für den Minikube- Cluster bereit. Mit dem Kubernetes Maven Plugin können wir Bereitstellungsoptionen festlegen, ohne eine Konfiguration schreiben zu müssen.
Als Beispielanwendung verwenden wir einen einfachen Zufallszahlengenerator , der 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 Maven Central 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 reinen Kubernetes verwendet wird, wird die Datei 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 des Docker-Images Die
JAR-Datei der Anwendung kann mit dem Befehl mvn package erstellt werden. Anschließend können Sie mit der Task mvn k8s: build target das Docker-Image dieser Anwendung erstellen. 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 ist. Dies kann mit dem folgenden Befehl erfolgen:
$ eval $(minikube docker-env)
Dann geben wir den Befehl mvn k8s: build ein. Dies sehen wir auf dem Bildschirm, wenn wir das Docker-Image mit der Build-Aufgabe Eclipse JKube 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. Hochladen des Images in die Docker-Registrierung
Nachdem wir das Docker-Image mit der konfigurierten Push-Registrierung erstellt haben (in unserem Fall docker.io), können wir dieses Image in die Registrierung übertragen. Dies wird angezeigt, nachdem wir Eclipse JKube gebeten haben, die mvn k8s auszuführen: push push task:
~/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 : $
Nach dem Senden des Bildes müssen Sie überprüfen, ob es sich in der Registrierung befindet. In unserem Fall sehen wir es nur im Docker Hub, wie in Abb. 4.
Zahl: 4. Das in die Registrierung hochgeladene Bild wurde im Docker Hub angezeigt.
Schritt 4. Generieren von Kubernetes-Ressourcenmanifesten für die Anwendung
Nachdem wir das Anwendungsimage zusammengestellt haben, müssen wir nun Kubernetes-Manifeste schreiben. Zu diesem Zweck verfügt Eclipse JKube über eine Aufgabe, die auf der Grundlage des zugrunde liegenden Java-Frameworks ( Spring Boot , Quarkus , Vert.x oder ein anderes) Manifeste für harte Ressourcen generiert . Sie können das Manifest auch anpassen, indem Sie eine XML-Konfigurationsdatei verwenden und Rohfragmente (Fragmente des erforderlichen Ressourcenmanifests) im Anwendungsordner src / main / jkube ablegen. In diesem Fall wird Ihre Konfiguration in die generierten Manifeste hochgeladen.
In unserem Beispiel lassen wir alles so, wie es ist, und daher generiert der Eclipse JKube ein Manifest für die Standardbereitstellung und für den Dienst mit dem ClusterIP-Typ. Anschließend ändern wir das Service-Manifest, um den Service-Typ in NodePort zu ändern. Sie können das Standardverhalten mithilfe 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 Task mvn k8s: resource 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: 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. Bereitstellen der Anwendung im Kubernetes-Cluster
Wir sind also bereit, die Anwendung bereitzustellen: Wir haben das Image generiert und dann automatisch Ressourcenmanifeste generiert. Jetzt müssen Sie nur noch alles 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 tun. Dies wird auf dem Bildschirm angezeigt, nachdem wir Eclipse JKube gebeten haben, die mvn k8s auszuführen: apply apply task:
~/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. Wir heben die Bereitstellung der Anwendung aus dem Kubernetes-Cluster auf.
Dazu wird die Aufgabe zum Aufheben der Bereitstellung verwendet, bei der einfach alle Ressourcen gelöscht werden, die im vorherigen Schritt angewendet wurden, dh als die Anwendungstask ausgeführt wurde. Dies sehen wir auf dem Bildschirm, nachdem wir Eclipse JKube gebeten haben, die Aufgabe mvn k8s: undeploy 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 noch mit Eclipse JKube tun?
Daher haben wir die Hauptziele des Eclipse JKube- und Kubernetes Maven-Plugins behandelt, die die Entwicklung von Java-Anwendungen für die Kubernetes-Plattform vereinfachen. Wenn Sie diese Aufgaben nicht ständig über die Tastatur eingeben möchten, können Sie sie beispielsweise wie folgt in die Plugin-Konfiguration 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>
Ich muss sagen, dass wir in diesem Artikel weit entfernt von allen Zielaufgaben im Eclipse JKube- und Kubernetes Maven-Plugin berücksichtigt haben. Daher stellen wir in Tabelle 2 eine Liste zusätzlicher Aufgaben vor, die auch für Sie nützlich sein können.
Tab. 2. Zusätzliche Eclipse JKube-Ziele.
| Aufgabe | Bühne | Beschreibung |
|---|---|---|
| k8s: log | BESTÄTIGEN | Empfangen von Protokollen von einer Anwendung, die auf Kubernetes ausgeführt wird. |
| k8s: debuggen | PAKET | Öffnen eines Debug-Ports zum Debuggen Ihrer Kubernetes-Anwendung direkt über die IDE. |
| k8s: bereitstellen | INSTALLIEREN | Das Verzweigen der Installationsaufgabe und das Anwenden der generierten Manifeste auf den Kubernetes-Cluster ist genau das gleiche wie für die Anwendungstask. |
| k8s: zuschauen | PAKET | Automatische Hot-Bereitstellung einer Anwendung durch Verfolgung ihres Namespace. |
Bereitstellen von Java-Anwendungen für Red Hat OpenShift mithilfe des OpenShift Maven-Plugins
Um die Anwendung aus unserem Beispiel auf der Red Hat OpenShift-Plattform bereitzustellen, verwenden wir das OpenShift Maven- Plugin . Der einzige Unterschied besteht darin, dass sich das Task-Präfix von k8s zu oc ändert. Standardmäßig macht das Plugin Kubernetes Maven Docker- Slorki und Plug OpenShift Maven - Assembly S2i . Wir nehmen keine Änderungen an unserem Projekt vor, außer das Entfernen der Eigenschaft jkube.generator.name, da dies beim Senden an die Registrierung nicht erforderlich ist (während der Erstellungsphase platziert OpenShift das Image in der internen Registrierung). Und das wird auf dem Bildschirm angezeigt, wenn wir unser Beispiel ausführen, in dem wir übrigens Zielaufgaben nicht einzeln, sondern 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 : $
Videoanleitung
Weitere Informationen zur Vereinfachung der Kubernetes-Entwicklung mit Eclipse JKube finden Sie im Video-Tutorial zur schnellen Bereitstellung einer einfachen Spring Boot-Anwendung auf Minikube:
Fazit
In diesem Artikel haben wir gezeigt, wie der Eclipse JKube dem Java-Entwickler das Leben bei der Arbeit mit Kubernetes erleichtert. Weitere Informationen zum Eclipse JKube finden Sie auf der Projektsite und auf GitHub .