Zhvillimi i aplikacioneve Java për Kubernetes duke përdorur Eclipse JKube

25 vjet më parë Java hyri në masat e zhvilluesve, duke u bërë një nga ato shtylla rreth të cilave ndërtohen steka aplikacionesh. Por sot, shumë individë dhe organizata, që për vite të tëra kanë mbetur besnikë ndaj Java, janë angazhuar në kalimin ose po mendojnë të kalojnë në platformën Kubernetes ose degët e saj, siç janë Red Hat OpenShift ose Amazon EKS.

Fatkeqësisht, Kubernetes ka një kurbë të pjerrët mësimi dhe paraqet një tjetër nivel operativ në procesin e zhvillimit që Java-programuesit e njohin. Sot do të flasim për mënyrën se si të përdorim Eclipse JKube, për të lehtësuar këto operacione shtesë të lidhura me Kubernetes dhe kontejnerët, si dhe për të siguruar një migrim pa dhimbje në platformën cloud duke mbajtur ekosistemin e njohur të Java. Madje, ne do të tregojmë se si të publikoni aplikacione Java në platformën OpenShift duke përdorur plugin-in OpenShift Maven.

Procesi tradicional i zhvillimit Java

Procesi tradicional i zhvillimit Java (Fig.1) nënkupton që zhvilluesi shkruan kodin, pastaj krijon njësi implementimi në formën e skedarëve JAR ose WAR, dhe më pas i vendos dhe i lanson këto skedare në serverin e internetit ose serverin e aplikacioneve. Kryesisht, për këtë përdoret Maven nga komandat e linjës ose përdoren IDE-të, si IntelliJ ose Eclipse, për të koduar dhe paketuar aplikacione. Zhvilluesit janë të zakonshëm të bëjnë ndryshime në kod dhe të testojnë gjithçka me kujdes, përpara se të ruajnë kodin dhe ta dërgojnë atë në sistemin e menaxhimit të versioneve.

Fig. 1. Procesi tradicional i zhvillimit të Java.

Procesi i zhvillimit të Java për cloud

Me kalimin në aplikacionet cloud, në diagramin e përshkruar më sipër shtohen Kubernetes dhe kontejnerë. Prandaj, tani zhvilluesi duhet të paketoje aplikacionet Java në imazhe konteiner dhe të krijojë manifese Kubernetes që përshkruajnë këto imazhe. Pastaj këto manifese aplikohen në serverin e prodhimit, ku funksionon Kubernetes. Nga ana tjetër, Kubernetes merr këto imazhe nga regjistri dhe implementon aplikacionet sipas konfigurimeve që kemi përshkruar në manifese, të cilat zakonisht janë skedarë YAML.

Metamorfoza e procesit tradicional të zhvillimit Java gjatë kalimit në cloud shfaqet në Fig. 2.

Fig. 2. Procesi i zhvillimit Java për cloud.

Eclipse JKube

Kalimi në Kubernetes shton një nivel tjetër operacional në procesin e zhvillimit, dhe shumë zhvillues e ndjejnë këtë si një stres, pasi ata duan të fokusohen në punën e tyre kryesore – logjikën e aplikacioneve – në vend të mënyrës se si t’i publikojnë ato. Këtu hyjnë në lojë Eclipse JKube, i cili lejon zhvilluesit të përdorin bibliotekat dhe pluginët e tyre (JKube Kit në bashkëpunim me Kubernetes Maven Plugin ose OpenShift Maven Plugin), për të realizuar pa mundim operacionet lidhur me kontejnerët dhe Kubernetes, duke ndjekur skemën në Fig. 2.

Në pjesën tjetër të këtij artikulli do të tregojmë si të thjeshtojmë procesin e zhvillimit Java në mjedisin Kubernetes, duke përdorur Eclipse JKube me pluginin Kubernetes Maven Plugin.

Procesi i zhvillimit për cloud duke përdorur Eclipse JKube

