25 jaar geleden kwam Java in de breedte van de programmeursgemeenschap, om uiteindelijk een van die fundamenten te worden waarop applicatiestacks zijn gebouwd. Echter, vandaag de dag zijn veel mensen en organisaties, die jarenlang trouw zijn gebleven aan Java, bezig met de overstap of overwegen over te stappen naar het platform of afgeleiden daarvan, zoals of .
Helaas heeft Kubernetes een steile leercurve en voegt het een extra operationeel niveau toe aan het ontwikkelingsproces dat bekend is voor Java-programmeurs. Vandaag vertellen we je hoe je , kunt gebruiken om deze extra taken met Kubernetes en containers te vereenvoudigen, en tegelijkertijd een pijnloze migratie naar een cloudplatform te waarborgen, met behoud van het vertrouwde Java-ecosysteem. Bovendien laten we zien hoe je Java-applicaties kunt implementeren op het OpenShift-platform met behulp van de OpenShift Maven-plugin.
Het traditionele Java-ontwikkelingsproces
Het traditionele ontwikkelingsproces (Figuur 1) houdt in dat de ontwikkelaar code schrijft, vervolgens deployment-eenheden creƫert in de vorm van JAR- of WAR-bestanden, en deze bestanden daarna op een webserver of applicatieserver implementeert en uitvoert. Hiervoor wordt meestal Maven vanuit de commandoregel toegepast of gebruiken ontwikkelaars een IDE zoals IntelliJ of Eclipse om applicaties te coderen en te verpakken. Ontwikkelaars zijn eraan gewend om wijzigingen in de code aan te brengen en alles grondig te testen, voordat ze de code vastleggen en deze naar een versiebeheersysteem verzenden.
Figuur 1. Traditioneel Java-ontwikkelingsproces.
Het Java-ontwikkelingsproces voor de cloud
Bij de overstap naar cloudapplicaties worden Kubernetes en toegevoegd aan het bovenstaande schema. Daarom moet de ontwikkelaar nu Java-applicaties verpakken in en Kubernetes-manifesten creƫren die deze beelden beschrijven. Deze manifesten worden vervolgens toegepast op de productie-server waarop Kubernetes draait. Kubernetes haalt op zijn beurt deze beelden uit de register en implementeert applicaties volgens de configuraties die we in de manifesten hebben beschreven, die meestal in YAML-bestanden worden weergegeven.
De metamorfose van het traditionele Java-ontwikkelingsproces bij de overgang naar de cloud is weergegeven in Figuur 2.
Figuur 2. Het Java-ontwikkelingsproces voor de cloud.
Eclipse JKube
De overstap naar Kubernetes voegt nog een operationeel niveau toe aan het ontwikkelingsproces, en veel ontwikkelaars voelen zich hierdoor nerveus, omdat ze zich willen concentreren op hun kernwerk ā de applicatielogica ā in plaats van op hoe ze deze moeten implementeren. En hier komt , dat ontwikkelaars in staat stelt om hun bibliotheken en plugins te gebruiken ( samen met of ), zodat ze moeiteloos kunnen omgaan met taken die verband houden met containers en Kubernetes, volgens de diagram op fig. 2.
In de resterende delen van dit artikel zullen we laten zien hoe we het proces van Java-ontwikkeling in een Kubernetes-omgeving kunnen vereenvoudigen door gebruik te maken van Eclipse JKube met de Kubernetes Maven Plugin.
Het ontwikkelproces voor de cloud met behulp van Eclipse JKube
Laten we een iets gemodificeerd schema van Java-ontwikkeling voor de cloud bekijken, zoals weergegeven in fig. 2, en Eclipse JKube en de Kubernetes Maven Plugin introduceren, zoals getoond in fig. 3.
Fig. 3. Het Java-ontwikkelingsproces voor de cloud met behulp van Eclipse JKube.
Zoals we zien, worden alle interacties met Kubernetes en containers (in het diagram in het rood gemarkeerd) vervangen door de standaard goal-taken van Eclipse JKube, die zijn opgesomd in tabel 1.
Tabel 1. Standaard taken van Eclipse JKube.
Task
Fase
Omschrijving
PRE_INTEGRATION_TEST
Het bouwen van docker-images
INSTALL
Het pushen van docker-images naar de registry
PROCESS_RESOURCES
Het genereren van K8s-manifesten
COMPILE
Het toepassen van de gegenereerde manifesten op K8s
UNDEPLOY
Het verwijderen van K8s-resources die zijn geĆÆmplementeerd via k8s:apply en k8s:deploy
Opmerking: Als je niet wilt dat de taken deze strikte standaarden (opinionated defaults) gebruiken, kun je Eclipse JKube handmatig configureren, omdat het configuratie via ondersteunt en .
Laten we nu voorbeelden bekijken van het gebruik van Eclipse JKube en de Kubernetes Maven Plugin bij het werken met applicaties.
Een Java-applicatie implementeren in Kubernetes met behulp van Eclipse JKube
In dit voorbeeld zullen we een eenvoudige Java-applicatie implementeren in een cluster met behulp van Eclipse JKube. Met de Kubernetes Maven Plugin kunnen we de implementatieparameters instellen zonder enige configuratie te hoeven schrijven.
Als voorbeeldapplicatie gebruiken we , die JSON-output geeft op het endpoint \/random:
~\/work\/repos\/eclipse-jkube-demo-project : $ curl localhost:8080\/random | jq .
% Totaal % Ontvangen % Overdracht Gemiddelde Snelheid Tijd Tijd Tijd Huidig
Dload Upload Totaal Besteed Over Snelheid
100 45 0 45 0 0 818 0 --:--:-- --:--:-- --:--:-- 818
{
"id": "e80a4d10-c79b-4b9a-aaac-7c286cb37f3c"
}
Stap 1. Kubernetes Maven Plugin uploaden
Kubernetes Maven Plugin bevindt zich in de repository . Om Eclipse JKube te gebruiken, moet je de Kubernetes Maven Plugin aan je pom.xml toevoegen als afhankelijkheid:
<plugin>
<groupId>org.eclipse.jkube<\/groupId>
<artifactId>kubernetes-maven-plugin<\/artifactId>
<version>${jkube.version}<\/version>
<\/plugin>
Als in plaats van puur Kubernetes OpenShift wordt gebruikt, dan wordt pom.xml als volgt aangepast:
<plugin>
<groupId>org.eclipse.jkube<\/groupId>
<artifactId>openshift-maven-plugin<\/artifactId>
<version>${jkube.version}<\/version>
<\/plugin>
Stap 2. Docker-image bouwen
Het JAR-bestand van de applicatie kan worden gebouwd met het commando mvn package, en vervolgens kan de goal-taak mvn k8s:build worden gebruikt om het docker-image van deze applicatie te bouwen. Let op dat we de standaard afbeeldingnaam hebben overschreven met dit eigenschap:
<jkube.generator.name>docker.io\/rohankanojia\/random-generator:${project.version}<\/jkube.generator.name>
Voordat we de afbeelding bouwen, moeten we ervoor zorgen dat de docker-daemon correct is geƫxposeerd. Dit kan met het volgende commando:
$ eval $(minikube docker-env)
Vervolgens voeren we het commando mvn k8s:build in, en dit is wat we op het scherm zien tijdens het bouwen van het docker-image met behulp van de build-taak van Eclipse JKube:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:build
[INFO] Scannen naar projecten...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Bouwen van random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] k8s: Draait in Kubernetes-modus
[INFO] k8s: Docker-image bouwen in Kubernetes-modus
[INFO] k8s: Generator spring-boot draaien
[INFO] k8s: spring-boot: Gebruik Docker-image quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 als basis \/ bouwer
[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] BOUW SUCCESVOL
[INFO] ------------------------------------------------------------------------
[INFO] Totale tijd: 5.053 s
[INFO] Voltooid op: 2020-08-10T11:28:23+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $
Stap 3. Afbeelding naar docker registry sturen
Nadat we het docker-image hebben gebouwd met de ingeschakelde push-registry (in ons geval is dit docker.io), kunnen we deze afbeelding naar de registry sturen. Dit is wat op het scherm verschijnt nadat we Eclipse JKube hebben gevraagd om de push-taak mvn k8s:push uit te voeren:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:push
[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: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 : $
Na het verzenden van de afbeelding moeten we controleren of deze in de register is gekomen. In ons geval zien we het gewoon in Docker Hub, zoals weergegeven in Figuur 4.
Figuur 4. De afbeelding die naar het register is verzonden, verschijnt in Docker Hub.
Stap 4. We genereren manifesten voor Kubernetes-resources voor de applicatie
Dus, we hebben de applicatie-afbeelding samengesteld, nu moeten we Kubernetes-manifesten schrijven. Hiervoor heeft Eclipse JKube een taak die harde manifesten van resources genereert, gebaseerd op het onderliggende Java-framework (, , Vert.x of een ander). Ook is het mogelijk om het manifest in te stellen met behulp van een configuratie-XML-bestand en de raw-fragmenten (fragmenten van de vereiste resource-manifesten) in de map van de applicatie src\/main\/jkube te plaatsen. In dat geval zal uw configuratie worden opgenomen in de gegenereerde manifesten.
In ons voorbeeld laten we alles zoals het is, en daarom genereert Eclipse JKube een manifest voor de standaard uitrol en voor de service met het type ClusterIP. Daarna zullen we het service-manifest aanpassen om het servicetype te wijzigen naar NodePort. Het standaardgedrag kan worden overschreven met de volgende eigenschap:
NodePort
Dit is hoe de uitvoer op het scherm eruitziet nadat we Eclipse JKube hebben gevraagd om de resource-taak mvn k8s:resource uit te voeren.
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:resource
[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: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 : $
Stap 5. De applicatie implementeren in de Kubernetes-cluster
Nu zijn we er helemaal klaar voor om de implementatie van de applicatie uit te voeren: we hebben het beeld gegenereerd en vervolgens automatisch de resource-manifesten gegenereerd. We hoeven dit nu alleen nog maar toe te passen op de Kubernetes-cluster. Voor het implementeren van de applicatie kan je natuurlijk het commando kubectl apply -f gebruiken, maar de plugin kan dit ook voor ons doen. Dit is wat er op het scherm verschijnt nadat we Eclipse JKube hebben gevraagd de apply-taak mvn k8s:apply uit te voeren:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:apply
[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: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 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 .
% 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"
}
Stap 6. Voer de undeploy van de applicatie uit in het Kubernetes-cluster
Hiervoor gebruiken we de undeploy-taak, die eenvoudigweg alle bronnen verwijdert die in de vorige stap zijn toegepast, namelijk bij het uitvoeren van de apply-taak. Dit is wat we op het scherm zullen zien nadat we Eclipse JKube vragen om de undeploy-taak mvn k8s:undeploy uit te voeren:
~\/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 : $
Wat kan er nog meer gedaan worden met Eclipse JKube
We hebben de belangrijkste doelen van de Eclipse JKube en Kubernetes Maven Plugin besproken, die het ontwikkelen van Java-toepassingen voor het Kubernetes-platform vergemakkelijken. Als u niet voortdurend deze doelen vanaf het toetsenbord wilt invoeren, kunt u ze in de configuratie van de plugin opnemen, bijvoorbeeld zo:
org.eclipse.jkube
kubernetes-maven-plugin
${project.version}
build
resource
apply
Het moet worden opgemerkt dat we in dit artikel niet alle doelen hebben behandeld die beschikbaar zijn in Eclipse JKube en Kubernetes Maven Plugin, en daarom geven we in Tabel 2 een lijst met aanvullende doelen die ook nuttig voor u kunnen zijn.
Tabel 2. Aanvullende doelen van Eclipse JKube.
Task
Fase
Omschrijving
VALIDATE
Logs ophalen van een applicatie die op Kubernetes draait.
PACKAGE
Het openen van de debug-poort om de applicatie die op Kubernetes draait, direct vanuit de IDE te debuggen.
INSTALL
Een fork maken voor de Install-taak en de gegenereerde manifesten toepassen op het Kubernetes-cluster, net zoals bij de apply-taak.
PACKAGE
Automatische hot deployment van de applicatie door zijn namespace te volgen.
Java-applicaties implementeren op Red Hat OpenShift met behulp van de OpenShift Maven Plugin.
Voor het implementeren van de applicatie uit ons voorbeeld op het Red Hat OpenShift-platform passen we de plugin . Het enige verschil is dat de taak-prefix verandert van k8s naar oc. Standaard maakt de Kubernetes Maven plugin -builds, terwijl de OpenShift Maven plugin -builds maakt. . We brengen geen wijzigingen aan in ons project, behalve het verwijderen van de eigenschap jkube.generator.name, omdat dit niet nodig is bij het pushen naar de registry (tijdens de build-fase plaatst OpenShift de afbeelding in zijn interne registry). En dit is wat er op het scherm verschijnt wanneer we ons voorbeeld uitvoeren, waarin we trouwens alle doel-taken in Ć©Ć©n keer uitvoeren:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn oc:build oc:resource oc:apply
[INFO] Scanning for projects...
[INFO]
[INFO] ---------------------------------------------
[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 : $
Video-tutorial
Om meer te leren over hoe je Kubernetes-ontwikkeling kunt vereenvoudigen met Eclipse JKube, bekijk de video-tutorial voor het snel implementeren van een eenvoudige Spring Boot-applicatie op Minikube:
Conclusie
In dit artikel hebben we laten zien hoe Eclipse JKube het leven van Java-ontwikkelaars gemakkelijker maakt bij het werken met Kubernetes. Meer informatie over Eclipse JKube vind je op en op .
Bron: habr.com
