25 anni fa Java è entrato a far parte delle masse di programmatori, diventando alla fine uno dei pilastri attorno ai quali si costruiscono gli stack delle applicazioni. Tuttavia, oggi molte persone e organizzazioni, fedeli a Java da anni, stanno passando o pensando di passare a una piattaforma o ai suoi derivati, come o .
Purtroppo, Kubernetes ha una curva di apprendimento ripida e introduce un ulteriore livello operativo nel processo di sviluppo familiare per i programmatori Java. Oggi parleremo di come utilizzare , per semplificare queste operazioni aggiuntive legate a Kubernetes e ai container, oltre a garantire una migrazione indolore verso una piattaforma cloud mantenendo l'ecosistema Java usuale. Inoltre, mostreremo come distribuire applicazioni Java sulla piattaforma OpenShift utilizzando il plugin OpenShift Maven.
Il processo tradizionale di sviluppo Java
Il processo tradizionale di sviluppo (Fig. 1) implica che il programmatore scriva il codice, poi crei unità di distribuzione sotto forma di file JAR o WAR e infine distribuisca ed esegua questi file su un server web o un server applicativo. Fondamentalmente, ciò viene realizzato tramite Maven dalla riga di comando o utilizzando IDE come IntelliJ o Eclipse, per codificare e impacchettare le applicazioni. Gli sviluppatori sono abituati a apportare modifiche al codice e a testare tutto accuratamente prima di archiviare il codice e inviarlo al sistema di gestione delle versioni.
Fig. 1. Processo tradizionale di sviluppo Java.
Il processo di sviluppo Java per il cloud
Passando alle applicazioni cloud, la schematizzazione sopra descritta aggiunge Kubernetes e . Pertanto, ora il programmatore deve impacchettare le applicazioni Java in e creare manifesti Kubernetes che descrivono queste immagini. Questi manifesti vengono quindi 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 al processo di sviluppo, e molti sviluppatori ne sono nervosi, poiché vogliono concentrarsi sul loro lavoro principale – la logica delle applicazioni – e non su come distribuirle. E qui entra in gioco , che consente agli sviluppatori di utilizzare le proprie librerie e plugin ( insieme a o ), per eseguire senza sforzi le operazioni relative ai contenitori e a Kubernetes, seguendo lo schema mostrato in Fig. 2.
Nella parte restante di questo articolo, mostreremo come semplificare il processo di sviluppo di Java in un ambiente Kubernetes utilizzando Eclipse JKube con il plugin Kubernetes Maven Plugin.
Il processo di sviluppo per il cloud utilizzando Eclipse JKube
Consideriamo uno schema leggermente modificato dello sviluppo Java per il cloud con la Fig. 2, integrando Eclipse JKube e il Kubernetes Maven Plugin, come mostrato in 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 goal predefiniti di Eclipse JKube, che sono elencati nella Tab. 1.
Tab. 1. Obiettivi 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 manifest K8s
COMPILE
Applicazione dei manifest generati a K8s
UNDEPLOY
Rimozione delle risorse K8s che sono state distribuite tramite k8s:apply e k8s:deploy
Nota: Se non si desidera che gli obiettivi utilizzino queste impostazioni predefinite rigide (opinionated defaults), è possibile configurare manualmente Eclipse JKube secondo le proprie esigenze, dato che supporta la configurazione tramite e .
Ora consideriamo alcuni esempi di utilizzo di Eclipse JKube e del Kubernetes Maven Plugin nel lavoro con le app.
Distribuiamo un'app Java in Kubernetes utilizzando Eclipse JKube
In questo esempio, distribuiremo una semplice applicazione Java nel cluster utilizzando Eclipse JKube. Usando il Kubernetes Maven Plugin, possiamo specificare i parametri di distribuzione senza dover definire 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
Scarico Carico Totale Trascorso Rimanente Velocità
100 45 0 45 0 0 818 0 --:--:-- --:--:-- --:--:-- 818
{
"id": "e80a4d10-c79b-4b9a-aaac-7c286cb37f3c"
}
Passo 1. Carichiamo il Plugin Maven Kubernetes
Il Plugin Maven Kubernetes si trova nel repository . Per utilizzare Eclipse JKube è necessario aggiungere il Plugin Maven Kubernetes al proprio pom.xml come dipendenza:
org.eclipse.jkube
kubernetes-maven-plugin
${jkube.version}
Se invece di Kubernetes puro si utilizza OpenShift, il pom.xml viene modificato nel seguente modo:
org.eclipse.jkube
openshift-maven-plugin
${jkube.version}
Passo 2. Costruiamo l'immagine Docker
Il file JAR dell'applicazione può essere costruito con il comando mvn package, dopodiché si può usare il goal mvn k8s:build per creare l'immagine Docker di questa applicazione. Si noti che abbiamo sovrascritto il nome dell'immagine predefinito utilizzando la seguente proprietà:
docker.io/rohankanojia/random-generator:${project.version}
Prima di costruire l'immagine, è necessario assicurarsi che il demone Docker sia esposto correttamente. Questo può essere fatto con il seguente comando:
$ eval $(minikube docker-env)
Dopo, inseriamo il comando mvn k8s:build, ecco cosa vedremo sullo schermo durante la costruzione dell'immagine Docker con 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 al registro Docker
Dopo aver costruito l'immagine Docker con il registro di push impostato (nel nostro caso docker.io), possiamo inviare quest'immagine al registro. Ecco cosa apparirà sullo schermo dopo aver chiesto a Eclipse JKube di eseguire il task di push mvn k8s:push:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:push
[INFO] Scansione dei progetti...
[INFO]
[INFO] ---------------------------------------------
[INFO] Costruzione di random-generator 0.0.1
[INFO] -------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:push (default-cli) @ random-generator ---
[INFO] k8s: Esecuzione in modalità Kubernetes
[INFO] k8s: Creazione dell'immagine Docker in modalità Kubernetes
[INFO] k8s: Esecuzione del generatore spring-boot
[INFO] k8s: spring-boot: Utilizzo dell'immagine Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 come base \/ builder
[INFO] k8s: Il push si riferisce al repository [docker.io\/rohankanojia\/random-generator]
5dcd9556710f: Layer già esistente
b7139ad07aa8: Layer già esistente
b6f081e4b2b6: Layer già esistente
d8e1f35641ac: Layer già esistente
[INFO] k8s: 0.0.1: digest: sha256:9f9eda2a13b8cab1d2c9e474248500145fc09e2922fe3735692f9bda4c76002d dimensione: 1162
[INFO] k8s: Caricato docker.io\/rohankanojia\/random-generator:0.0.1 in 7 secondi
[INFO] ------------------------------------------------------------------------
[INFO] COSTRUZIONE RIUSCITA
[INFO] ------------------------------------------------------------------------
[INFO] Tempo totale: 11.222 s
[INFO] Terminato alle: 2020-08-10T11:35:37+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $
Dopo aver inviato l'immagine, è necessario verificare che sia stata caricata nel registro. Nel nostro caso, possiamo semplicemente vederla in Docker Hub, come mostrato in Fig. 4.
Fig. 4. L'immagine inviata al registro è apparsa in Docker Hub.
Passaggio 4. Generiamo i manifesti delle risorse Kubernetes per l'applicazione
Quindi, abbiamo costruito l'immagine dell'applicazione, ora 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 qualsiasi altro). È anche possibile configurare il manifesto utilizzando un file XML di configurazione e posizionando frammenti raw (frammenti del manifesto delle risorse richieste) nella cartella dell'applicazione src\/main\/jkube. In tal caso, la vostra configurazione sarà iniettata nei manifesti generati.
Nel nostro esempio, lasciamo tutto così com'è, e quindi Eclipse JKube genera un manifesto per il deployment predefinito e per il servizio di tipo ClusterIP. Successivamente, 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 a schermo dopo che chiediamo a Eclipse JKube di eseguire il task delle risorse mvn k8s:resource.
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:resource
[INFO] Scansione dei progetti...
[INFO]
[INFO] ---------------------------------------------
[INFO] Creazione random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:resource (default-cli) @ random-generator ---
[INFO] k8s: Esecuzione del generatore spring-boot
[INFO] k8s: spring-boot: Utilizzo dell'immagine Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 come base \/ builder
[INFO] k8s: jkube-controller: Aggiunta di un Deployment predefinito
[INFO] k8s: jkube-service: Aggiunta di un servizio predefinito 'random-generator' con porte [8080]
[INFO] k8s: jkube-healthcheck-spring-boot: Aggiunta di un probe di prontezza sulla porta 8080, percorso='\/actuator\/health', schema='HTTP', con un ritardo iniziale di 10 secondi
[INFO] k8s: jkube-healthcheck-spring-boot: Aggiunta di un probe di vitalità sulla porta 8080, percorso='\/actuator\/health', schema='HTTP', con un ritardo iniziale di 180 secondi
[INFO] k8s: jkube-revision-history: Aggiunta di un limite alla cronologia delle revisioni di 2
[INFO] ------------------------------------------------------------------------
[INFO] COSTRUZIONE RIUSCITA
[INFO] ------------------------------------------------------------------------
[INFO] Tempo totale: 3.344 s
[INFO] Completato il: 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. Distribuiamo l'applicazione nel cluster Kubernetes
Ora abbiamo tutto pronto per eseguire il deployment dell'applicazione: abbiamo generato la sua immagine e poi abbiamo generato automaticamente i manifesti delle risorse. Ora non resta che applicare tutto ciò al cluster Kubernetes. Per distribuire l'applicazione, ovviamente, possiamo utilizzare il comando kubectl apply -f, ma il plugin può farlo per noi. Ecco cosa apparirà sullo schermo dopo che avremo chiesto a Eclipse JKube di eseguire il compito di apply 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. Eseguiamo l'undeploy dell'applicazione dal cluster Kubernetes
Per questo si utilizza il compito undeploy, che elimina semplicemente tutte le risorse che sono state applicate nel passaggio precedente, ovvero durante l'esecuzione del compito apply. Ecco cosa vedremo sullo schermo dopo che chiederemo a Eclipse JKube di eseguire il compito di undeploy mvn k8s:undeploy:
~/work/repos/eclipse-jkube-demo-project : $ kubectl get all
NAME READY STATUS RESTARTS AGE
pod/random-generator-58b7847d7f-9m9df 1/1 In esecuzione 0 5m21s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/kubernetes ClusterIP 10.96.0.1 443/TCP 18d
service/random-generator NodePort 10.97.172.147 8080:32186/TCP 5m21s
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/random-generator 1/1 1 1 5m21s
NAME DESIRED CURRENT READY AGE
replicaset.apps/random-generator-58b7847d7f 1 1 1 5m21s
~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:undeploy
[INFO] Scanning for projects...
[INFO]
[INFO] ---------------------------------------------
[INFO] Building random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:undeploy (default-cli) @ random-generator ---
[INFO] k8s: Using Kubernetes at https://192.168.39.145:8443/ in namespace default with manifest /home/rohaan/work/repos/eclipse-jkube-demo-project/target/classes/META-INF/jkube/kubernetes.yml
[INFO] k8s: Using namespace: default
[INFO] k8s: Deleting resource Deployment default/random-generator
[INFO] k8s: Deleting resource Service default/random-generator
[INFO] k8s: HINT: Use the command `kubectl get pods -w` to watch your pods start up
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.412 s
[INFO] Finished at: 2020-08-10T11:46:22+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $ kubectl get pods -w
^C~/work/repos/eclipse-jkube-demo-project : $ kubectl get all
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/kubernetes ClusterIP 10.96.0.1 443/TCP 18d
~/work/repos/eclipse-jkube-demo-project : $
Cosa altro si può fare con Eclipse JKube
Quindi, abbiamo esaminato 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, puoi scriverli nella configurazione del plugin, ad esempio, in questo modo:
org.eclipse.jkube
kubernetes-maven-plugin
${project.version}
build
resource
apply
Va detto che in questo articolo abbiamo esaminato solo alcune delle possibili operazioni, disponibili in Eclipse JKube e nel Kubernetes Maven Plugin, pertanto presentiamo nella Tab.2 un elenco di ulteriori attività che potrebbero esserti utili.
Tab. 2. Ulteriori operazioni disponibili in Eclipse JKube.
Compito
Fase
Descrizione
VALIDATE
recuperare i log da un'applicazione in esecuzione su Kubernetes.
PACKAGE
Apertura della porta di debug per eseguire il debug dell'applicazione in esecuzione su Kubernetes direttamente dall'IDE.
INSTALL
Creazione di un fork per il task di installazione e applicazione dei manifesti generati al cluster Kubernetes proprio come nel caso del task apply.
PACKAGE
Distribuzione automatica e istantanea dell'applicazione monitorando il suo namespace.
Distribuzione di applicazioni Java su Red Hat OpenShift utilizzando OpenShift Maven Plugin.
Per distribuire l'applicazione dal nostro esempio sulla piattaforma Red Hat OpenShift, utilizzeremo il plugin . L'unica differenza sarà che il prefisso dei task cambierà da k8s a oc. Per impostazione predefinita, il plugin Kubernetes Maven esegue -build, mentre il plugin OpenShift Maven esegue build. . Non apportiamo alcuna modifica al nostro progetto, ad eccezione della rimozione della proprietà jkube.generator.name, poiché non è necessaria quando si invia al registro (nella fase di build, OpenShift colloca l'immagine nel suo registro interno). Ecco cosa apparirà sullo schermo quando eseguiremo il nostro esempio, in cui, a proposito, eseguiamo i goal dei task non uno alla volta, ma tutti insieme:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn oc:build oc:resource oc:apply
[INFO] Scansione dei progetti in corso...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Creazione di random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] oc: Utilizzando la build di OpenShift con strategia S2I
[INFO] oc: Esecuzione in modalità OpenShift
[INFO] oc: Esecuzione del generatore spring-boot
[INFO] oc: spring-boot: Utilizzo dell'immagine Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 come base \/ builder
[INFO] oc: [random-generator:0.0.1] "spring-boot": Creata tar sorgente docker \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/docker\/random-generator\/0.0.1\/tmp\/docker-build.tar
[INFO] oc: Aggiunta a Secret pullsecret-jkube
[INFO] oc: Utilizzo del Secret pullsecret-jkube
[INFO] oc: Creazione di BuildServiceConfig random-generator-s2i per la build di sorgente
[INFO] oc: Creazione di ImageStream random-generator
[INFO] oc: Avvio della build random-generator-s2i
[INFO] oc: In attesa che la build random-generator-s2i-1 si completi...
[INFO] oc: Memorizzazione dei blob in "\/var\/cache\/blobs".
[INFO] oc: Ottenimento delle firme delle sorgenti delle immagini
[INFO] oc: Copia del blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Copia del blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Copia del blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Copia della configurazione sha256:52d6788fcfdd39595264d34a3959464a5dabc1d4ef0ae188802b20fc2d6a857b
[INFO] oc: Scrittura del manifesto nella destinazione dell'immagine
[INFO] oc: Memorizzazione delle firme
[INFO] oc: Generazione del Dockerfile con l'immagine builder quay.io\/jkube\/jkube-java-binary-s2i:0.0.7
[INFO] oc: PASSO 1: DA quay.io\/jkube\/jkube-java-binary-s2i:0.0.7
[INFO] oc: PASSO 2: ETICHETTA "io.openshift.build.source-location"="\/tmp\/build\/inputs" "io.openshift.build.image"="quay.io\/jkube\/jkube-java-binary-s2i:0.0.7"
[INFO] oc: PASSO 3: ENV JAVA_APP_DIR="\/deployments" OPENSHIFT_BUILD_NAME="random-generator-s2i-1" OPENSHIFT_BUILD_NAMESPACE="default"
[INFO] oc: PASSO 4: UTENTE root
[INFO] oc: PASSO 5: COPIA upload\/src \/tmp\/src
[INFO] oc: PASSO 6: ESEGUI chown -R 1000:0 \/tmp\/src
[INFO] oc: PASSO 7: UTENTE 1000
[INFO] oc: PASSO 8: ESEGUI \/usr\/local\/s2i\/assemble
[INFO] oc: INFO Build S2I sorgente con binari semplici rilevato
[INFO] oc: INFO Build S2I binaria da fabric8-maven-plugin rilevato
[INFO] oc: INFO Copia dei binari da \/tmp\/src\/deployments a \/deployments ...
[INFO] oc: random-generator-0.0.1.jar
[INFO] oc: INFO Copia delle distribuzioni da deployments a \/deployments...
[INFO] oc: '\/tmp\/src\/deployments\/random-generator-0.0.1.jar' -> '\/deployments\/random-generator-0.0.1.jar'
[INFO] oc: PASSO 9: CMD \/usr\/local\/s2i\/run
[INFO] oc: PASSO 10: IMPEGNARE temp.builder.openshift.io\/default\/random-generator-s2i-1:48795e41
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Mismatch nel sistema operativo dell'immagine: l'immagine usa "", aspettandosi "linux""
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Mismatch nell'architettura dell'immagine: l'immagine usa "", aspettandosi "amd64""
[INFO] oc: Ottenimento delle firme delle sorgenti delle immagini
[INFO] oc: Copia del blob sha256:d8e1f35641acb80b562f70cf49911341dfbe8c86f4d522b18efbf3732aa74223
[INFO] oc: Copia del blob sha256:b6f081e4b2b6de8be4b1dec132043d14c121e968384dd624fb69c2c07b482edb
[INFO] oc: Copia del blob sha256:b7139ad07aa8ce4ed5a132f7c5cc9f1de0f5099b5e155027a23d57f7fbe78b16
[INFO] oc: Copia del blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Copia della configurazione sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Scrittura del manifesto nella destinazione dell'immagine
[INFO] oc: Memorizzazione delle firme
[INFO] oc: --> 27aaadaf28e
[INFO] oc: 27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Ottenimento delle firme delle sorgenti delle immagini
[INFO] oc:
[INFO] oc: Invio dell'immagine image-registry.openshift-image-registry.svc:5000\/default\/random-generator:0.0.1 ...
[INFO] oc: Copia del blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Copia del blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Copia del blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Copia del blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Copia della configurazione sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Scrittura del manifesto nella destinazione dell'immagine
[INFO] oc: Memorizzazione delle firme
[INFO] oc: Immagine-invio avvenuto con successo image-registry.openshift-image-registry.svc:5000\/default\/random-generator@sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: Invio avvenuto con successo
[INFO] oc: Build random-generator-s2i-1 nello stato Completo
[INFO] oc: Trovato tag su ImageStream random-generator tag: sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: ImageStream random-generator scritto in \/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: Utilizzo del nome dell'immagine docker dello spazio dei nomi: default
[INFO] oc: Esecuzione del generatore spring-boot
[INFO] oc: spring-boot: Utilizzo dell'immagine Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 come base \/ builder
[INFO] oc: jkube-controller: Aggiunta di un DeploymentConfig predefinito
[INFO] oc: jkube-service: Aggiunta di un servizio predefinito 'random-generator' con porte [8080]
[INFO] oc: jkube-healthcheck-spring-boot: Aggiunta della probe di prontezza sulla porta 8080, percorso='\/actuator\/health', schema='HTTP', con un ritardo iniziale di 10 secondi
[INFO] oc: jkube-healthcheck-spring-boot: Aggiunta della probe di liveness sulla porta 8080, percorso='\/actuator\/health', schema='HTTP', con un ritardo iniziale di 180 secondi
[INFO] oc: jkube-revision-history: Aggiunta del limite della cronologia delle revisioni a 2
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] oc: Utilizzo di OpenShift su https:\/\/api.crc.testing:6443\/ nello spazio dei nomi default con manifesto \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/classes\/META-INF\/jkube\/openshift.yml
[INFO] oc: Piattaforma OpenShift rilevata
[INFO] oc: Utilizzo del progetto: default
[INFO] oc: Creazione di un servizio da openshift.yml spazio dei nomi default nome random-generator
[INFO] oc: Servizio creato: target\/jkube\/applyJson\/default\/service-random-generator.json
[INFO] oc: Creazione di un DeploymentConfig da openshift.yml spazio dei nomi default nome random-generator
[INFO] oc: DeploymentConfig creato: target\/jkube\/applyJson\/default\/deploymentconfig-random-generator.json
[INFO] oc: Creazione di Route default:random-generator host: null
[INFO] oc: HINT: Utilizza il comando `oc get pods -w` per monitorare l'avvio dei tuoi pods
[INFO] ------------------------------------------------------------------------
[INFO] BUILD RIUSCITO
[INFO] ------------------------------------------------------------------------
[INFO] Tempo totale: 01:07 min
[INFO] Terminato alle: 2020-08-10T12:08:00+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $ oc get pods -w
NOME PRONTO STATO RISTARTS ETA
random-generator-1-deploy 1\/1 Esecuzione 0 14s
random-generator-1-vnrm9 0\/1 Esecuzione 0 11s
random-generator-s2i-1-build 0\/1 Completato 0 1m
random-generator-1-vnrm9 1\/1 Esecuzione 0 24s
random-generator-1-deploy 0\/1 Completato 0 28s
~\/work\/repos\/eclipse-jkube-demo-project : $ oc get routes
NOME HOST\/PORT PERCORSO SERVIZI PORTA TERMINAZIONE WILDCARD
random-generator random-generator-default.apps-crc.testing random-generator 8080 Nessuno
~\/work\/repos\/eclipse-jkube-demo-project : $ curl random-generator-default.apps-crc.testing\/random
% Totale % Ricevuto % Trasferito Media Velocità Tempo Tempo Tempo Corrente
Dscarica Carica Totale Speso Rimasto Velocità
100 45 0 45 0 0 1666 0 --:--:-- --:--:-- --:--:-- 1730
{
"id": "d80052d9-2f92-43cb-b9eb-d7cffb879798"
}
~\/work\/repos\/eclipse-jkube-demo-project : $
Video-lezione
Per saperne di più su come semplificare lo sviluppo Kubernetes con Eclipse JKube, guarda la video-lezione su come distribuire rapidamente una semplice applicazione Spring Boot su Minikube:
Conclusione
In questo articolo abbiamo mostrato come Eclipse JKube faciliti la vita ai programmatori Java quando lavorano con Kubernetes. Maggiori informazioni su Eclipse JKube possono essere trovate su e su .
Fonte: habr.com