Le të shqyrtojmë një skemë të modifikuar të zhvillimit Java për cloud me Fig. 2, duke futur Eclipse JKube dhe Kubernetes Maven Plugin, siç tregohet në Fig. 3.

Fig. 3. Procesi i zhvillimit Java për cloud duke përdorur Eclipse JKube.

Si e shohim, të gjitha operacionet e ndërveprimit me Kubernetes dhe kontejnerët (në diagram janë theksuar me të kuqe) zëvendësohen me detyrat e paracaktuara të Eclipse JKube, të cilat janë listuar në Tabela 1.

Tabela 1. Detyrat e Eclipse JKube të paracaktuara.

Detyra
Shkalla
Përshkrimi

k8s:build
PRE_INTEGRATION_TEST
Ndërtimi i imazheve docker

k8s:push
INSTALLO
Dërgimi i imazheve docker në regjistër

k8s:resource
PROCESS_RESOURCES
Generimi i manifestëve K8s

k8s:apply
KOMPILO
Përveç aplikimit të manifestëve të gjeneruar në K8s

k8s:undeploy
ANULLO
Fshirja e burimeve K8s që janë vendosur përmes k8s:apply dhe k8s:deploy

Shënim: Nëse nuk dëshironi që detyrat të përdorin këto paracaktime të forta (opinionated defaults), mund të konfiguroni manually Eclipse JKube për veten tuaj, duke e ditur se ai mbështet konfigurimin përmes XML dhe burimet.

Tani le të shqyrtojmë shembujt e përdorimit të Eclipse JKube dhe Kubernetes Maven Plugin kur punojmë me aplikacione.

Vendosim një aplikacion Java në Kubernetes duke përdorur Eclipse JKube

Në këtë shembull, ne do të vendosim një aplikacion të thjeshtë Java në klastrin Minikube duke përdorur Eclipse JKube. Duke përdorur Kubernetes Maven Plugin, ne mund të caktuar parametrat e vendosjes pa përshkruar ndonjë konfigurim.

Si një shembull aplikacioni ne përdorim një gjenerator të thjeshtë numrash të rastit, i cili jep JSON-output në endpoint-in /random:

~~/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"
}

Hapi 1. Ngarko Kubernetes Maven Plugin

Kubernetes Maven Plugin ndodhet në repositor Maven Central Repository. Për të përdorur Eclipse JKube, duhet të shtoni Kubernetes Maven Plugin në pom.xml si varësi:

org.eclipse.jkube
     kubernetes-maven-plugin
     ${jkube.version}

Nëse përdoret OpenShift në vend të Kubernetes të pastër, atëherë pom.xml modifikohet si më poshtë:

org.eclipse.jkube
     openshift-maven-plugin
     ${jkube.version}

Hapi 2. Ndërto imazhin docker

Skedari JAR i aplikacionit mund të ndërtohet me komandën mvn package, dhe pastaj mund të përdoret detyra goal mvn k8s:build për të ndërtuar imazhin docker të këtij aplikacioni. Vini re se ne kemi rishkruar emrin e imazhit të paracaktuar me këtë pronë:

docker.io/rohankanojia/random-generator:${project.version}

Para të mbledhësh imazhin, duhet të sigurohesh që docker-demon është i ekspozuar në mënyrë korrekte. Këtë mund ta bësh me komandën e mëposhtme:

$ eval $(minikube docker-env)

Pastaj, japim komandën mvn k8s:build, dhe kjo është ajo që do të shohim në ekran gjatë ndërtimit të imazhit docker me ndihmën e detyrës build të Eclipse JKube:

