Venticinque anni fa, Java ha iniziato a diffondersi tra i programmatori, diventando uno dei fondamenti su cui si costruiscono gli stack applicativi. Tuttavia, oggi molte persone e organizzazioni che per anni sono state fedeli a Java sono impegnate nel passaggio o nell'analisi di passaggio a piattaforme o alle sue derivate, come o .
Purtroppo, Kubernetes presenta una ripida curva di apprendimento e introduce un ulteriore livello operativo nel processo di sviluppo familiare ai programmatori Java. Oggi parleremo di come utilizzare , per semplificare queste operazioni aggiuntive legate a Kubernetes e ai container, garantendo anche una migrazione fluida verso una piattaforma cloud mantenendo l'ecosistema Java consueto. Inoltre, mostreremo come distribuire applicazioni Java sulla piattaforma OpenShift utilizzando il plugin OpenShift Maven.
Il processo tradizionale di sviluppo Java
Il processo di sviluppo tradizionale (Fig.1) implica che lo sviluppatore scrive codice, poi crea unità di distribuzione sotto forma di file JAR o WAR, e successivamente distribuisce ed esegue questi file su un server web o un server applicazioni. Per questo scopo, si utilizza principalmente Maven dalla riga di comando o si usano IDE come IntelliJ o Eclipse per codificare e impacchettare applicazioni. Gli sviluppatori sono abituati a apportare modifiche al codice e a testare accuratamente tutto prima di fissare il codice e inviarlo al sistema di controllo versione.
Fig. 1. Processo tradizionale di sviluppo Java.
Processo di sviluppo Java per il cloud
Passando alle applicazioni cloud, nella schema descritta sopra si aggiungono Kubernetes e . Pertanto, ora lo sviluppatore deve impacchettare le applicazioni Java in e creare manifesti Kubernetes che descrivono queste immagini. Quindi, questi manifesti vengono applicati al server di produzione dove opera Kubernetes. A sua volta, Kubernetes preleva queste immagini dal registro e distribuisce le applicazioni secondo le configurazioni che abbiamo specificato nei manifesti, che di solito sono file YAML.
La metamorfosi del processo tradizionale di sviluppo Java nel passaggio al cloud è mostrata nella Fig. 2.
Fig. 2. Processo di sviluppo Java per il cloud.
Eclipse JKube
Il passaggio a Kubernetes aggiunge un ulteriore livello operativo nel processo di sviluppo, e molti sviluppatori si sentono ansiosi, poiché vogliono concentrarsi sul loro lavoro principale – la logica delle applicazioni – piuttosto che sul modo in cui vengono distribuite. Qui entra in gioco , che consente agli sviluppatori di utilizzare le loro librerie e plugin ( insieme a o ), per eseguire senza sforzo operazioni relative ai container e a Kubernetes, seguendo il diagramma mostrato nella Fig. 2.
Nella restante parte di questo articolo mostreremo come semplificare il processo di sviluppo Java nell'ambiente Kubernetes utilizzando Eclipse JKube con il plugin Kubernetes Maven Plugin.
Processo di sviluppo per il cloud utilizzando Eclipse JKube
Esaminiamo un diagramma leggermente modificato del processo di sviluppo Java per il cloud con la Fig. 2, introducendo Eclipse JKube e il Kubernetes Maven Plugin, come mostrato nella Fig. 3.
Fig. 3. Processo di sviluppo Java per il cloud utilizzando Eclipse JKube.
Come possiamo vedere, tutte le operazioni di interazione con Kubernetes e i contenitori (evidenziate in rosso nello schema) vengono sostituite dai task predefiniti di Eclipse JKube, elencati nella Tab. 1.
Tab. 1. Task predefiniti di Eclipse JKube.
Compito
Fase
Descrizione
PRE_INTEGRATION_TEST
Costruzione delle immagini Docker
INSTALL
Invio delle immagini Docker nel registry
PROCESS_RESOURCES
Generazione dei manifesti K8s
COMPILE
Applicazione dei manifesti generati a K8s
UNDEPLOY
Rimozione delle risorse K8s che sono state distribuite tramite k8s:apply e k8s:deploy
Nota: Se non desideri che i task utilizzino queste rigide impostazioni predefinite (impostazioni opinionali), puoi configurare manualmente Eclipse JKube, poiché supporta la configurazione tramite e .
Ora vediamo esempi di utilizzo di Eclipse JKube e del Kubernetes Maven Plugin quando lavoriamo con le applicazioni.
Distribuiamo un'applicazione Java in Kubernetes utilizzando Eclipse JKube
In questo esempio, distribuiremo una semplice applicazione Java nel cluster utilizzando Eclipse JKube. Con Kubernetes Maven Plugin, possiamo specificare i parametri di distribuzione senza dover scrivere alcuna configurazione.
Come esempio di applicazione, utilizziamo , che restituisce un output JSON all'endpoint /random:
~/work/repos/eclipse-jkube-demo-project : $ curl localhost:8080/random | jq .
% Totale % Ricevuto % Trasferito Velocità Media Tempo Tempo Tempo Corrente
Dload Upload Totale Speso Rimanente Velocità
100 45 0 45 0 0 818 0 --:--:-- --:--:-- --:--:-- 818
{
"id": "e80a4d10-c79b-4b9a-aaac-7c286cb37f3c"
}
Passo 1. Carica il Kubernetes Maven Plugin
Il Kubernetes Maven Plugin si trova nel repository . Per utilizzare Eclipse JKube, è necessario aggiungere il Kubernetes Maven Plugin nel proprio pom.xml come dipendenza:
org.eclipse.jkube
kubernetes-maven-plugin
${jkube.version}
Se invece di Kubernetes puro si utilizza OpenShift, il pom.xml deve essere modificato nel seguente modo:
org.eclipse.jkube
openshift-maven-plugin
${jkube.version}
Passo 2. Costruisce l'immagine docker
Il file JAR dell'applicazione può essere costruito con il comando mvn package, e poi si può utilizzare il goal mvn k8s:build per costruire l'immagine docker di quest'applicazione. Si noti che abbiamo sovrascritto il nome dell'immagine predefinito utilizzando questa proprietà:
docker.io/rohankanojia/random-generator:${project.version}
Prima di creare l'immagine, assicurati che il demone docker sia esposto correttamente. Puoi farlo con il seguente comando:
$ eval $(minikube docker-env)
Successivamente, immetti il comando mvn k8s:build, e vedrai quanto segue sullo schermo durante la costruzione dell'immagine docker utilizzando il task di build di Eclipse JKube:
~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:build
[INFO] Scanning for projects...
[INFO]
[INFO] ---------------------------------------------
[INFO] Building random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] k8s: Running in Kubernetes mode
[INFO] k8s: Building Docker image in Kubernetes mode
[INFO] k8s: Running generator spring-boot
[INFO] k8s: spring-boot: Using Docker image quay.io/jkube/jkube-java-binary-s2i:0.0.7 as base / builder
[INFO] k8s: [docker.io/rohankanojia/random-generator:0.0.1] "spring-boot": Created docker-build.tar in 251 milliseconds
[INFO] k8s: [docker.io/rohankanojia/random-generator:0.0.1] "spring-boot": Built image sha256:a20e5
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 5.053 s
[INFO] Finished at: 2020-08-10T11:28:23+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $
Passo 3. Inviamo l'immagine nel registro docker
Dopo aver creato l'immagine Docker con il registro di push configurato (nel nostro caso docker.io), possiamo inviare quest'immagine al registro. Ecco cosa verrà visualizzato sullo schermo dopo aver chiesto a Eclipse JKube di eseguire il compito di 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 : $
Dopo aver inviato l'immagine, è necessario verificare che sia stata registrata. Nel nostro caso, la vediamo semplicemente su Docker Hub, come mostrato in Fig. 4.
Fig. 4. L'immagine inviata è apparsa su Docker Hub.
Passo 4. Generiamo i manifesti delle risorse Kubernetes per l'applicazione
Ora che abbiamo creato l'immagine dell'applicazione, dobbiamo scrivere i manifesti Kubernetes. A tal fine, in Eclipse JKube c'è un'attività che genera manifesti rigidi delle risorse, basandosi sul framework Java sottostante (, , Vert.x o un altro). È anche possibile configurare il manifesto utilizzando un file XML di configurazione e posizionando frammenti raw (frammenti del manifesto delle risorse richieste) nella cartella src/main/jkube dell'applicazione. In tal caso, la tua configurazione verrà caricata nei manifesti generati.
Nel nostro esempio, lasciamo tutto com'è, quindi Eclipse JKube genera un manifesto per il deployment predefinito e per il servizio di tipo ClusterIP. In seguito, modifichiamo il manifesto del servizio per cambiare il tipo di servizio in NodePort. È possibile sovrascrivere il comportamento predefinito utilizzando la seguente proprietà:
NodePort
Ecco come appare l'output dello schermo dopo aver richiesto a Eclipse JKube di eseguire il task resource mvn k8s:resource.
~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:resource
[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: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: 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 : $
Passo 5. Distribuzione dell'applicazione nel cluster Kubernetes
Ora siamo pronti per procedere con la distribuzione dell'applicazione: abbiamo generato la sua immagine e poi automaticamente creato i manifesti delle risorse. Non resta che applicare tutto questo al cluster Kubernetes. Per distribuire l'applicazione, possiamo naturalmente utilizzare il comando kubectl apply -f, ma il plugin può farlo per noi. Ecco cosa apparirà sullo schermo dopo che chiederemo a Eclipse JKube di eseguire il task apply con mvn k8s:apply:
~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:apply
[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: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 9080:30570/TCP 44h
kubernetes ClusterIP 10.96.0.1 443/TCP 18d
random-generator NodePort 10.97.172.147 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"
}
Passo 6. Effettuare l'undeploy dell'applicazione dal cluster Kubernetes
A tal fine si utilizza il task undeploy, che elimina semplicemente tutte le risorse applicate nel passaggio precedente, ovvero durante l'esecuzione del task apply. Ecco cosa vedremo sullo schermo dopo aver chiesto a Eclipse JKube di eseguire il task di undeploy mvn k8s:undeploy:
~/work/repos/eclipse-jkube-demo-project : $ kubectl get all
NOME PRONTO STATO RIAVVII ETÀ
pod/random-generator-58b7847d7f-9m9df 1/1 In esecuzione 0 5m21s
NOME TIPO CLUSTER-IP EXTERNAL-IP PORT(I) ETÀ
service/kubernetes ClusterIP 10.96.0.1 443/TCP 18d
service/random-generator NodePort 10.97.172.147 8080:32186/TCP 5m21s
NOME PRONTO AGGIORNATO DISPONIBILE ETÀ
deployment.apps/random-generator 1/1 1 1 5m21s
NOME DESIDERATO ATTUALE PRONTO ETÀ
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
NOME TIPO CLUSTER-IP EXTERNAL-IP PORT(I) ETÀ
service/kubernetes ClusterIP 10.96.0.1 443/TCP 18d
~/work/repos/eclipse-jkube-demo-project : $
Cosa altro si può fare con Eclipse JKube
Abbiamo visto i principali obiettivi di Eclipse JKube e del Kubernetes Maven Plugin, che semplificano lo sviluppo di applicazioni Java per la piattaforma Kubernetes. Se non vuoi digitare continuamente questi obiettivi da tastiera, puoi scriverli nella configurazione del plugin, ad esempio in questo modo:
org.eclipse.jkube
kubernetes-maven-plugin
${project.version}
build
resource
apply
Vale la pena notare che in questo articolo non abbiamo trattato tutti gli obiettivi disponibili in Eclipse JKube e nel Kubernetes Maven Plugin, quindi riportiamo nella Tab. 2 un elenco di ulteriori obiettivi che potrebbero esserti utili.
Tab. 2. Ulteriori obiettivi di Eclipse JKube.
Compito
Fase
Descrizione
VALIDA
Ottenere i log dall'applicazione in esecuzione su Kubernetes.
PACCHETTO
Apertura della porta di debug per eseguire il debug dell'applicazione in esecuzione su Kubernetes direttamente dall'IDE.
INSTALL
Creazione di un fork per l'attività Install e applicazione dei manifesti generati al cluster Kubernetes proprio come nel caso dell'attività apply.
PACCHETTO
Distribuzione automatica e immediata dell'applicazione tramite il monitoraggio del suo spazio dei nomi.
Distribuzione di applicazioni Java su Red Hat OpenShift utilizzando il plugin OpenShift Maven
Per distribuire l'applicazione dal nostro esempio sulla piattaforma Red Hat OpenShift, utilizziamo il plugin . L'unica differenza sarà che il prefisso delle attività cambierà da k8s a oc. Per default, il plugin Kubernetes Maven esegue -build, mentre il plugin OpenShift Maven esegue build . Non apportiamo modifiche al nostro progetto, tranne che per rimuovere la proprietà jkube.generator.name, poiché non è necessaria durante l'invio al registro (nella fase di build OpenShift posiziona l'immagine nel proprio registro interno). Ecco cosa apparirà sullo schermo quando eseguiamo il nostro esempio, nel quale, tra l'altro, eseguiamo l'obiettivo delle attività non una alla volta, ma tutte insieme:
~/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 : $
Video tutorial
Per scoprire come semplificare lo sviluppo di Kubernetes con Eclipse JKube, guarda il video tutorial su come distribuire rapidamente una semplice applicazione Spring Boot su Minikube:
Conclusione
In questo articolo abbiamo mostrato come Eclipse JKube renda la vita più facile per gli sviluppatori Java che lavorano con Kubernetes. Ulteriori informazioni su Eclipse JKube possono essere trovate su e su .
Fonte: habr.com
