25 jaar gelede het Java die hoofstroom van programmering betree en uiteindelik een van die kernelemente geword waarom toepassingstapels gebou word. Vandag is baie mense en organisasies wat al jare lank lojaal aan Java is egter besig om te migreer of te oorweeg om na die platform te migreer. of sy afgeleides soos of .
Ongelukkig het Kubernetes 'n steil leerkurwe en stel nog 'n operasionele laag in die ontwikkelingsproses bekend waaraan Java-programmeerders gewoond is. Vandag sal ons jou vertel hoe om te gebruik , om hierdie bykomende bedrywighede wat met Kubernetes en houers geassosieer word te vereenvoudig, en 'n pynlose migrasie na die wolkplatform te verseker terwyl die bekende Java-ekosisteem in stand gehou word. Boonop sal ons wys hoe om Java-toepassings op die OpenShift-platform te ontplooi met behulp van die OpenShift Maven-inprop.
Tradisionele Java-ontwikkelingsproses
Tradisionele ontwikkelingsproses (Figuur 1) behels dat die ontwikkelaar kode skryf, dan ontplooiingseenhede in die vorm van JAR- of WAR-lêers skep, en dan hierdie lêers op 'n web- of toepassingbediener ontplooi en laat loop. Die belangrikste manier om dit te doen is om Maven vanaf die opdragreël te gebruik of 'n IDE soos IntelliJ of Eclipse te gebruik om die toepassings te kodeer en te verpak. Ontwikkelaars is gewoond daaraan om kodeveranderings aan te bring en alles deeglik te toets voordat die kode toegepas word en dit aan weergawebeheer voorgelê word.
Rys. 1. Tradisionele Java-ontwikkelingsproses.
Java-ontwikkelingsproses vir die wolk
Wanneer oorgeskakel word na wolktoepassings, Kubernetes en . Daarom moet die ontwikkelaar nou Java-toepassings inpak en skep Kubernetes-manifeste wat hierdie beelde beskryf. Hierdie manifeste word dan toegepas op die produksiebediener wat Kubernetes gebruik. Op sy beurt neem Kubernetes hierdie beelde uit die register en ontplooi toepassings volgens die konfigurasies wat ons in manifeste geskryf het, wat gewoonlik YAML-lêers is.
Die metamorfose van die tradisionele Java-ontwikkelingsproses in die oorgang na die wolk word in Fig. 2.
Rys. 2. Java-ontwikkelingsproses vir die wolk.
Verduistering JKube
Om na Kubernetes te migreer, voeg nog 'n operasionele laag by die ontwikkelingsproses, en baie ontwikkelaars is senuweeagtig daaroor omdat hulle op hul kernwerk wil fokus - die toepassingslogika - eerder as hoe om dit te ontplooi. En dit is waar dit ter sprake kom. , wat ontwikkelaars toelaat om hul biblioteke en inproppe te gebruik ( saam met of ) om moeiteloos houer- en Kubernetes-verwante bewerkings uit te voer deur die diagram in Figuur te volg. 2.
In die res van hierdie artikel sal ons jou wys hoe om die Java-ontwikkelingsproses in die Kubernetes-omgewing te vereenvoudig deur Eclipse JKube met die Kubernetes Maven-inprop te gebruik.
Wolkontwikkelingsproses met behulp van Eclipse JKube
Kom ons kyk na 'n effens gewysigde Java-ontwikkelingskema vir die wolk vanaf Fig. 2, en stel Eclipse JKube en Kubernetes Maven Plugin daarin bekend, soos in Fig. 3.
Rys. 3. Java-ontwikkelingsproses vir die wolk met Eclipse JKube.
Soos ons kan sien, word alle bewerkings vir interaksie met Kubernetes en houers (in rooi in die diagram uitgelig) vervang deur verstek Eclipse JKube-doeltake, wat in tabel gelys word. 1.
Tafel 1. Eclipse JKube verstek take.
Taak
Verhoog
Beskrywing
PRE_INTEGRATION_TEST
Bou docker-beelde
INSTALLEER
Laai docker-beelde op na die register
PROCESS_RESOURCES
Genereer K8s manifesteer
SAMESTEL
Die toepassing van gegenereerde manifeste op K8's
ONDERWERK
Die verwydering van K8s-hulpbronne wat met behulp van k8s:apply en k8s:deploy ontplooi is
Let wel: As jy nie wil hê dat take hierdie eiesinnige verstekstellings moet gebruik nie, kan jy Eclipse JKube self vir jouself opstel, aangesien dit konfigurasie ondersteun via и .
Kom ons kyk nou na voorbeelde van die gebruik van Eclipse JKube en Kubernetes Maven Plugin wanneer jy met toepassings werk.
Ontplooi 'n Java-toepassing op Kubernetes met Eclipse JKube
In hierdie voorbeeld sal ons 'n eenvoudige Java-toepassing op 'n groepie ontplooi met Eclipse JKube. Deur die Kubernetes Maven-inprop te gebruik, kan ons ontplooiingsparameters stel sonder om enige konfigurasie te hoef te skryf.
As 'n voorbeeldtoepassing wat ons gebruik , wat JSON-uitset by die /random eindpunt produseer:
~/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"
}
Stap 1. Laai Kubernetes Maven Plugin af
Kubernetes Maven Plugin is in die bewaarplek . Om Eclipse JKube te gebruik, moet jy die Kubernetes Maven-inprop by jou pom.xml voeg as 'n afhanklikheid:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>kubernetes-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
As OpenShift gebruik word in plaas van suiwer Kubernetes, dan word pom.xml soos volg gewysig:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>openshift-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Stap 2. Bou die docker-beeld
Die toepassing se JAR-lêer kan met die mvn-pakketopdrag gebou word, en dan kan die mvn-doeltaak k8s:build gebruik word om 'n docker-beeld van die toepassing te bou. Let daarop dat ons die verstek prentnaam met hierdie eienskap vervang het:
<jkube.generator.name>docker.io/rohankanojia/random-generator:${project.version}</jkube.generator.name>
Voordat jy die prent bou, moet jy seker maak dat die docker-demoon korrek blootgestel is. Dit kan gedoen word met die volgende opdrag:
$ eval $(minikube docker-env)
Dan voer ons die mvn k8s:build-opdrag in, en dit is wat ons op die skerm sal sien wanneer ons die docker-beeld bou met die Eclipse JKube-boutaak:
~/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 : $
Stap 3. Laai die prent op na die docker-register
Nadat ons die docker-beeld gebou het met die push-register opgestel (in ons geval is dit docker.io), kan ons hierdie beeld na die register stuur. Dit is wat vertoon sal word nadat ons Eclipse JKube gevra het om die mvn k8s:push push-taak uit te voer:
~/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 : $
Nadat u die prent gestuur het, moet u seker maak dat dit in die register ingesluit is. In ons geval sien ons dit eenvoudig in Docker Hub, soos in Fig. 4.
Rys. 4. Die prent wat na die register gestuur is, het in Docker Hub verskyn.
Stap 4. Genereer Kubernetes-hulpbronmanifeste vir die toepassing
Dus, ons het die toepassingsbeeld versamel, nou moet ons Kubernetes-manifeste skryf. Om dit te doen, het Eclipse JKube 'n taak wat rigiede hulpbronmanifeste genereer gebaseer op die onderliggende Java-raamwerk (, , Vert.x of 'n ander). U kan ook die manifes aanpas deur 'n XML-konfigurasielêer te gebruik en rou fragmente (fragmente van die vereiste hulpbronmanifes) in die toepassingslêergids src/main/jkube te plaas. In hierdie geval sal u konfigurasie na die gegenereerde manifeste opgelaai word.
In ons voorbeeld laat ons alles soos dit is, en daarom genereer Eclipse JKube 'n manifes vir die verstek ontplooiing en vir die diens met tipe ClusterIP. En eers dan verander ons die diensmanifes om die dienstipe na NodePort te verander. U kan die verstekgedrag ignoreer deur die volgende eienskap te gebruik:
<jkube.enricher.jkube-service.type>NodePort</jkube.enricher.jkube-service.type>
Dit is hoe die skermuitset lyk nadat ons Eclipse JKube gevra het om die mvn k8s:hulpbron-hulpbrontaak uit te voer.
~/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 : $
Stap 5. Ontplooi die toepassing na die Kubernetes-kluster
Nou is ons gereed om die toepassing te ontplooi: ons het sy beeld gegenereer en dan outomaties hulpbronmanifeste gegenereer. Al wat nou oorbly, is om dit alles op die Kubernetes-kluster toe te pas. Om die toepassing te ontplooi, kan u natuurlik die kubectl application -f-opdrag gebruik, maar die inprop kan dit vir ons doen. Dit is wat op die skerm sal verskyn nadat ons Eclipse JKube gevra het om die mvn k8s:apply application-taak uit te voer:
~/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"
}
Stap 6. Ontplooi toepassings van die Kubernetes-kluster
Om dit te doen, word die ontplooiingstaak gebruik, wat eenvoudig alle hulpbronne verwyder wat in die vorige stap toegepas is, dit wil sê wanneer die toepassingstaak uitgevoer word. Dit is wat ons op die skerm sal sien nadat ons Eclipse JKube gevra het om die mvn k8s:undeploy undeploy taak uit te voer:
~/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 : $
Wat anders kan jy doen met Eclipse JKube
Dus, ons het gekyk na die hoofdoeltake van Eclipse JKube en Kubernetes Maven Plugin, wat die ontwikkeling van Java-toepassings vir die Kubernetes-platform vergemaklik. As jy nie voortdurend hierdie take vanaf die sleutelbord wil invoer nie, kan jy dit byvoorbeeld in die inpropkonfigurasie skryf, soos volg:
<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>
Daar moet gesê word dat ons in hierdie artikel nie al die doeltake wat in Eclipse JKube en Kubernetes Maven Plugin is, oorweeg het nie, daarom verskaf ons in Tabel 2 'n lys van bykomende take wat ook vir jou nuttig kan wees.
Tafel 2. Bykomende Eclipse JKube doelwit take.
Taak
Verhoog
Beskrywing
GELDIG
Ontvang logboeke van 'n toepassing wat op Kubernetes loop.
PAKKET
Maak 'n ontfoutpoort oop sodat jy jou toepassing wat op Kubernetes loop, direk vanaf die IDE kan ontfout.
INSTALLEER
Die skep van 'n vurk vir die installeringstaak en die toepassing van die gegenereerde manifeste op die Kubernetes-kluster op dieselfde manier as in die geval van die toepassingstaak.
PAKKET
Outomatiese warm ontplooiing van 'n toepassing deur sy naamruimte na te spoor.
Ontplooi Java-toepassings op Red Hat OpenShift deur die OpenShift Maven-inprop te gebruik
Om die toepassing van ons voorbeeld op die Red Hat OpenShift-platform te ontplooi, gebruik ons die inprop . Die enigste verskil sal wees dat die taakvoorvoegsel van k8s na oc sal verander. By verstek doen die Kubernetes Maven-inprop -samestellings, en die OpenShift Maven-inprop - samestellings . Ons maak geen veranderinge aan ons projek nie, behalwe om die jkube.generator.name-eienskap te verwyder, aangesien dit nie vereis word wanneer na die register gedruk word nie (Gedurende die boufase plaas OpenShift die prent in sy interne register). En dit is wat op die skerm sal verskyn wanneer ons ons voorbeeld uitvoer, waarin ons, terloops, doeltake nie een op 'n slag uitvoer nie, maar almal op een slag:
~/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 : $
Video les
Om meer te wete te kom oor hoe om Kubernetes-ontwikkeling makliker te maak met Eclipse JKube, kyk na hierdie video-tutoriaal oor hoe om vinnig 'n eenvoudige Spring Boot-toepassing op Minikube te ontplooi:
Gevolgtrekking
In hierdie artikel het ons gewys hoe Eclipse JKube die lewe vir 'n Java-ontwikkelaar makliker maak wanneer hulle met Kubernetes werk. Meer inligting oor Eclipse JKube kan gevind word by en .
Bron: will.com