~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:build
[INFO] Skanoq për projekte...
[INFO] 
[INFO] ---------------------------------------------
[INFO] Ndërtimi i random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] k8s: Po funksionon në modalitetin Kubernetes
[INFO] k8s: Po ndërton imazhin Docker në modalitetin Kubernetes
[INFO] k8s: Po funksionon gjeneratori spring-boot
[INFO] k8s: spring-boot: Duke përdorur imazhin Docker quay.io/jkube/jkube-java-binary-s2i:0.0.7 si bazë / ndërtues
[INFO] k8s: [docker.io/rohankanojia/random-generator:0.0.1] "spring-boot": Krijuar docker-build.tar në 251 milisekonda
[INFO] k8s: [docker.io/rohankanojia/random-generator:0.0.1] "spring-boot": Ndërtuar imazhi sha256:a20e5
[INFO] ------------------------------------------------------------------------
[INFO] NDËRTIMI ME SUKSES
[INFO] ------------------------------------------------------------------------
[INFO] Koha totale:  5.053 s
[INFO] Mbaroi në: 2020-08-10T11:28:23+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $

Hapi 3. Dërgojmë imazhin në regjistrin docker

Pas pas përfundimit të ndërtimit të imazhit docker me regjistrin e vendosur të push-it (në rastin tonë, docker.io), mund ta dërgojmë këtë imazh në regjistër. Këtu është ajo që do të shfaqet në ekran pasi t'i kërkojmë Eclipse JKube të kryejë detyrën e push-it mvn k8s:push:

~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:push
[INFO] Skanojmë për projekte...
[INFO] 
[INFO] ---------------------------------------------
[INFO] Duke ndërtuar random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:push (default-cli) @ random-generator ---
[INFO] k8s: Po funksionon në modalitetin Kubernetes
[INFO] k8s: Duke ndërtuar imazhin Docker në modalitetin Kubernetes
[INFO] k8s: Po ekzekuton gjeneratorin spring-boot
[INFO] k8s: spring-boot: Duke përdorur imazhin Docker quay.io/jkube/jkube-java-binary-s2i:0.0.7 si bazë / ndërtues
[INFO] k8s: Dërgimi i imazhit i referohet regjistrit [docker.io/rohankanojia/random-generator]
5dcd9556710f: Shtresa ekziston tashmë 
b7139ad07aa8: Shtresa ekziston tashmë 
b6f081e4b2b6: Shtresa ekziston tashmë 
d8e1f35641ac: Shtresa ekziston tashmë 
[INFO] k8s: 0.0.1: digest: sha256:9f9eda2a13b8cab1d2c9e474248500145fc09e2922fe3735692f9bda4c76002d madhësia: 1162
[INFO] k8s: Dërguar docker.io/rohankanojia/random-generator:0.0.1 në 7 sekonda 
[INFO] ------------------------------------------------------------------------
[INFO] NDËRTIMI ME SUKSES
[INFO] ------------------------------------------------------------------------
[INFO] Kohë totale:  11.222 s
[INFO] Përfundoi në: 2020-08-10T11:35:37+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $ 

Pas pastrimit të imazhit, duhet të kontrolloni se ai ka përfunduar në regjistrin. Në rastin tonë, ne thjesht e shohim atë në Docker Hub, siç tregohet në Fig. 4.

Fig. 4. Imazhi i dërguar në regjistër u shfaq në Docker Hub.

Hapi 4. Gjenerimi i manifestave të burimeve Kubernetes për aplikacionin

Pra, ne kemi ndërtuar imazhin e aplikacionit, tani duhet të shkruajmë manifestet e Kubernetes. Për këtë, në Eclipse JKube ka një detyrë që gjeneron manifestet e burimeve, duke u bazuar në çadrën Java të përdorur (Spring Boot, Quarkus, Vert.x ose ndonjë tjetër). Gjithashtu, është e mundur të konfigurohet manifesti, duke përdorur një skedar XML konfigurimi dhe duke vendosur fragmente të papërpunuara (fragmente të manifestit të kërkuar të burimeve) në dosjen e aplikacionit src/main/jkube. Në këtë rast, konfigurimi juaj do të ngarkohet në manifestet e gjeneruara.

Në shembullin tonë, ne e lëmë gjithçka siç është, dhe kështu Eclipse JKube gjeneron një manifest për një shpërndarje default dhe për shërbimin me llojin ClusterIP. Pastaj ne e modifikojmë manifestin e shërbimit për të ndryshuar llojin e shërbimit në NodePort. Të dhënat e sjelljes default mund të ri-definohen duke përdorur pronën e mëposhtme:

