Fa 25 anys, Java va entrar en el corrent principal de la programació i, finalment, es va convertir en un dels elements bàsics al voltant dels quals es construeixen les piles d'aplicacions. Avui, però, moltes persones i organitzacions que han estat lleials a Java durant molts anys estan ocupades migrant o considerant migrar a la plataforma. o els seus derivats com ara o .
Malauradament, Kubernetes té una corba d'aprenentatge pronunciada i introdueix una altra capa operativa en el procés de desenvolupament al qual estan acostumats els programadors de Java. Avui us explicarem com utilitzar-lo , per simplificar aquestes operacions addicionals associades a Kubernetes i contenidors, i garantir una migració indolora a la plataforma de núvol mentre es manté l'ecosistema Java familiar. A més, mostrarem com implementar aplicacions Java a la plataforma OpenShift mitjançant el connector OpenShift Maven.
Procés de desenvolupament tradicional de Java
Procés de desenvolupament tradicional (Figura 1) implica que el desenvolupador escrigui codi, després creï unitats de desplegament en forma de fitxers JAR o WAR i, a continuació, desplega i executi aquests fitxers en un servidor web o d'aplicacions. La forma principal de fer-ho és utilitzar Maven des de la línia d'ordres o utilitzar un IDE com IntelliJ o Eclipse per codificar i empaquetar les aplicacions. Els desenvolupadors estan acostumats a fer canvis de codi i provar-ho tot a fons abans de confirmar el codi i enviar-lo al control de versions.
Arròs. 1. Procés de desenvolupament tradicional de Java.
Procés de desenvolupament de Java per al núvol
Quan passeu a aplicacions al núvol, Kubernetes i . Per tant, ara el desenvolupador necessita empaquetar aplicacions Java i creeu manifests de Kubernetes que descriguin aquestes imatges. A continuació, aquests manifests s'apliquen al servidor de producció que executa Kubernetes. Al seu torn, Kubernetes agafa aquestes imatges del registre i desplega aplicacions segons les configuracions que hem escrit als manifests, que solen ser fitxers YAML.
La metamorfosi del procés de desenvolupament tradicional de Java en la transició al núvol es mostra a la Fig. 2.
Arròs. 2. Procés de desenvolupament de Java per al núvol.
Eclipsi JKube
La migració a Kubernetes afegeix una altra capa operativa al procés de desenvolupament, i molts desenvolupadors estan nerviosos per això perquè volen centrar-se en el seu treball principal (la lògica de l'aplicació) en lloc de com implementar-los. I aquí és on entra en joc. , que permet als desenvolupadors utilitzar les seves biblioteques i connectors ( amb o ) per realitzar sense esforç operacions relacionades amb el contenidor i Kubernetes seguint el diagrama de la figura. 2.
A la resta d'aquest article, us mostrarem com simplificar el procés de desenvolupament de Java a l'entorn Kubernetes mitjançant l'ús d'Eclipse JKube amb el complement Kubernetes Maven.
Procés de desenvolupament al núvol mitjançant Eclipse JKube
Considerem un esquema de desenvolupament Java lleugerament modificat per al núvol de la figura 2, introduint-hi Eclipse JKube i Kubernetes Maven Plugin, tal com es mostra a la figura. 3.
Arròs. 3. Procés de desenvolupament de Java per al núvol mitjançant Eclipse JKube.
Com podem veure, aquí totes les operacions per interaccionar amb Kubernetes i contenidors (ressaltats en vermell al diagrama) es substitueixen per defecte per les tasques de l'objectiu d'Eclipse JKube, que es mostren a la taula. 1.
Taula 1. Tasques per defecte d'Eclipse JKube.
Tasca
Etapa
Descripció
PRE_INTEGRATION_TEST
Construcció d'imatges docker
INSTAL.LACIÓ
Càrrega d'imatges de Docker al registre
PROCESS_RESOURCES
Generació de manifests K8s
COMPIL
Aplicació de manifests generats als K8
DESDEPLEGAT
Eliminació dels recursos del K8s que es van desplegar amb k8s:apply i k8s:deploy
Nota: Si no voleu que les tasques utilitzin aquests valors predeterminats, podeu configurar Eclipse JKube manualment per vosaltres mateixos, ja que admet la configuració mitjançant и .
Vegem ara exemples d'ús d'Eclipse JKube i Kubernetes Maven Plugin quan es treballa amb aplicacions.
Desplegant una aplicació Java a Kubernetes mitjançant Eclipse JKube
En aquest exemple, desplegarem una aplicació Java senzilla en un clúster utilitzant Eclipse JKube. Mitjançant el complement Kubernetes Maven, podem establir paràmetres de desplegament sense haver d'escriure cap configuració.
Com a exemple d'aplicació fem servir , que produeix una sortida JSON al punt final /aleatori:
~/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"
}
Pas 1. Baixeu el complement Kubernetes Maven
El complement Kubernetes Maven és al repositori . Per utilitzar Eclipse JKube, heu d'afegir el complement Kubernetes Maven al vostre pom.xml com a dependència:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>kubernetes-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Si s'utilitza OpenShift en comptes de Kubernetes pur, llavors pom.xml es modifica de la següent manera:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>openshift-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Pas 2. Creeu la imatge de Docker
El fitxer JAR de l'aplicació es pot crear amb l'ordre mvn package i, a continuació, la tasca mvn goal k8s:build es pot utilitzar per crear una imatge docker de l'aplicació. Tingueu en compte que hem substituït el nom de la imatge per defecte amb aquesta propietat:
<jkube.generator.name>docker.io/rohankanojia/random-generator:${project.version}</jkube.generator.name>
Abans de crear la imatge, heu d'assegurar-vos que el dimoni docker està exposat correctament. Això es pot fer amb l'ordre següent:
$ eval $(minikube docker-env)
A continuació, introduïm l'ordre mvn k8s:build, i això és el que veurem a la pantalla quan es construeix la imatge de docker mitjançant la tasca de compilació d'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 : $
Pas 3. Carregueu la imatge al registre docker
Després d'haver construït la imatge docker amb el registre push configurat (en el nostre cas és docker.io), podem enviar aquesta imatge al registre. Això és el que es mostrarà després de demanar a Eclipse JKube que realitzi la tasca 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 : $
Després d'enviar la imatge, heu de comprovar que estigui inclosa al registre. En el nostre cas, simplement ho veiem a Docker Hub, tal com es mostra a la Fig. 4.
Arròs. 4. La imatge enviada al registre va aparèixer a Docker Hub.
Pas 4. Genereu manifests de recursos de Kubernetes per a l'aplicació
Per tant, hem recollit la imatge de l'aplicació, ara hem d'escriure manifests de Kubernetes. Per fer-ho, Eclipse JKube té una tasca que genera manifests de recursos rígids basats en el marc Java subjacent (, , Vert.x o algun altre). També podeu personalitzar el manifest utilitzant un fitxer de configuració XML i col·locant fragments en brut (fragments del manifest de recursos necessaris) a la carpeta de l'aplicació src/main/jkube. En aquest cas, la vostra configuració es carregarà als manifests generats.
En el nostre exemple, ho deixem tot tal qual, i per tant Eclipse JKube genera un manifest per al desplegament per defecte i per al servei amb tipus ClusterIP. I només llavors modifiquem el manifest del servei per canviar el tipus de servei a NodePort. Podeu substituir el comportament predeterminat mitjançant la propietat següent:
<jkube.enricher.jkube-service.type>NodePort</jkube.enricher.jkube-service.type>
Així es veu la sortida de la pantalla després de demanar a Eclipse JKube que realitzi la tasca 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 : $
Pas 5. Desplegueu l'aplicació al clúster de Kubernetes
Ara ja estem preparats per desplegar l'aplicació: hem generat la seva imatge i després hem generat automàticament els manifests de recursos. Ara només queda aplicar tot això al clúster de Kubernetes. Per implementar l'aplicació, podeu, per descomptat, utilitzar l'ordre kubectl apply -f, però el connector pot fer-ho per nosaltres. Això és el que apareixerà a la pantalla després de demanar a Eclipse JKube que executi la tasca 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"
}
Pas 6. Desplegueu aplicacions del clúster de Kubernetes
Per fer-ho, s'utilitza la tasca de desplegament, que simplement elimina tots els recursos que es van aplicar al pas anterior, és a dir, quan s'executa la tasca d'aplicació. Això és el que veurem a la pantalla després de demanar a Eclipse JKube que realitzi la tasca 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 : $
Què més pots fer amb Eclipse JKube
Així doncs, vam analitzar les principals tasques d'objectiu d'Eclipse JKube i Kubernetes Maven Plugin, que faciliten el desenvolupament d'aplicacions Java per a la plataforma Kubernetes. Si no voleu introduir aquestes tasques constantment des del teclat, podeu escriure-les a la configuració del connector, per exemple, així:
<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>
Cal dir que en aquest article no hem considerat totes les tasques d'objectiu que es troben a Eclipse JKube i Kubernetes Maven Plugin, per la qual cosa proporcionem a la Taula 2 una llista de tasques addicionals que també us poden ser útils.
Taula 2. Tasques addicionals de l'objectiu de l'Eclipse JKube.
Tasca
Etapa
Descripció
VALIDAR
Recepció de registres d'una aplicació que s'executa a Kubernetes.
PAQUET
Obriu un port de depuració perquè pugueu depurar la vostra aplicació que s'executa a Kubernetes directament des de l'IDE.
INSTAL.LACIÓ
Crear una bifurcació per a la tasca d'instal·lació i aplicar els manifestos generats al clúster de Kubernetes de la mateixa manera que en el cas de la tasca d'aplicació.
PAQUET
Desplegament automàtic en calent d'una aplicació mitjançant el seguiment del seu espai de noms.
Desplegament d'aplicacions Java a Red Hat OpenShift mitjançant el connector OpenShift Maven
Per implementar l'aplicació del nostre exemple a la plataforma Red Hat OpenShift, utilitzem el connector . L'única diferència serà que el prefix de la tasca canviarà de k8s a oc. Per defecte, el connector Kubernetes Maven ho fa -assembles i el connector OpenShift Maven - assemblees . No estem fent cap canvi al nostre projecte a part d'eliminar la propietat jkube.generator.name, ja que no és necessari quan s'envia al registre (OpenShift col·loca la imatge al seu registre intern durant la fase de construcció). I això és el que apareixerà a la pantalla quan executem el nostre exemple, en el qual, per cert, realitzem les tasques d'objectiu no una a la vegada, sinó totes alhora:
~/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 : $
Lliçó de vídeo
Per obtenir més informació sobre com facilitar el desenvolupament de Kubernetes amb Eclipse JKube, mireu aquest tutorial de vídeo sobre com implementar ràpidament una aplicació Spring Boot senzilla a Minikube:
Conclusió
En aquest article, vam mostrar com Eclipse JKube facilita la vida a un desenvolupador de Java quan treballa amb Kubernetes. Podeu trobar més informació sobre Eclipse JKube a i .
Font: www.habr.com