Acum 25 de ani, Java a intrat în comunitatea programmerilor pentru a deveni unul dintre pilonii în jurul cărora se construiesc stivele de aplicații. Cu toate acestea, astăzi, multe persoane și organizații, care au fost fidèles Java timp de mulți ani, sunt ocupate cu trecerea sau gândindu-se să treacă la platforma sau derivații acesteia, cum ar fi sau .
Din păcate, Kubernetes are o curbă de învățare abruptă și introduce un alt nivel operațional în procesul de dezvoltare familiar programatorilor Java. Astăzi vă vom arăta cum să folosiți , pentru a simplifica aceste operațiuni suplimentare legate de Kubernetes și containere, precum și pentru a asigura o migrație fără dureri către o platformă cloud, păstrând ecosistemul Java cunoscut. Mai mult, vă vom arăta cum să desfășurați aplicații Java pe platforma OpenShift utilizând pluginul OpenShift Maven.
Procesul tradițional de dezvoltare Java
Procesul tradițional de dezvoltare (Fig.1) implică faptul că dezvoltatorul scrie cod, apoi creează unități de desfășurare sub formă de fișiere JAR sau WAR și apoi desfășoară și rulează aceste fișiere pe un server web sau un server de aplicații. În principal, se utilizează Maven din linia de comandă sau se folosește un IDE, cum ar fi IntelliJ sau Eclipse, pentru a codifica și împacheta aplicațiile. Dezvoltatorii sunt obișnuiți să facă modificări în cod și să testeze totul cu atenție înainte de a fixa codul și de a-l trimite în sistemul de gestionare a versiunilor.
Fig. 1. Procesul tradițional de dezvoltare Java.
Procesul de dezvoltare Java pentru cloud
Atunci când trecem la aplicațiile cloud, schema descrisă mai sus adaugă Kubernetes și . Prin urmare, acum dezvoltatorul trebuie să împacheteze aplicațiile Java în și să creeze manifeste Kubernetes care descriu aceste imagini. Apoi, aceste manifeste sunt aplicate serverului de producție pe care rulează Kubernetes. La rândul său, Kubernetes ia aceste imagini din registru și desfășoară aplicațiile conform configurațiilor pe care le-am specificat în manifești, care sunt de obicei fișiere YAML.
Metamorfoza procesului tradițional de dezvoltare Java la trecerea către cloud este ilustrată în Fig. 2.
Fig. 2. Procesul de dezvoltare Java pentru cloud.
Eclipse JKube
Trecerea la Kubernetes adaugă un nou nivel operațional în procesul de dezvoltare, ceea ce îi îngrijorează pe mulți dezvoltatori, deoarece doresc să se concentreze pe activitatea lor de bază – logica aplicațiilor – și nu pe modul în care acestea sunt desfășurate. Și aici intervine , care permite dezvoltatorilor să utilizeze bibliotecile și pluginurile lor ( împreună cu sau ), pentru a efectua fără efort operațiunile legate de containere și Kubernetes, conform schemei din Fig. 2.
În restul acestui articol, vom arăta cum să simplificăm procesul de dezvoltare Java în medii Kubernetes, folosind Eclipse JKube cu pluginul Kubernetes Maven Plugin.
Procesul de dezvoltare pentru cloud cu Eclipse JKube
Să considerăm o schemă ușor modificată a dezvoltării Java pentru cloud din Fig. 2, introducându-l pe Eclipse JKube și Kubernetes Maven Plugin, așa cum este arătat în Fig. 3.
Fig. 3. Procesul de dezvoltare Java pentru cloud cu Eclipse JKube.
Așa cum vedem, toate operațiunile de interacțiune cu Kubernetes și containerele (evidențiate în roșu în schemă) sunt înlocuite de sarcinile implicit oferite de Eclipse JKube, care sunt enumerate în Tabelul 1.
Tabelul 1. Sarcinile implicite ale Eclipse JKube.
Sarcină
Etapa
Descriere
PRE_INTEGRATION_TEST
Construirea imaginilor docker
INSTALL
Trimiterea imaginilor docker în registru
PROCESS_RESOURCES
Generarea manifestelor K8s
COMPILE
Aplicarea manifestelor generate pe K8s
UNDEPLOY
Ștergerea resurselor K8s care au fost desfășurate prin k8s:apply și k8s:deploy
Notă: Dacă nu doriți ca sarcinile să folosească aceste valori implicite rigide (defaulturi opționale), puteți personaliza manual Eclipse JKube, având în vedere că acesta suportă configurarea prin și .
Acum să analizăm exemple de utilizare a Eclipse JKube și Kubernetes Maven Plugin în lucrul cu aplicațiile.
Desfășurând o aplicație Java în Kubernetes cu Eclipse JKube
În acest exemplu, vom desfășura o aplicație Java simplă în clusterul cu ajutorul Eclipse JKube. Folosind Kubernetes Maven Plugin, putem specifica parametrii desfășurării fără a fi nevoie să scriem vreo configurare.
Ca exemplu de aplicație, folosim , care returnează JSON-output la endpoint-ul \/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"
}
Pasul 1. Încărcăm Kubernetes Maven Plugin
Kubernetes Maven Plugin se află în repository . Pentru a folosi Eclipse JKube, trebuie să adăugați Kubernetes Maven Plugin în pom.xml-ul dvs. ca dependență:
org.eclipse.jkube
kubernetes-maven-plugin
${jkube.version}
Dacă în loc de Kubernetes pur folosiți OpenShift, atunci pom.xml se modifică astfel:
org.eclipse.jkube
openshift-maven-plugin
${jkube.version}
Pasul 2. Construim imaginea docker
Fișierul JAR al aplicației poate fi construit cu comanda mvn package, iar apoi se poate folosi sarcina mvn k8s:build pentru a construi imaginea docker a acestei aplicații. Rețineți că am suprascris numele imaginii implicite cu această proprietate:
docker.io/rohankanojia/random-generator:${project.version}
Înainte de a construi imaginea, trebuie să ne asigurăm că daemonul docker este corect expus. Acest lucru se poate face cu următoarea comandă:
$ eval $(minikube docker-env)
Apoi introducem comanda mvn k8s:build și iată ce vom vedea pe ecran în timpul construirii imaginii docker cu sarcina build de la Eclipse JKube:
~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:build
[INFO] Scan 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 : $
Pasul 3. Încărcăm imaginea în registry-ul docker
După ce am construit imaginea docker având registry-ul de push configurat (în cazul nostru este docker.io), putem încărca această imagine în registry. Iată ce va apărea pe ecran după ce vom cere lui Eclipse JKube să execute sarcina de push mvn k8s:push:
~\/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 : $
După trimiterea imaginii, trebuie să verificăm dacă a ajuns în registru. În cazul nostru, îl vedem pur și simplu în Docker Hub, așa cum este arătat în Fig. 4.
Fig. 4. Imaginea trimisă în registru a apărut în Docker Hub.
Pasul 4. Generăm manifestele resurselor Kubernetes pentru aplicație
Așadar, am construit imaginea aplicației, acum trebuie să scriem manifestele Kubernetes. Pentru aceasta, în Eclipse JKube există o sarcină care generează manifestele statice ale resurselor, pornind de la cadrul Java de bază (, , Vert.x sau altul). De asemenea, este posibil să configurăm manifestul folosind un fișier XML de configurare și plasând fragmentele raw (fragmentele manifestului resurselor necesare) în directorul aplicației src\/main\/jkube. În acest caz, configurația dumneavoastră va fi inclusă în manifestele generate.
În exemplul nostru, lăsăm totul așa cum este, iar Eclipse JKube generează un manifest pentru desfășurarea implicită și pentru serviciul de tip ClusterIP. Apoi, modificăm manifestul serviciului pentru a schimba tipul de serviciu în NodePort. Comportamentul implicit poate fi suprascris folosind următoarea proprietate:
NodePort
Iată cum arată ieșirea pe ecran după ce cerem Eclipse JKube să execute sarcina de resurse mvn k8s:resource.
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:resource
[INFO] Scanare proiecte...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Construind random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:resource (default-cli) @ random-generator ---
[INFO] k8s: Pornind generator spring-boot
[INFO] k8s: spring-boot: Folosind imagine Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 ca bază \/ builder
[INFO] k8s: jkube-controller: Adăugând un Deployment implicit
[INFO] k8s: jkube-service: Adăugând un serviciu implicit 'random-generator' cu porturi [8080]
[INFO] k8s: jkube-healthcheck-spring-boot: Adăugând un probe de disponibilitate pe portul 8080, calea='\/actuator\/health', schemă='HTTP', cu o întârziere inițială de 10 secunde
[INFO] k8s: jkube-healthcheck-spring-boot: Adăugând un probe de vitalitate pe portul 8080, calea='\/actuator\/health', schemă='HTTP', cu o întârziere inițială de 180 secunde
[INFO] k8s: jkube-revision-history: Adăugând o limită a istoricului reviziilor de 2
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUCȚIE SUCCES
[INFO] ------------------------------------------------------------------------
[INFO] Timp total: 3.344 s
[INFO] Terminat la: 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 : $
Pasul 5. Implementăm aplicația în clusterul Kubernetes
Așadar, totul este pregătit pentru a efectua implementarea aplicației: am generat imaginea sa și apoi am generat automat manifesturile resurselor. Acum nu ne rămâne decât să aplicăm totul în clusterul Kubernetes. Pentru a implementa aplicația, putem folosi comanda kubectl apply -f, dar pluginul poate face acest lucru în locul nostru. Iată ce va apărea pe ecran după ce cerem lui Eclipse JKube să execute sarcina apply mvn k8s:apply:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:apply
[INFO] Scanare pentru proiecte...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Construire random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] k8s: Folosind Kubernetes la https:\/\/192.168.39.145:8443\/ în namespace default cu manifestul \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/classes\/META-INF\/jkube\/kubernetes.yml
[INFO] k8s: Folosind namespace: default
[INFO] k8s: Crearea unui Serviciu din kubernetes.yml namespace default nume random-generator
[INFO] k8s: Serviciu creat: target\/jkube\/applyJson\/default\/service-random-generator.json
[INFO] k8s: Crearea unei Deployments din kubernetes.yml namespace default nume random-generator
[INFO] k8s: Deployment creat: target\/jkube\/applyJson\/default\/deployment-random-generator.json
[INFO] k8s: SUGESTIE: Utilizați comanda `kubectl get pods -w` pentru a urmări pornirea pod-urilor dumneavoastră
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUCȚIE REUȘITĂ
[INFO] ------------------------------------------------------------------------
[INFO] Timp total: 7.306 s
[INFO] Terminată la: 2020-08-10T11:40:57+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get pods -w
NUME READY STATUS RESTARTS VÂRSTĂ
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
NUME TIP CLUSTER-IP EXTERNAL-IP PORT(S) VÂRSTĂ
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 % Recepit % Transferat Viteza Medie Timp Timp Timp Curent
Dload Upload Total Petrecut Rămâne Viteză
100 45 0 45 0 0 1800 0 --:--:-- --:--:-- --:--:-- 1875
{
"id": "42e5571f-a20f-44b3-8184-370356581d10"
}
Pasul 6. Facem undeploy aplicației din clusterul Kubernetes
Pentru aceasta se folosește sarcina undeploy, care pur și simplu șterge toate resursele care au fost aplicate la pasul anterior, adică în timpul executării sarcinii apply. Iată ce vom vedea pe ecran după ce cerem Eclipse JKube să execute sarcina undeploy cu 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 : $
Ce altceva mai poți face cu Eclipse JKube
Așadar, am discutat despre principalele sarcini ale Eclipse JKube și ale Kubernetes Maven Plugin, care facilitează dezvoltarea aplicațiilor Java pentru platforma Kubernetes. Dacă nu dorești să introduci aceste sarcini în mod constant de la tastatură, le poți adăuga în configurația pluginului, de exemplu, astfel:
org.eclipse.jkube
kubernetes-maven-plugin
${project.version}
build
resource
apply
Trebuie să spunem că în acest articol am discutat doar despre o parte din sarcinile disponibile în Eclipse JKube și Kubernetes Maven Plugin, așa că prezentăm în Tabelul 2 lista sarcinilor suplimentare care ar putea să-ți fie utile.
Tabelul 2. Sarcini suplimentare Eclipse JKube.
Sarcină
Etapa
Descriere
VALIDATE
Obținerea logurilor de la aplicația care rulează pe Kubernetes.
PACKAGE
Deschiderea portului de depanare pentru a facilita depanarea aplicației care rulează pe Kubernetes direct din IDE.
INSTALL
Crearea unui fork pentru task-ul Install și aplicarea manifestelor generate în clusterul Kubernetes la fel ca în cazul task-ului apply.
PACKAGE
Implementarea automată a aplicației prin monitorizarea spațiului său de nume.
Implementarea aplicațiilor Java pe Red Hat OpenShift folosind OpenShift Maven Plugin
Pentru a implementa aplicația din exemplul nostru pe platforma Red Hat OpenShift, vom folosi plugin-ul . Singura diferență va fi că prefixul task-urilor se va schimba de la k8s la oc. În mod implicit, plugin-ul Kubernetes Maven efectuează -build-uri, în timp ce plugin-ul OpenShift Maven efectuează build-uri. . Nu facem nicio modificare în proiectul nostru, cu excepția eliminării proprietății jkube.generator.name, deoarece aceasta nu este necesară la trimiterea în registru (în etapa de construire, OpenShift plasează imaginea în registrul său intern). Iată ce va apărea pe ecran atunci când vom rula exemplul nostru, în care, de altfel, executăm task-urile nu una câte una, ci pe toate simultan:
~\/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 : $
Tutorial video
Pentru a afla mai multe despre cum să simplifici dezvoltarea Kubernetes cu Eclipse JKube, vizionați tutorialul video privind desfășurarea rapidă a unei aplicații simple Spring Boot pe Minikube:
Concluzie
În acest articol am arătat cum Eclipse JKube face viața mai ușoară pentru dezvoltatorii Java în lucrul cu Kubernetes. Informații suplimentare despre Eclipse JKube pot fi găsite pe și pe .
Sursa: habr.com