NodePort

Kyky është shfaqja e ekranit pas kërkesës që Eclipse JKube të realizojë detyrën e resurseve mvn k8s:resource.

~/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 : $

Hapi 5. Ne zhvillojmë aplikimin në klasterin Kubernetes

Pra, gjithçka është gati për të realizuar zhvillimin e aplikacionit: ne kemi gjeneruar imazhin e tij dhe më pas kemi gjeneruar automatikisht manifestet e burimeve. Tani mbetet vetëm të aplikojmë të gjitha këto në klasterin Kubernetes. Për zhvillimin e aplikacionit, natyrisht, mund të përdorim komandën kubectl apply -f, por plugin-i mund ta bëjë këtë për ne. Këtu është se çfarë do të shfaqet në ekran pas kërkesës sonë për Eclipse JKube për të realizuar detyrën apply mvn k8s:apply:

~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:apply
[INFO] Skanning për projekte...
[INFO] 
[INFO] ---------------------------------------------
[INFO] Ndërtimi i random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] k8s: Duke përdorur Kubernetes në https://192.168.39.145:8443/ në hapësirën e emrave default me manifest /home/rohaan/work/repos/eclipse-jkube-demo-project/target/classes/META-INF/jkube/kubernetes.yml 
[INFO] k8s: Duke përdorur hapësirën e emrave: default
[INFO] k8s: Duke krijuar një Shërbim nga kubernetes.yml hapësira e emrave default emri random-generator
[INFO] k8s: Krijuar Shërbimi: target/jkube/applyJson/default/service-random-generator.json
[INFO] k8s: Duke krijuar një Zhvillim nga kubernetes.yml hapësira e emrave default emri random-generator
[INFO] k8s: Krijuar Zhvillimi: target/jkube/applyJson/default/deployment-random-generator.json
[INFO] k8s: KËSHILLË: Përdorni komandën `kubectl get pods -w` për të parë se si nisin pod-ët tuaj
[INFO] ------------------------------------------------------------------------
[INFO] NDIHMA E NDËRTIMIT
[INFO] ------------------------------------------------------------------------
[INFO] Koha totale:  7.306 s
[INFO] Mbaroi në: 2020-08-10T11:40:57+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $ kubectl get pods -w
EMRI                                                     GATI   STATUS             RIKTHESE   MOSHA
random-generator-58b7847d7f-9m9df                        0/1     Duke punuar            0          7s
random-generator-58b7847d7f-9m9df                        1/1     Duke punuar            0          17s
^C~/work/repos/eclipse-jkube-demo-project : $ kubectl get svc
EMRI                                    LLOJI        CLUSTER-IP      EKSTERNO-IP   PORT(S)           MOSHA
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 .
  % Totali    % E pranuar % Transferit  Shpejtësia Mesatare   Koha    Koha     Koha  Aktual
                                 Dload  Ngarkim   Totali   Shpenzuar   Mbetur  Shpejtësia
100    45    0    45    0     0   1800      0 --:--:-- --:--:-- --:--:--  1875
{
  "id": "42e5571f-a20f-44b3-8184-370356581d10"
}

Hapi 6. Zbrazhja e aplikacionit nga klasteri Kubernetes

Për këtë përdoret detyra e zbrazhjes, e cila thjesht fshin të gjitha burimet që ishin aplikuar në hapin e mëparshëm, pra gjatë ekzekutimit të detyrës apply. Këto janë ato që do të shohim në ekran pas kërkesës që Eclipse JKube të realizojë detyrën e zbrazhjes mvn k8s:undeploy:

~/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 : $

Çfarë tjetër mund të bëhet me Eclipse JKube

