În urmă cu 25 de ani, Java a intrat în curentul principal al programării și a devenit în cele din urmă unul dintre elementele de bază în jurul cărora sunt construite stivele de aplicații. Astăzi, totuși, mulți oameni și organizații care au fost loiali Java de mulți ani sunt ocupați cu migrarea sau iau în considerare migrarea către platformă. sau derivatele sale precum sau .
Din păcate, Kubernetes are o curbă de învățare abruptă și introduce un alt nivel operațional în procesul de dezvoltare cu care sunt obișnuiți programatorii Java. Astăzi vă vom spune cum să utilizați , pentru a simplifica aceste operațiuni suplimentare asociate cu Kubernetes și containere și pentru a asigura o migrare fără durere la platforma cloud, menținând în același timp ecosistemul Java familiar. Mai mult, vom arăta cum să implementăm aplicații Java pe platforma OpenShift folosind pluginul OpenShift Maven.
Procesul tradițional de dezvoltare Java
Procesul de dezvoltare tradițional (Figura 1) implică dezvoltatorul care scrie cod, apoi creează unități de implementare sub formă de fișiere JAR sau WAR și apoi implementează și rulează aceste fișiere pe un server web sau de aplicații. Principala modalitate de a face acest lucru este să utilizați Maven din linia de comandă sau să folosiți un IDE precum IntelliJ sau Eclipse pentru a codifica și a împacheta aplicațiile. Dezvoltatorii sunt obișnuiți să efectueze modificări de cod și să testeze totul în detaliu înainte de a comite codul și de a-l supune controlului versiunii.
Orez. 1. Procesul tradițional de dezvoltare Java.
Procesul de dezvoltare Java pentru cloud
Când treceți la aplicații cloud, Kubernetes și . Prin urmare, acum dezvoltatorul trebuie să împacheteze aplicațiile Java în și creați manifeste Kubernetes care descriu aceste imagini. Aceste manifeste sunt apoi aplicate serverului de producție care rulează Kubernetes. La rândul său, Kubernetes preia aceste imagini din registry și implementează aplicații conform configurațiilor pe care le-am scris în manifeste, care sunt de obicei fișiere YAML.
Metamorfoza procesului tradițional de dezvoltare Java în tranziția către cloud este prezentată în Fig. 2.
Orez. 2. Procesul de dezvoltare Java pentru cloud.
Eclipsa JKube
Migrarea la Kubernetes adaugă un alt nivel operațional procesului de dezvoltare, iar mulți dezvoltatori sunt îngrijorați de acest lucru, deoarece doresc să se concentreze pe munca lor de bază – logica aplicației – mai degrabă decât asupra modului de implementare. Și aici intră în joc. , care permite dezvoltatorilor să-și folosească bibliotecile și pluginurile ( cu sau ) pentru a efectua fără efort operațiuni legate de container și Kubernetes, urmând diagrama din figură. 2.
În restul acestui articol, vă vom arăta cum să simplificați procesul de dezvoltare Java în mediul Kubernetes folosind Eclipse JKube cu Plugin-ul Kubernetes Maven.
Procesul de dezvoltare în cloud folosind Eclipse JKube
Să luăm în considerare o schemă de dezvoltare Java ușor modificată pentru cloud din Fig. 2, introducând Eclipse JKube și Kubernetes Maven Plugin în ea, așa cum se arată în Fig. 3.
Orez. 3. Proces de dezvoltare Java pentru cloud folosind Eclipse JKube.
După cum putem vedea, aici toate operațiunile pentru interacțiunea cu Kubernetes și containerele (evidențiate cu roșu în diagramă) sunt înlocuite implicit sarcinile obiectivului Eclipse JKube, care sunt listate în Tabel. 1.
Masa 1. Sarcini implicite Eclipse JKube.
Sarcină
etapă
descriere
PRE_INTEGRARE_TEST
Construirea imaginilor docker
INSTALARE
Încărcarea imaginilor Docker în registry
PROCESS_RESOURCES
Generarea manifestelor K8
COMPILA
Aplicarea manifestelor generate la K8-uri
DESPLAREA
Eliminarea resurselor K8s care au fost implementate folosind k8s:apply și k8s:deploy
Nota: Dacă nu doriți ca sarcinile să folosească aceste valori implicite obișnuite, puteți configura manual Eclipse JKube pentru dvs., deoarece acceptă configurarea prin и .
Acum să ne uităm la exemple de utilizare a Eclipse JKube și Kubernetes Maven Plugin atunci când lucrați cu aplicații.
Implementarea unei aplicații Java pe Kubernetes folosind Eclipse JKube
În acest exemplu vom implementa o aplicație Java simplă pe un cluster folosind Eclipse JKube. Folosind Plugin-ul Kubernetes Maven, putem seta parametrii de implementare fără a fi nevoie să scriem nicio configurație.
Ca exemplu de aplicație pe care o folosim , care produce ieșire JSON la punctul final /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. Descărcați pluginul Kubernetes Maven
Pluginul Kubernetes Maven este în depozit . Pentru a utiliza Eclipse JKube, trebuie să adăugați pluginul Kubernetes Maven la pom.xml dvs. ca dependență:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>kubernetes-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Dacă se folosește OpenShift în loc de Kubernetes pur, atunci pom.xml este modificat după cum urmează:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>openshift-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Pasul 2. Creați imaginea docker
Fișierul JAR al aplicației poate fi construit cu comanda mvn package, iar apoi sarcina obiectiv mvn k8s:build poate fi folosită pentru a construi o imagine docker a aplicației. Rețineți că am înlocuit numele implicit al imaginii cu această proprietate:
<jkube.generator.name>docker.io/rohankanojia/random-generator:${project.version}</jkube.generator.name>
Înainte de a construi imaginea, trebuie să vă asigurați că demonul docker este expus corect. Acest lucru se poate face cu următoarea comandă:
$ eval $(minikube docker-env)
Apoi introducem comanda mvn k8s:build și aceasta este ceea ce vom vedea pe ecran când construim imaginea docker folosind sarcina de construire Eclipse JKube:
~/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 : $
Pasul 3. Încărcați imaginea în registrul docker
După ce am construit imaginea docker cu registrul push configurat (în cazul nostru este docker.io), putem trimite această imagine către registry. Acesta este ceea ce va fi afișat după ce vom cere Eclipse JKube să efectueze sarcina mvn k8s:push push:
~/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 : $
După trimiterea imaginii, trebuie să verificați dacă este inclusă în registru. În cazul nostru, îl vedem pur și simplu în Docker Hub, așa cum se arată în Fig. 4.
Orez. 4. Imaginea trimisă la registry a apărut în Docker Hub.
Pasul 4. Generați manifeste de resurse Kubernetes pentru aplicație
Deci, am colectat imaginea aplicației, acum trebuie să scriem manifeste Kubernetes. Pentru a face acest lucru, Eclipse JKube are o sarcină care generează manifeste de resurse rigide pe baza cadrului Java subiacent (, , Vert.x sau altele). De asemenea, puteți personaliza manifestul utilizând un fișier de configurare XML și plasând fragmente brute (fragmente din manifestul resurselor necesare) în folderul aplicației src/main/jkube. În acest caz, configurația dvs. va fi încărcată în manifestele generate.
În exemplul nostru, lăsăm totul așa cum este și, prin urmare, Eclipse JKube generează un manifest pentru implementarea implicită și pentru serviciul cu tip ClusterIP. Și numai atunci modificăm manifestul serviciului pentru a schimba tipul de serviciu în NodePort. Puteți suprascrie comportamentul implicit folosind următoarea proprietate:
<jkube.enricher.jkube-service.type>NodePort</jkube.enricher.jkube-service.type>
Așa arată rezultatul ecranului după ce îi cerem lui Eclipse JKube să efectueze sarcina de resurse mvn k8s:resource.
~/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 : $
Pasul 5. Implementați aplicația în cluster-ul Kubernetes
Acum suntem gata să implementăm aplicația: i-am generat imaginea și apoi am generat automat manifeste de resurse. Acum tot ce rămâne este să aplici toate acestea clusterului Kubernetes. Pentru a implementa aplicația, puteți, desigur, să utilizați comanda kubectl apply -f, dar pluginul poate face acest lucru pentru noi. Acesta este ceea ce va apărea pe ecran după ce vom cere lui Eclipse JKube să execute sarcina mvn k8s:apply apply:
~/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"
}
Pasul 6. Anulați implementarea aplicațiilor din clusterul Kubernetes
Pentru a face acest lucru, este utilizată sarcina de anulare implementare, care pur și simplu elimină toate resursele care au fost aplicate în pasul anterior, adică atunci când este executată sarcina de aplicare. Acesta este ceea ce vom vedea pe ecran după ce vom cere lui Eclipse JKube să efectueze sarcina mvn k8s:undeploy 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 <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 : $
Ce altceva poți face cu Eclipse JKube
Așadar, am analizat principalele sarcini ale Eclipse JKube și Kubernetes Maven Plugin, care facilitează dezvoltarea aplicațiilor Java pentru platforma Kubernetes. Dacă nu doriți să introduceți în mod constant aceste sarcini de la tastatură, le puteți scrie în configurația pluginului, de exemplu, astfel:
<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>
Trebuie spus că în acest articol nu am luat în considerare toate sarcinile obiectiv care se află în Eclipse JKube și Kubernetes Maven Plugin, așa că vă oferim în Tabelul 2 o listă de sarcini suplimentare care vă pot fi și utile.
Masa 2. Sarcini suplimentare pentru obiectivul Eclipse JKube.
Sarcină
etapă
descriere
VALIDA
Primirea jurnalelor de la o aplicație care rulează pe Kubernetes.
PACHET
Deschideți un port de depanare pentru a vă putea depana aplicația care rulează pe Kubernetes direct din IDE.
INSTALARE
Crearea unui furk pentru sarcina de instalare și aplicarea manifestelor generate clusterului Kubernetes în același mod ca și în cazul sarcinii de aplicare.
PACHET
Implementarea automată la cald a unei aplicații prin urmărirea spațiului de nume.
Implementarea aplicațiilor Java pe Red Hat OpenShift utilizând pluginul OpenShift Maven
Pentru a implementa aplicația din exemplul nostru pe platforma Red Hat OpenShift, folosim pluginul . Singura diferență va fi că prefixul sarcinii se va schimba de la k8s la oc. În mod implicit, pluginul Kubernetes Maven o face -ansambluri și pluginul OpenShift Maven - ansambluri . Nu facem nicio modificare în proiectul nostru, în afară de eliminarea proprietății jkube.generator.name, deoarece nu este necesară la împingerea în registru (OpenShift plasează imaginea în registrul său intern în timpul fazei de construire). Și aceasta este ceea ce va apărea pe ecran atunci când rulăm exemplul nostru, în care, apropo, îndeplinim sarcinile obiectiv nu pe rând, ci toate odată:
~/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 : $
Lecție video
Pentru a afla mai multe despre cum să faci dezvoltarea Kubernetes mai ușoară cu Eclipse JKube, urmăriți acest tutorial video despre cum să implementați rapid o aplicație Spring Boot simplă pe Minikube:
Concluzie
În acest articol, am arătat cum Eclipse JKube face viața mai ușoară unui dezvoltator Java atunci când lucrează cu Kubernetes. Mai multe informații despre Eclipse JKube pot fi găsite la și .
Sursa: www.habr.com