25 anni fa, Java è entrato nella corrente principale della programmazione e alla fine è diventato uno degli elementi fondamentali attorno ai quali sono costruiti gli stack di applicazioni. Oggi, tuttavia, molte persone e organizzazioni fedeli a Java da molti anni sono impegnate a migrare o stanno valutando la possibilità di migrare alla piattaforma. o suoi derivati come o .
Sfortunatamente, Kubernetes ha una curva di apprendimento ripida e introduce un altro livello operativo nel processo di sviluppo a cui sono abituati i programmatori Java. Oggi ti diremo come usarlo , per semplificare queste operazioni aggiuntive associate a Kubernetes e ai contenitori e garantire una migrazione indolore alla piattaforma cloud mantenendo il familiare ecosistema Java. Inoltre, mostreremo come distribuire applicazioni Java sulla piattaforma OpenShift utilizzando il plugin OpenShift Maven.
Processo di sviluppo Java tradizionale
Processo di sviluppo tradizionale (Figura 1) prevede che lo sviluppatore scriva il codice, quindi crei unità di distribuzione sotto forma di file JAR o WAR e quindi distribuisca ed esegua questi file su un server Web o applicativo. Il modo principale per farlo è utilizzare Maven dalla riga di comando o utilizzare un IDE come IntelliJ o Eclipse per codificare e pacchettizzare le applicazioni. Gli sviluppatori sono abituati ad apportare modifiche al codice e a testare tutto accuratamente prima di confermare il codice e sottoporlo al controllo della versione.
Riso. 1. Processo di sviluppo Java tradizionale.
Processo di sviluppo Java per il cloud
Quando si passa alle applicazioni cloud, Kubernetes e . Pertanto, ora lo sviluppatore deve pacchettizzare le applicazioni Java e creare manifest Kubernetes che descrivono queste immagini. Questi manifesti vengono quindi applicati al server di produzione che esegue Kubernetes. A sua volta, Kubernetes prende queste immagini dal registro e distribuisce le applicazioni in base alle configurazioni che abbiamo scritto nei manifest, che solitamente sono file YAML.
La metamorfosi del tradizionale processo di sviluppo Java nella transizione al cloud è mostrata in Fig. 2.
Riso. 2. Processo di sviluppo Java per il cloud.
Eclissi JKube
La migrazione a Kubernetes aggiunge un altro livello operativo al processo di sviluppo e molti sviluppatori ne sono nervosi perché vogliono concentrarsi sul loro lavoro principale, ovvero la logica dell'applicazione, piuttosto che su come distribuirla. Ed è qui che entra in gioco. , che consente agli sviluppatori di utilizzare le proprie librerie e plug-in ( con o ) per eseguire senza sforzo operazioni relative al contenitore e a Kubernetes seguendo il diagramma in Figura. 2.
Nel resto di questo articolo ti mostreremo come semplificare il processo di sviluppo Java nell'ambiente Kubernetes utilizzando Eclipse JKube con il plug-in Kubernetes Maven.
Processo di sviluppo cloud utilizzando Eclipse JKube
Consideriamo uno schema di sviluppo Java leggermente modificato per il cloud dalla Fig. 2, introducendovi Eclipse JKube e Kubernetes Maven Plugin, come mostrato in Fig. 3.
Riso. 3. Processo di sviluppo Java per il cloud utilizzando Eclipse JKube.
Come possiamo vedere, qui tutte le operazioni per interagire con Kubernetes e i contenitori (evidenziate in rosso nel diagramma) sono sostituite dalle attività obiettivo predefinite di Eclipse JKube, elencate nella Tabella. 1.
Tavolo 1. Attività predefinite di Eclipse JKube.
Compito
Palcoscenico
descrizione
PRE_INTEGRAZIONE_TEST
Creazione di immagini della finestra mobile
INSTALLARE
Caricamento delle immagini della finestra mobile nel registro
PROCESSO_RISORSE
Generazione di manifest K8
COMPILARE
Applicazione dei manifest generati ai K8
NON DISTRIBUIRE
Rimozione delle risorse K8s distribuite utilizzando k8s:apply e k8s:deploy
Nota: Se non desideri che le attività utilizzino queste impostazioni predefinite supponenti, puoi configurare manualmente Eclipse JKube, poiché supporta la configurazione tramite и .
Ora diamo un'occhiata agli esempi di utilizzo di Eclipse JKube e Kubernetes Maven Plugin quando si lavora con le applicazioni.
Distribuzione di un'applicazione Java su Kubernetes utilizzando Eclipse JKube
In questo esempio distribuiremo una semplice applicazione Java su un cluster utilizzando Eclipse JKube. Utilizzando il plugin Kubernetes Maven, possiamo impostare i parametri di distribuzione senza dover scrivere alcuna configurazione.
Come applicazione di esempio utilizziamo , che produce un output JSON nell'endpoint /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"
}
Passaggio 1. Scarica il plug-in Kubernetes Maven
Il plugin Kubernetes Maven è nel repository . Per utilizzare Eclipse JKube devi aggiungere il plugin Kubernetes Maven al tuo pom.xml come dipendenza:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>kubernetes-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Se viene utilizzato OpenShift anziché Kubernetes puro, pom.xml viene modificato come segue:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>openshift-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Passaggio 2. Costruisci l'immagine della finestra mobile
Il file JAR dell'applicazione può essere creato con il comando mvn package, quindi l'attività obiettivo mvn k8s:build può essere utilizzata per creare un'immagine docker dell'applicazione. Tieni presente che abbiamo sovrascritto il nome dell'immagine predefinito con questa proprietà:
<jkube.generator.name>docker.io/rohankanojia/random-generator:${project.version}</jkube.generator.name>
Prima di creare l'immagine, è necessario assicurarsi che il demone docker sia esposto correttamente. Questo può essere fatto con il seguente comando:
$ eval $(minikube docker-env)
Quindi inseriamo il comando mvn k8s:build e questo è ciò che vedremo sullo schermo durante la creazione dell'immagine docker utilizzando l'attività di compilazione 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 : $
Passaggio 3. Carica l'immagine nel registro della finestra mobile
Dopo aver creato l'immagine docker con il registro push configurato (nel nostro caso è docker.io), possiamo inviare questa immagine al registro. Questo è ciò che verrà visualizzato dopo aver chiesto a Eclipse JKube di eseguire l'attività 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 : $
Dopo aver inviato l'immagine, è necessario verificare che sia inclusa nel registro. Nel nostro caso, lo vediamo semplicemente nel Docker Hub, come mostrato in Fig. 4.
Riso. 4. L'immagine inviata al registro è apparsa in Docker Hub.
Passaggio 4. Genera manifest delle risorse Kubernetes per l'applicazione
Quindi, abbiamo raccolto l'immagine dell'applicazione, ora dobbiamo scrivere i manifest Kubernetes. Per fare ciò, Eclipse JKube ha un'attività che genera manifesti di risorse rigidi basati sul framework Java sottostante (, , Vert.x o qualche altro). Puoi anche personalizzare il manifest utilizzando un file di configurazione XML e inserendo frammenti grezzi (frammenti del manifest della risorsa richiesta) nella cartella dell'applicazione src/main/jkube. In questo caso, la tua configurazione verrà caricata nei manifest generati.
Nel nostro esempio lasciamo tutto così com'è e quindi Eclipse JKube genera un manifest per la distribuzione predefinita e per il servizio con tipo ClusterIP. E solo allora modifichiamo il manifest del servizio per cambiare il tipo di servizio in NodePort. È possibile sovrascrivere il comportamento predefinito utilizzando la seguente proprietà:
<jkube.enricher.jkube-service.type>NodePort</jkube.enricher.jkube-service.type>
Questo è l'aspetto dell'output sullo schermo dopo aver chiesto a Eclipse JKube di eseguire l'attività della risorsa 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 : $
Passaggio 5. Distribuisci l'applicazione al cluster Kubernetes
Ora siamo pronti per distribuire l'applicazione: abbiamo generato la sua immagine e quindi generato automaticamente i manifest delle risorse. Ora non resta che applicare tutto questo al cluster Kubernetes. Per distribuire l'applicazione puoi ovviamente utilizzare il comando kubectl apply -f, ma il plugin può farlo per noi. Questo è ciò che apparirà sullo schermo dopo aver chiesto a Eclipse JKube di eseguire l'attività 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"
}
Passaggio 6. Annulla la distribuzione delle applicazioni dal cluster Kubernetes
Per fare ciò, viene utilizzata l'attività di annullamento della distribuzione, che rimuove semplicemente tutte le risorse applicate nel passaggio precedente, ovvero quando viene eseguita l'attività di applicazione. Questo è ciò che vedremo sullo schermo dopo aver chiesto a Eclipse JKube di eseguire l'attività 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 : $
Cos'altro puoi fare con Eclipse JKube
Quindi, abbiamo esaminato gli obiettivi principali di Eclipse JKube e Kubernetes Maven Plugin, che facilitano lo sviluppo di applicazioni Java per la piattaforma Kubernetes. Se non vuoi inserire costantemente queste attività dalla tastiera, puoi scriverle nella configurazione del plugin, ad esempio, in questo modo:
<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>
Va detto che in questo articolo non abbiamo considerato tutte le attività obiettivo presenti in Eclipse JKube e Kubernetes Maven Plugin, quindi forniamo nella Tabella 2 un elenco di attività aggiuntive che potrebbero esserti utili.
Tavolo 2. Ulteriori attività obiettivo Eclipse JKube.
Compito
Palcoscenico
descrizione
CONVALIDARE
Ricezione di log da un'applicazione in esecuzione su Kubernetes.
PACCHETTO
Apri una porta di debug in modo da poter eseguire il debug della tua applicazione in esecuzione su Kubernetes direttamente dall'IDE.
INSTALLARE
Creare un fork per l'attività Installa e applicare i manifesti generati al cluster Kubernetes come nel caso dell'attività apply.
PACCHETTO
Distribuzione a caldo automatica di un'applicazione monitorandone lo spazio dei nomi.
Distribuzione di applicazioni Java su Red Hat OpenShift utilizzando il plug-in OpenShift Maven
Per distribuire l'applicazione dal nostro esempio sulla piattaforma Red Hat OpenShift, utilizziamo il plugin . L'unica differenza sarà che il prefisso dell'attività cambierà da k8s a oc. Per impostazione predefinita, il plug-in Kubernetes Maven lo fa -assemblies e il plug-in OpenShift Maven - assembly . Non stiamo apportando alcuna modifica al nostro progetto oltre alla rimozione della proprietà jkube.generator.name poiché non è richiesta durante il push nel registro (OpenShift inserisce l'immagine nel suo registro interno durante la fase di creazione). E questo è ciò che apparirà sullo schermo quando eseguiamo il nostro esempio, in cui, tra l'altro, eseguiamo i compiti relativi agli obiettivi non uno alla volta, ma tutti in una volta:
~/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 : $
Videolezione
Per saperne di più su come semplificare lo sviluppo di Kubernetes con Eclipse JKube, guarda questo video tutorial su come distribuire rapidamente una semplice applicazione Spring Boot su Minikube:
conclusione
In questo articolo, abbiamo mostrato come Eclipse JKube semplifichi la vita a uno sviluppatore Java quando lavora con Kubernetes. Maggiori informazioni su Eclipse JKube sono disponibili all'indirizzo e .
Fonte: habr.com