Kështu, ne shqyrtuam objektivat kryesore të Eclipse JKube dhe Kubernetes Maven Plugin, të cilat lehtësojnë zhvillimin e aplikacioneve Java për platformën Kubernetes. Nëse nuk dëshironi ta shkruani vazhdimisht këto detyra në tastierë, ato mund të shkruhen në konfigurimin e plugin-it, për shembull, kështu:

org.eclipse.jkube
     kubernetes-maven-plugin
     ${project.version}
     
         
             
                  build
                  resource
                  apply

Duhet thënë se në këtë artikull ne nuk kemi shqyrtuar të gjitha objektivat që ekzistojnë në Eclipse JKube dhe Kubernetes Maven Plugin, prandaj po paraqesim në Tab. 2 një listë të detyrave shtesë që gjithashtu mund t'ju nevojiten.

Tab. 2. Detyra shtesë të Eclipse JKube.

Detyra
Shkalla
Përshkrimi

k8s:log
VALIDATE
Marrja e logëve nga aplikacioni që punon në Kubernetes.

k8s:debug
PACKAGE
Hapja e portit të debug për të kryer debugging të aplikacionit që punon në Kubernetes, direkt nga IDE.

k8s:deploy
INSTALLO
Krijimi i një fork për detyrën e Install dhe aplikimi i manifestove të gjeneruara në klasterin Kubernetes ashtu siç do të bëhej me detyrën apply.

k8s:watch
PACKAGE
Zhvillimi automatik i aplikacionit përmes përcjelljes së hapësirës së tij të emrave.

Zhvillimi i aplikacioneve Java në Red Hat OpenShift duke përdorur OpenShift Maven Plugin

Për të zhvilluar aplikacionin nga shembulli ynë në platformën Red Hat OpenShift, do të aplikojmë plugin-in OpenShift Maven. E vetmja ndryshim do të jetë se prefiksi i detyrave do të ndryshojë nga k8s në oc. Në mënyrë të paracaktuar, plugin-i Kubernetes Maven bën docker-ndërtime, ndërsa plugin-i OpenShift Maven bën ndërtimet S2I. Ne nuk bëjmë asnjë ndryshim në projektin tonë, përveç se heqim pronën jkube.generator.name, pasi ajo nuk kërkohet gjatë dërgimit në regjistrin (në fazën e ndërtimit, OpenShift vendos imazhin në regjistrin e tij të brendshëm). Dhe ja se çfarë do të shfaqet në ekran kur të nisnim shembullin tonë, në të cilin, për të qenë saktë, ne ekzekutojmë detyrat e qëllimit jo një nga një, por të gjitha njëherësh:

