25 vjet më parë, Java hyri në masat e shumta të programuesve, duke u bërë një nga ato shtylla përreth të cilave ndërtohen stekat e aplikacioneve. Megjithatë, sot shumë njerëz dhe organizata, të cilët për një kohë të gjatë i kanë mbajtur besnikërinë Java, janë të angazhuar në kalimin ose po mendojnë të kalojnë në platformën ose përvarësitë e saj, siç janë или .
Mjerisht, Kubernetes ka një kurbë të mprehtë të të mësuarit dhe sjell një nivel tjetër operativ në procesin e zakonshëm të zhvillimit për programuesit Java. Sot do të flasim se si të përdorim , për të thjeshtuar 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 ruajtur ekosistemin e njohur Java. Më shumë se kaq, ne do të tregojmë se si të implementojmë aplikacionet Java në platformën OpenShift duke përdorur plugin-in OpenShift Maven.
Procesi tradicional i zhvillimit Java
Procesi tradicional i zhvillimit (Fig.1) nënkupton që zhvilluesi shkruan kodin, pastaj krijon njësitë e implementimit në formën e skedarëve JAR ose WAR, dhe më pas implementon dhe ekzekuton këto skedarë në një server web ose server aplikacionesh. Kryesisht për këtë përdoret Maven nga rreshti i komandave ose përdoren IDE të tilla si IntelliJ ose Eclipse për të koduar dhe paketuar aplikacionet. Zhvilluesit janë mësuar të bëjnë ndryshime në kod dhe të testojnë gjithçka me kujdes, para se të ngjeshin kodin dhe ta dërgojnë atë në sistemin e menaxhimit të versioneve.
Fig. 1. Procesi tradicional i zhvillimit Java.
Procesi i zhvillimit Java për cloud
Duke kaluar në aplikacionet cloud, në skemën e përshkruar më sipër shtohen Kubernetes dhe . Prandaj, tani zhvilluesi duhet të paketojë aplikacionet Java në dhe të krijojë manifestet Kubernetes që përshkruajnë këto imazhe. Pastaj këto manifeste aplikohen në serverin prodhues, ku funksionon Kubernetes. Nga ana e tij, Kubernetes merr këto imazhe nga registri dhe implementon aplikacionet sipas atyre konfigurimeve që ne kemi shkruar në manifeste, të cilat zakonisht janë skedarë YAML.
Metamorfoza e procesit tradicional të zhvillimit Java në kalimin në cloud është e ilustruar në Fig. 2.
Fig. 2. Procesi i zhvillimit Java për cloud.
Eclipse JKube
Migrimi në Kubernetes shton një nivel operativ të ri në procesin e zhvillimit, dhe shumë zhvillues e ndjejnë këtë stresuese, sepse ata duan të fokusohen në punën e tyre kryesore - logjikën e aplikacioneve - dhe jo se si t'i implementojnë ato. Këtu hyn në lojë , i cili lejon zhvilluesit të përdorin bibliotekat dhe pluginët e tyre ( më bashkë me или ), për të kryer pa mundim operacionet që lidhen me kontejnerët dhe Kubernetes, duke ndjekur skemën në Figurën 2.
Në pjesën e mbetur të këtij artikulli ne do të tregojmë se si ta thjeshtojmë procesin e zhvillimit Java në ambientin Kubernetes, duke përdorur Eclipse JKube me pluginin Kubernetes Maven Plugin.
Procesi i zhvillimit për cloud me Eclipse JKube
Le të shqyrtojmë një skemë të modifikuar pak të zhvillimit Java për cloud me Figurën 2, duke e futur Eclipse JKube dhe Kubernetes Maven Plugin, siç tregohet në Figurën 3.
Figura 3. Procesi i zhvillimit Java për cloud me Eclipse JKube.
Siç shohim, këtu të gjitha operacionet e ndërveprimit me Kubernetes dhe kontejnerët (të theksuara me të kuqe në skemë) zëvendësohen me detyrat e Eclipse JKube nga default, të cilat janë të listuara në Tabelën 1.
Tabela 1. Detyrat e Eclipse JKube nga default.
Detyra
Faza
Përshkrimi
PRE_INTEGRATION_TEST
Ndërtimi i imazheve docker
INSTALL
Dërgimi i imazheve docker në regjistrin
PROCESS_RESOURCES
Generimi i manifestëve K8s
COMPILE
Zbatimi i manifestëve të gjeneruara në K8s
UNDEPLOY
Fshirja e burimeve K8s që janë implementuar përmes k8s:apply dhe k8s:deploy
Vërejtje: Nëse nuk dëshironi që detyrat të përdorin këto defolt të forta (default të menduar), mund ta rregulloni manualisht Eclipse JKube sipas nevojës, pasi që ai mbështet konfigurimin përmes dhe .
Tani le të shqyrtojmë shembujt e përdorimit të Eclipse JKube dhe Kubernetes Maven Plugin gjatë punës me aplikacione.
Implementimi i aplikacionit Java në Kubernetes duke përdorur Eclipse JKube
Në këtë shembull ne do të implementojmë një aplikacion të thjeshtë Java në klasterin duke përdorur Eclipse JKube. Duke përdorur Kubernetes Maven Plugin, ne mund të caktomë parametrat e implementimit pa pasur nevojë të shkruajmë ndonjë konfigurim.
Si një shembull aplikacioni ne përdorim , i cili jep JSON-output në endpoint’ën /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ë depo . Për të përdorur Eclipse JKube, duhet të shtoni Kubernetes Maven Plugin në pom.xml tuaj si një varësi:
org.eclipse.jkube
kubernetes-maven-plugin
${jkube.version}
Nëse në vend të Kubernetes të pastër përdoret OpenShift, pom.xml modifikohet si më poshtë:
org.eclipse.jkube
openshift-maven-plugin
${jkube.version}
Hapi 2. Ndërtojmë imazhin docker
Skedari JAR i aplikacionit mund të ndërtohet me komandën mvn package, pastaj mund të përdoret qëllimi 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 duke përdorur këtë pronë:
docker.io\/rohankanojia\/random-generator:${project.version}
Para se të ndërtojmë imazhin, duhet të sigurohemi që demon docker është ekspozuar siç duhet. Kjo mund të bëhet me komandën e mëposhtme:
$ eval $(minikube docker-env)
Pastaj jepni komandën mvn k8s:build, dhe ja çfarë do të shohim në ekran gjatë ndërtimit të imazhit docker me ndihmën e Eclipse JKube:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:build
[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: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 : $
Hapi 3. Dërgojmë imazhin në regjistrin docker
Pasi të kemi ndërtuar imazhin docker me regjistrin e konfiguruar për push (në rastin tonë është docker.io), mund ta dërgojmë këtë imazh në regjistër. Këtu është çfarë do të shfaqet në ekran pasi t'i kërkojmë Eclipse JKube të kryejë detyrën push mvn k8s:push:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:push
[INFO] Punimi i projekteve...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Ndërtojmë random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:push (default-cli) @ random-generator ---
[INFO] k8s: Duke funksionuar në modin Kubernetes
[INFO] k8s: Duke ndërtuar imazhin Docker në modin Kubernetes
[INFO] k8s: Duke ecur gjeneruesin spring-boot
[INFO] k8s: spring-boot: Duke përdorur imazhin Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 si bazë \/ ndihmës
[INFO] k8s: Dërgimi i referohet depozitës [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 përmasë: 1162
[INFO] k8s: Dërguar docker.io\/rohankanojia\/random-generator:0.0.1 në 7 sekonda
[INFO] ------------------------------------------------------------------------
[INFO] NDËRTIMI SUKSES
[INFO] ------------------------------------------------------------------------
[INFO] Koha totale: 11.222 s
[INFO] Mbaroi në: 2020-08-10T11:35:37+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $
Pas dërgimit të imazhit, duhet të verifikojmë që ai ka mbërritur në regjistrin. Në rastin tonë, thjesht e shohim atë në Docker Hub, siç tregohet në Fig. 4.
Fig. 4. Imazhi i dërguar në regjistrin u shfaq në Docker Hub.
Hapi 4. Gjenerimi i manifestimeve të burimeve Kubernetes për aplikacionin
Pra, imazhi i aplikacionit e kemi ndërtuar, tani duhet të shkruajmë manifestet Kubernetes. Për këtë, në Eclipse JKube ekziston një detyrë që gjeneron manifestet e burimeve duke u mbështetur në kuadër e Java-s (, , Vert.x ose ndonjë tjetër). Gjithashtu, mund të konfigurojmë manifestin duke përdorur një fichier XML dhe duke vendosur fragmente të papërpunuara (fragmente të manifestit të kërkuar të burimeve) në folderin src\/main\/jkube të aplikacionit. Në këtë rast, konfigurimi juaj do të përfshihet në manifestet e gjeneruara.
Në shembullin tonë, ne i lejmë gjithçka siç është, dhe për këtë arsye Eclipse JKube gjeneron një manifest për ndërprerjen e parazgjedhur dhe për një shërbim me tipin ClusterIP. Më pas, ne modifikojmë manifestin e shërbimit për të ndryshuar tipin e shërbimit në NodePort. Të paracaktuarit e sjelljes së parazgjedhur mund të anashkalohet me vetinë e mëposhtme:
<jkube.enricher.jkube-service.type>NodePort<\/jkube.enricher.jkube-service.type>
Ja si duket dalja në ekran pasi kërkojmë nga Eclipse JKube të ekzekutojë detyrën e burimeve mvn k8s:resource.
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:resource
[INFO] Skanning për projekte...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Ndërtohet random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:resource (default-cli) @ random-generator ---
[INFO] k8s: Po ekzekutohet gjeneratori spring-boot
[INFO] k8s: spring-boot: Duke përdorur imazhin Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 si bazë \/ ndihmës
[INFO] k8s: jkube-controller: Duke shtuar një Ndërmarrje default
[INFO] k8s: jkube-service: Duke shtuar një shërbim default 'random-generator' me porte [8080]
[INFO] k8s: jkube-healthcheck-spring-boot: Duke shtuar një provë gatishmërie në portin 8080, rruga='\/actuator\/health', skema='HTTP', me një vonesë fillestare 10 sekonda
[INFO] k8s: jkube-healthcheck-spring-boot: Duke shtuar një provë gjallërie në portin 8080, rruga='\/actuator\/health', skema='HTTP', me një vonesë fillestare 180 sekonda
[INFO] k8s: jkube-revision-history: Duke shtuar një kufizim të historisë së revizionit me 2
[INFO] ------------------------------------------------------------------------
[INFO] NDËRTIM I SUKSESSHËM
[INFO] ------------------------------------------------------------------------
[INFO] Koha totale: 3.344 s
[INFO] Përfundoi në: 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 e deployojmë aplikacionin në klasterin Kubernetes
Prandaj, tani jemi gati për të realizuar depërtimin e aplikacionit: ne kemi gjeneruar imazhin e tij dhe më pas kemi gjeneruar automatikisht manifestet e burimeve. Tani mbetet vetëm të aplikojmë gjithçka në klasterin Kubernetes. Për të depërtuar aplikacionin, mund të përdorim komandën kubectl apply -f, por plugini mund ta bëjë këtë për ne. Këtu është se çfarë do të shfaqet në ekran pasi të kërkojmë nga Eclipse JKube të realizojë detyrën apply mvn k8s:apply:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:apply
[INFO] Skanning për projekte...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[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: Përdor Kubernetes në https:\/\/192.168.39.145:8443\/ në hapësirë të emrit default me manifest \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/classes\/META-INF\/jkube\/kubernetes.yml
[INFO] k8s: Përdor hapësirën e emrit: default
[INFO] k8s: Krijimi i një Shërbimi nga kubernetes.yml hapësira e emrit default emri random-generator
[INFO] k8s: Krijuar Shërbimi: target\/jkube\/applyJson\/default\/service-random-generator.json
[INFO] k8s: Krijimi i një Ndërmarrjeje nga kubernetes.yml hapësira e emrit default emri random-generator
[INFO] k8s: Krijuar Ndërmarrja: target\/jkube\/applyJson\/default\/deployment-random-generator.json
[INFO] k8s: KËSHILLË: Përdor komandën `kubectl get pods -w` për të ndjekur fillimin e pods tuaj
[INFO] ------------------------------------------------------------------------
[INFO] NDËRTIMI ME SUKSES
[INFO] ------------------------------------------------------------------------
[INFO] Koha totale: 7.306 s
[INFO] Përfunduar në: 2020-08-10T11:40:57+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get pods -w
EMRI GATI STATUSI RIFILLIMET MOSHA
random-generator-58b7847d7f-9m9df 0\/1 Po përshtatet 0 7s
random-generator-58b7847d7f-9m9df 1\/1 Po përshtatet 0 17s
^C~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get svc
EMRI LLOJI CLUSTER-IP EXTERNAL-IP PORT(E) MOSHA
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 .
% Totali % Marrë % Transferuara Shpejtësia Mesatare Koha Koha Koha Aktual
Dload Ngarko Totali Shpenzuar Mbete Shpejtësia
100 45 0 45 0 0 1800 0 --:--:-- --:--:-- --:--:-- 1875
{
"id": "42e5571f-a20f-44b3-8184-370356581d10"
}
Hapi 6. Bëni undeploy të aplikacionit nga klasteri Kubernetes
Për këtë përdoret detyra undeploy, e cila thjesht heq të gjitha burimet që ishin aplikuar në hapin e mëparshëm, dmth. gjatë ekzekutimit të detyrës apply. Këtu është çfarë do të shohim në ekran pas kërkesës që Eclipse JKube të ekzekutojë detyrën e undeploy 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ë mund të bëni tjetër me Eclipse JKube
Pra, ne shqyrtuam qëllimet 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 të jeni duke përshkruar vazhdimisht këto qëllime nga tastiera, mund t'i shkruani ato 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 shqyrtuam shumë, por jo të gjitha qëllimet që ekzistojnë në Eclipse JKube dhe Kubernetes Maven Plugin, prandaj po paraqesim në Tab.2 listën e qëllimeve shtesë që mund t'ju nevojiten.
Tab. 2. Qëllimet shtesë të Eclipse JKube.
Detyra
Faza
Përshkrimi
VALIDATE
Marrja e logeve nga aplikacioni që funksionon në Kubernetes.
PACKAGE
Hapja e portës së debug për të kryer debugging të aplikacioneve që punojnë në Kubernetes, drejtpërdrejt nga IDE.
INSTALL
Krijimi i një forks për detyrën e installimit dhe aplikimi i manifestimeve të gjeneruara në klasterin Kubernetes në të njëjtën mënyrë si detyra apply.
PACKAGE
Zhvillimi automatik i aplikacionit falë monitorimit të hapësirës së tij emri.
Zhvillimi i aplikacioneve Java në Red Hat OpenShift me ndihmën e OpenShift Maven Plugin
Për të zhvilluar aplikacionin nga shembulli ynë në platformën Red Hat OpenShift, do të përdorim pluginin . Diferenca e vetme do të jetë se prefiksi i detyrave do të ndryshojë nga k8s në oc. Nga e para, plugin Kubernetes Maven bën -ndërtimet, ndërsa plugin OpenShift Maven – ndërtimet . Ne nuk bëjmë ndryshime në projektin tonë, përveç se heqim pronën jkube.generator.name, sepse nuk është e nevojshme gjatë dërgimit në regjistrin (në fazën e ndërtimit, OpenShift vendos imazhin në regjistrin e tij të brendshëm). Këtu është ajo që do të shfaqet në ekran kur të ekzekutojmë shembullin tonë, në të cilin, nga ana tjetër, ne kryejmë detyrat e qëllimit jo një e vetme por të gjitha njëherësh:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn oc:build oc:resource oc:apply
[INFO] Skanning për projekte...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[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: Duke përdorur ndërtimin OpenShift me strategjinë S2I
[INFO] oc: Duke funksionuar në modalitetin OpenShift
[INFO] oc: Duke e ndihmuar gjeneratorin spring-boot
[INFO] oc: spring-boot: Duke përdorur imazhin Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 si bazë \/ ndihmës
[INFO] oc: [random-generator:0.0.1] "spring-boot": Krijuar tarin e burimit docker \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/docker\/random-generator\/0.0.1\/tmp\/docker-build.tar
[INFO] oc: Duke shtuar në Secret pullsecret-jkube
[INFO] oc: Duke përdorur Secret pullsecret-jkube
[INFO] oc: Duke krijuar BuildServiceConfig random-generator-s2i për ndërtimin e burimit
[INFO] oc: Duke krijuar ImageStream random-generator
[INFO] oc: Duke nisur ndërtimin random-generator-s2i
[INFO] oc: Duke pritur për ndërtimin random-generator-s2i-1 për të përfunduar...
[INFO] oc: Duke ruajtur blob-et nën "\/var\/cache\/blobs".
[INFO] oc: Duke marrë nënshkrime burimesh imazhi
[INFO] oc: Duke kopjuar blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Duke kopjuar blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Duke kopjuar blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Duke kopjuar konfigurimin sha256:52d6788fcfdd39595264d34a3959464a5dabc1d4ef0ae188802b20fc2d6a857b
[INFO] oc: Duke shkruar manifestin në destinacionin e imazhit
[INFO] oc: Duke ruajtur nënshkrimet
[INFO] oc: Duke gjeneruar dockerfile me imazhin e 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ËRGATIT ROOT
[INFO] oc: HAPI 5: KOPJO upload\/src \/tmp\/src
[INFO] oc: HAPI 6: RUN chown -R 1000:0 \/tmp\/src
[INFO] oc: HAPI 7: PËRGATIT 1000
[INFO] oc: HAPI 8: RUN \/usr\/local\/s2i\/assemble
[INFO] oc: INFO Ndërtesa S2I e burimit me binarë të pastër u zbulua
[INFO] oc: INFO Ndërtesa S2I binare e zbuluar nga fabric8-maven-plugin
[INFO] oc: INFO Duke kopjuar binarët nga \/tmp\/src\/deployments në \/deployments ...
[INFO] oc: random-generator-0.0.1.jar
[INFO] oc: INFO Duke kopjuar ndërtimet nga ndërtimet 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: KOMIT temp.builder.openshift.io\/default\/random-generator-s2i-1:48795e41
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Përputhja e sistemit të operimit të imazhit: imazhi përdor "", duke pritur "linux""
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Përputhja e arkitekturës së imazhit: imazhi përdor "", duke pritur "amd64""
[INFO] oc: Duke marrë nënshkrime burimesh imazhi
[INFO] oc: Duke kopjuar blob sha256:d8e1f35641acb80b562f70cf49911341dfbe8c86f4d522b18efbf3732aa74223
[INFO] oc: Duke kopjuar blob sha256:b6f081e4b2b6de8be4b1dec132043d14c121e968384dd624fb69c2c07b482edb
[INFO] oc: Duke kopjuar blob sha256:b7139ad07aa8ce4ed5a132f7c5cc9f1de0f5099b5e155027a23d57f7fbe78b16
[INFO] oc: Duke kopjuar blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Duke kopjuar konfigurimin sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Duke shkruar manifestin në destinacionin e imazhit
[INFO] oc: Duke ruajtur nënshkrimet
[INFO] oc: --> 27aaadaf28e
[INFO] oc: 27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Duke marrë nënshkrime burimesh imazhi
[INFO] oc:
[INFO] oc: Duke shtyrë imazhin image-registry.openshift-image-registry.svc:5000\/default\/random-generator:0.0.1 ...
[INFO] oc: Duke kopjuar blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Duke kopjuar blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Duke kopjuar blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Duke kopjuar blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Duke kopjuar konfigurimin sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Duke shkruar manifestin në destinacionin e imazhit
[INFO] oc: Duke ruajtur nënshkrimet
[INFO] oc: Shtimi i suksesshëm i image-registry.openshift-image-registry.svc:5000\/default\/random-generator@sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: Shtimi i suksesshëm
[INFO] oc: Ndërtimi random-generator-s2i-1 në statusin përfundimtar
[INFO] oc: Gjetur etiketë në ImageStream random-generator etiketë: sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: ImageStream random-generator është 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: Duke përdorur emrin e imazhit docker të hapësirës: default
[INFO] oc: Duke funksionuar gjeneratori spring-boot
[INFO] oc: spring-boot: Duke përdorur imazhin Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 si bazë \/ ndihmës
[INFO] oc: jkube-controller: Duke shtuar një DeploymentConfig të paracaktuar
[INFO] oc: jkube-service: Duke shtuar një shërbim të paracaktuar 'random-generator' me porta [8080]
[INFO] oc: jkube-healthcheck-spring-boot: Duke shtuar një sondë gatishmërie në portin 8080, rruga='\/actuator\/health', skema='HTTP', me vonesë fillestare 10 sekonda
[INFO] oc: jkube-healthcheck-spring-boot: Duke shtuar një sondë gjallërie në portin 8080, rruga='\/actuator\/health', skema='HTTP', me vonesë fillestare 180 sekonda
[INFO] oc: jkube-revision-history: Duke shtuar kufirin e historisë së riblerjes në 2
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] oc: Duke përdorur 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 u zbulua
[INFO] oc: Duke përdorur projektin: default
[INFO] oc: Duke krijuar 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: Duke krijuar një DeploymentConfig nga openshift.yml hapësira default emri random-generator
[INFO] oc: Krijuar DeploymentConfig: target\/jkube\/applyJson\/default\/deploymentconfig-random-generator.json
[INFO] oc: Duke krijuar Rrugë default:random-generator host: null
[INFO] oc: KËSHILL: Përdorni komandën `oc get pods -w` për të ndjekur fillimin e pod-ëve tuaj
[INFO] ------------------------------------------------------------------------
[INFO] NDËRTIM SUKSESH
[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 RIBASHKOHJET MOSHAT
random-generator-1-deploy 1\/1 Duke funksionuar 0 14s
random-generator-1-vnrm9 0\/1 Duke funksionuar 0 11s
random-generator-s2i-1-build 0\/1 Përfunduar 0 1m
random-generator-1-vnrm9 1\/1 Duke funksionuar 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 PORT TERMINIMI 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ë % Transferi Shpejtësia Mesatare Koha Koha Koha Aktual
Dload Ngarkesa Totali Shpenzuar E Lënë 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ësimor
Për të mësuar më shumë se si ta thjeshtoni zhvillimin e Kubernetes me Eclipse JKube, shikoni videon mësimore për vendosjen e shpejtë të një aplikacioni të thjeshtë Spring Boot në Minikube:
Përfundim
Në këtë artikull ne treguam se si Eclipse JKube e lehtëson jetën e zhvilluesve Java në punën me Kubernetes. Informacione të tjera mbi Eclipse JKube mund të gjeni në dhe në .
Burimi: habr.com