~/work/repos/eclipse-jkube-demo-project : $ mvn oc:build oc:resource oc:apply
[INFO] Skannoni për projekte...
[INFO] 
[INFO] ---------------------------------------------
[INFO] Ndërtimi i random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO] 
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] oc: Po përdoret ndërtimi OpenShift me strategjinë S2I
[INFO] oc: Po funksionon në mënyrën OpenShift
[INFO] oc: Po ekzekutohet gjeneruesi spring-boot
[INFO] oc: spring-boot: Po përdoret imazhi Docker quay.io/jkube/jkube-java-binary-s2i:0.0.7 si bazë / ndihmës
[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: Shtimi në Sekret pullsecret-jkube
[INFO] oc: Po përdoret Sekreti pullsecret-jkube
[INFO] oc: Po krijohet BuildServiceConfig random-generator-s2i për ndërtimin e burimit
[INFO] oc: Po krijohet ImageStream random-generator
[INFO] oc: Po nisin ndërtimin random-generator-s2i
[INFO] oc: Po pret që ndërtimi random-generator-s2i-1 të përfundojë...
[INFO] oc: Po ruhet blob-i nën "/var/cache/blobs".
[INFO] oc: Po merr nënshkrimet e burimit të imazhit
[INFO] oc: Po kopjon blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Po kopjon blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Po kopjon blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Po kopjon konfiguraimin sha256:52d6788fcfdd39595264d34a3959464a5dabc1d4ef0ae188802b20fc2d6a857b
[INFO] oc: Po shkruhet manifesti në destinacionin e imazhit
[INFO] oc: Po ruhen nënshkrimet
[INFO] oc: Po gjenerohet dockerfile me imazhin ndihmës quay.io/jkube/jkube-java-binary-s2i:0.0.7
[INFO] oc: HAPI 1: NGA quay.io/jkube/jkube-java-binary-s2i:0.0.7
[INFO] oc: HAPI 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: HAPI 3: ENV JAVA_APP_DIR="/deployments"     OPENSHIFT_BUILD_NAME="random-generator-s2i-1"     OPENSHIFT_BUILD_NAMESPACE="default"
[INFO] oc: HAPI 4: PËRDORUES root
[INFO] oc: HAPI 5: COPY upload/src /tmp/src
[INFO] oc: HAPI 6: RUN chown -R 1000:0 /tmp/src
[INFO] oc: HAPI 7: PËRDORUES 1000
[INFO] oc: HAPI 8: RUN /usr/local/s2i/assemble
[INFO] oc: INFO S2I ndërtim burimi me binarë të pastër i zbuluar
[INFO] oc: INFO S2I ndërtim binar nga fabric8-maven-plugin i zbuluar
[INFO] oc: INFO Po kopjoj binarët nga /tmp/src/deployments në /deployments ...
[INFO] oc: random-generator-0.0.1.jar
[INFO] oc: INFO Po kopjoj ndërtimet nga deployments në /deployments...
[INFO] oc: '/tmp/src/deployments/random-generator-0.0.1.jar' -> '/deployments/random-generator-0.0.1.jar'
[INFO] oc: HAPI 9: CMD /usr/local/s2i/run
[INFO] oc: HAPI 10: COMMIT temp.builder.openshift.io/default/random-generator-s2i-1:48795e41
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Përputhje mes sistemit të operimit të imazhit: imazhi përdor "", duke pritur "linux""
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Përputhje e arkitekturës së imazhit: imazhi përdor "", duke pritur "amd64""
[INFO] oc: Po merr nënshkrimet e burimit të imazhit
[INFO] oc: Po kopjon blob sha256:d8e1f35641acb80b562f70cf49911341dfbe8c86f4d522b18efbf3732aa74223
[INFO] oc: Po kopjon blob sha256:b6f081e4b2b6de8be4b1dec132043d14c121e968384dd624fb69c2c07b482edb
[INFO] oc: Po kopjon blob sha256:b7139ad07aa8ce4ed5a132f7c5cc9f1de0f5099b5e155027a23d57f7fbe78b16
[INFO] oc: Po kopjon blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Po kopjon konfiguraimin sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Po shkruhet manifesti në destinacionin e imazhit
[INFO] oc: Po ruhen nënshkrimet
[INFO] oc: --> 27aaadaf28e
[INFO] oc: 27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Po merr nënshkrimet e burimit të imazhit
[INFO] oc: 
[INFO] oc: Po shtyhet imazhi image-registry.openshift-image-registry.svc:5000/default/random-generator:0.0.1 ...
[INFO] oc: Po kopjon blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Po kopjon blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Po kopjon blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Po kopjon blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Po kopjon konfiguraimin sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Po shkruhet manifesti në destinacionin e imazhit
[INFO] oc: Po ruhen nënshkrimet
[INFO] oc: Imazhi regjistruar me sukses image-registry.openshift-image-registry.svc:5000/default/random-generator@sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: Shtimi i sukses
[INFO] oc: Ndërtimi random-generator-s2i-1 në status të plotë
[INFO] oc: Gjetur etiketa në ImageStream random-generator etiketa: sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: ImageStream random-generator shkruar në /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: Po përdoret emri i imazhit docker të hapësirës: default
[INFO] oc: Po funksionon gjeneruesi spring-boot
[INFO] oc: spring-boot: Po përdoret imazhi Docker quay.io/jkube/jkube-java-binary-s2i:0.0.7 si bazë / ndihmës
[INFO] oc: jkube-controller: Duke shtuar një DeploymenConfig të parazgjedhur
[INFO] oc: jkube-service: Duke shtuar një shërbim të parazgjedhur 'random-generator' me porte [8080]
[INFO] oc: jkube-healthcheck-spring-boot: Duke shtuar një provë gatishmërie në portin 8080, rruga='/actuator/health', skema='HTTP', me vonesë fillestare 10 sekonda
[INFO] oc: jkube-healthcheck-spring-boot: Duke shtuar një provë gjallërie në portin 8080, rruga='/actuator/health', skema='HTTP', me vonesë fillestare 180 sekonda
[INFO] oc: jkube-revision-history: Duke shtuar kufizimin e historikut të rishikimit në 2
[INFO] 
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] oc: Po përdoret OpenShift në https://api.crc.testing:6443/ në hapësirën e emrave default me manifestin /home/rohaan/work/repos/eclipse-jkube-demo-project/target/classes/META-INF/jkube/openshift.yml 
[INFO] oc: Platforma OpenShift e zbuluar
[INFO] oc: Po përdoret projekti: default
[INFO] oc: Po krijohet një Shërbim nga openshift.yml hapësira default emri random-generator
[INFO] oc: Krijuar Shërbimi: target/jkube/applyJson/default/service-random-generator.json
[INFO] oc: Po krijohet një DeploymenConfig nga openshift.yml hapësira default emri random-generator
[INFO] oc: Krijuar DeploymenConfig: target/jkube/applyJson/default/deploymentconfig-random-generator.json
[INFO] oc: Po krijohet Rruga default:random-generator host: null
[INFO] oc: Këshillë: Përdorni komandën `oc get pods -w` për të vëzhguar se si nisin pod-ët tuaj
[INFO] ------------------------------------------------------------------------
[INFO] NDËRTIMI I SUKSES
[INFO] ------------------------------------------------------------------------
[INFO] Koha totale:  01:07 min
[INFO] Përfunduar në: 2020-08-10T12:08:00+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $ oc get pods -w
EMRI                           GATI     STATUS      RIVENDOSJET   MOSHA
random-generator-1-deploy      1/1       Po funksionon     0          14s
random-generator-1-vnrm9       0/1       Po funksionon     0          11s
random-generator-s2i-1-build   0/1       Përfunduar   0          1m
random-generator-1-vnrm9   1/1       Po funksionon   0         24s
random-generator-1-deploy   0/1       Përfunduar   0         28s
~/work/repos/eclipse-jkube-demo-project : $ oc get routes
EMRI                HOST/PORT                                    RRUGA      SHËRBIMET            PORTE      PËRFUNDIMI   WILDCARD
random-generator    random-generator-default.apps-crc.testing              random-generator    8080                    Asnjë
~/work/repos/eclipse-jkube-demo-project : $ curl random-generator-default.apps-crc.testing/random 
  % Totali    % Marrë % Transferuar  Shpejtësia Mesatare   Koha    Koha     Koha  Aktualja
                                 Dload  Ngarkim   Totali   Shpenzuar   Këtë Shkëmbim  Shpejtësia
100    45    0    45    0     0   1666      0 --:--:-- --:--:-- --:--:--  1730
{
  "id": "d80052d9-2f92-43cb-b9eb-d7cffb879798"
}
~/work/repos/eclipse-jkube-demo-project : $

Video-mësimi

Për të mësuar më shumë se si ta thjeshtoni zhvillimin Kubernetes me Eclipse JKube, shikoni video-mësimin për instalimin e shpejtë të një aplikacioni të thjeshtë Spring Boot në Minikube:

Përfundimi

Në këtë artikull ne treguam si Eclipse JKube e bën më të lehtë jetën për zhvilluesit Java kur punojnë me Kubernetes. Informacione shtesë mbi Eclipse JKube mund të gjeni në faqja e projektit dhe te GitHub.

Burimi: habr.com