Il y a 25 ans, Java est entré dans le courant dominant de la programmation et est finalement devenu l'un des éléments centraux autour desquels sont construites les piles d'applications. Aujourd’hui, cependant, de nombreuses personnes et organisations fidèles à Java depuis de nombreuses années sont en train de migrer ou envisagent de migrer vers la plateforme. ou ses dérivés tels que ou .
Malheureusement, Kubernetes a une courbe d'apprentissage abrupte et introduit une autre couche opérationnelle dans le processus de développement à laquelle les programmeurs Java sont habitués. Aujourd'hui, nous allons vous expliquer comment utiliser , pour simplifier ces opérations supplémentaires associées à Kubernetes et aux conteneurs, et assurer une migration sans problème vers la plateforme cloud tout en conservant l'écosystème Java familier. De plus, nous montrerons comment déployer des applications Java sur la plateforme OpenShift à l'aide du plugin OpenShift Maven.
Processus de développement Java traditionnel
Processus de développement traditionnel (Figure 1) implique que le développeur écrit du code, puis crée des unités de déploiement sous la forme de fichiers JAR ou WAR, puis déploie et exécute ces fichiers sur un serveur Web ou d'applications. La principale façon de procéder est d'utiliser Maven à partir de la ligne de commande ou d'utiliser un IDE comme IntelliJ ou Eclipse pour coder et empaqueter les applications. Les développeurs sont habitués à apporter des modifications au code et à tout tester minutieusement avant de valider le code et de le soumettre au contrôle de version.
Riz. 1. Processus de développement Java traditionnel.
Processus de développement Java pour le cloud
Lors du passage aux applications cloud, Kubernetes et . Par conséquent, le développeur doit désormais empaqueter les applications Java dans et créez des manifestes Kubernetes qui décrivent ces images. Ces manifestes sont ensuite appliqués au serveur de production exécutant Kubernetes. À son tour, Kubernetes récupère ces images du registre et déploie les applications selon les configurations que nous avons écrites dans les manifestes, qui sont généralement des fichiers YAML.
La métamorphose du processus de développement Java traditionnel lors de la transition vers le cloud est illustrée à la Fig. 2.
Riz. 2. Processus de développement Java pour le cloud.
Eclipse JKube
La migration vers Kubernetes ajoute une autre couche opérationnelle au processus de développement, et de nombreux développeurs sont nerveux à ce sujet car ils souhaitent se concentrer sur leur travail principal (la logique des applications) plutôt que sur la manière de les déployer. Et c’est là que ça entre en jeu. , qui permet aux développeurs d'utiliser leurs bibliothèques et plugins ( avec ou ) pour effectuer sans effort les opérations liées aux conteneurs et à Kubernetes en suivant le schéma de la figure. 2.
Dans la suite de cet article, nous allons vous montrer comment simplifier le processus de développement Java dans l'environnement Kubernetes en utilisant Eclipse JKube avec le plugin Kubernetes Maven.
Processus de développement cloud à l'aide d'Eclipse JKube
Considérons un schéma de développement Java légèrement modifié pour le cloud à partir de la Fig. 2, en y introduisant le plug-in Eclipse JKube et Kubernetes Maven, comme le montre la Fig. 3.
Riz. 3. Processus de développement Java pour le cloud à l'aide d'Eclipse JKube.
Comme nous pouvons le voir, ici toutes les opérations d'interaction avec Kubernetes et les conteneurs (surlignées en rouge dans le diagramme) sont remplacées par les tâches d'objectif Eclipse JKube par défaut, qui sont répertoriées dans le tableau. 1.
Tableau 1. Tâches par défaut d'Eclipse JKube.
Tâche
Stage
description
PRE_INTEGRATION_TEST
Création d'images Docker
INSTALLER
Téléchargement d'images Docker dans le registre
PROCESS_RESOURCES
Générer des manifestes K8
COMPILER
Application des manifestes générés aux K8
NON-DÉPLOYER
Suppression des ressources K8s déployées à l'aide de k8s:apply et k8s:deploy
Note: Si vous ne souhaitez pas que les tâches utilisent ces valeurs par défaut, vous pouvez configurer manuellement Eclipse JKube pour vous-même, car il prend en charge la configuration via и .
Examinons maintenant des exemples d'utilisation d'Eclipse JKube et du plugin Kubernetes Maven lorsque vous travaillez avec des applications.
Déploiement d'une application Java sur Kubernetes à l'aide d'Eclipse JKube
Dans cet exemple nous allons déployer une simple application Java sur un cluster en utilisant Eclipse JKube. Grâce au plugin Kubernetes Maven, nous pouvons définir les paramètres de déploiement sans avoir à écrire de configuration.
Comme exemple d'application, nous utilisons , qui produit une sortie JSON au point de terminaison /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"
}
Étape 1. Téléchargez le plugin Kubernetes Maven
Le plugin Kubernetes Maven est dans le référentiel . Pour utiliser Eclipse JKube, vous devez ajouter le plugin Kubernetes Maven à votre pom.xml en tant que dépendance :
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>kubernetes-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Si OpenShift est utilisé à la place de Kubernetes pur, alors pom.xml est modifié comme suit :
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>openshift-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Étape 2. Créez l'image Docker
Le fichier JAR de l'application peut être construit avec la commande mvn package, puis la tâche d'objectif mvn k8s:build peut être utilisée pour créer une image Docker de l'application. Notez que nous avons remplacé le nom de l'image par défaut par cette propriété :
<jkube.generator.name>docker.io/rohankanojia/random-generator:${project.version}</jkube.generator.name>
Avant de créer l'image, vous devez vous assurer que le démon Docker est correctement exposé. Cela peut être fait avec la commande suivante :
$ eval $(minikube docker-env)
Ensuite, nous entrons dans la commande mvn k8s:build, et voici ce que nous verrons à l'écran lors de la construction de l'image Docker à l'aide de la tâche de construction 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 : $
Étape 3. Téléchargez l'image dans le registre Docker
Après avoir construit l'image Docker avec le registre push configuré (dans notre cas, il s'agit de docker.io), nous pouvons envoyer cette image au registre. C'est ce qui sera affiché après avoir demandé à Eclipse JKube d'effectuer la tâche 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 : $
Après avoir envoyé l'image, vous devez vérifier qu'elle est incluse dans le registre. Dans notre cas, nous le voyons simplement dans Docker Hub, comme le montre la Fig. 4.
Riz. 4. L'image envoyée au registre est apparue dans Docker Hub.
Étape 4. Générer des manifestes de ressources Kubernetes pour l'application
Nous avons donc collecté l'image de l'application, nous devons maintenant écrire les manifestes Kubernetes. Pour ce faire, Eclipse JKube a une tâche qui génère des manifestes de ressources rigides basés sur le framework Java sous-jacent (, , Vert.x ou un autre). Vous pouvez également personnaliser le manifeste en utilisant un fichier de configuration XML et en plaçant des fragments bruts (fragments du manifeste de ressources requis) dans le dossier d'application src/main/jkube. Dans ce cas, votre configuration sera téléchargée dans les manifestes générés.
Dans notre exemple, nous laissons tout tel quel, et donc Eclipse JKube génère un manifeste pour le déploiement par défaut et pour le service de type ClusterIP. Et alors seulement, nous modifions le manifeste du service pour changer le type de service en NodePort. Vous pouvez remplacer le comportement par défaut à l'aide de la propriété suivante :
<jkube.enricher.jkube-service.type>NodePort</jkube.enricher.jkube-service.type>
Voici à quoi ressemble la sortie de l'écran après avoir demandé à Eclipse JKube d'effectuer la tâche de ressource 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 : $
Étape 5. Déployer l'application sur le cluster Kubernetes
Nous sommes maintenant prêts à déployer l'application : nous avons généré son image, puis généré automatiquement les manifestes de ressources. Il ne reste plus qu'à appliquer tout cela au cluster Kubernetes. Pour déployer l'application, vous pouvez bien sûr utiliser la commande kubectl apply -f, mais le plugin peut le faire pour nous. C'est ce qui apparaîtra à l'écran après avoir demandé à Eclipse JKube d'exécuter la tâche 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"
}
Étape 6. Annuler le déploiement des applications du cluster Kubernetes
Pour ce faire, la tâche d'annulation du déploiement est utilisée, qui supprime simplement toutes les ressources qui ont été appliquées à l'étape précédente, c'est-à-dire lorsque la tâche d'application est exécutée. C'est ce que nous verrons à l'écran après avoir demandé à Eclipse JKube d'effectuer la tâche 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 : $
Que pouvez-vous faire d'autre avec Eclipse JKube
Nous avons donc examiné les tâches principales d'Eclipse JKube et du plug-in Kubernetes Maven, qui facilitent le développement d'applications Java pour la plate-forme Kubernetes. Si vous ne souhaitez pas saisir constamment ces tâches depuis le clavier, vous pouvez les écrire dans la configuration du plugin, par exemple, comme ceci :
<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>
Il faut dire que dans cet article nous n'avons pas pris en compte toutes les tâches cibles qui se trouvent dans Eclipse JKube et Kubernetes Maven Plugin, nous fournissons donc dans le tableau 2 une liste de tâches supplémentaires qui peuvent également vous être utiles.
Tableau 2. Tâches d'objectif Eclipse JKube supplémentaires.
Tâche
Stage
description
VALIDER
Réception des journaux d'une application exécutée sur Kubernetes.
RANGEMENT
Ouvrez un port de débogage afin de pouvoir déboguer votre application exécutée sur Kubernetes directement à partir de l'EDI.
INSTALLER
Créer un fork pour la tâche d'installation et appliquer les manifestes générés au cluster Kubernetes de la même manière que dans le cas de la tâche d'application.
RANGEMENT
Déploiement automatique à chaud d'une application en suivant son espace de noms.
Déploiement d'applications Java sur Red Hat OpenShift à l'aide du plugin OpenShift Maven
Pour déployer l'application de notre exemple sur la plateforme Red Hat OpenShift, nous utilisons le plugin . La seule différence sera que le préfixe de la tâche passera de k8s à oc. Par défaut, le plugin Kubernetes Maven le fait -assemblys et le plugin OpenShift Maven - assemblys . Nous n'apportons aucune modification à notre projet autre que la suppression de la propriété jkube.generator.name car elle n'est pas requise lors de la transmission vers le registre (OpenShift place l'image dans son registre interne pendant la phase de construction). Et c'est ce qui apparaîtra à l'écran lorsque nous exécuterons notre exemple, dans lequel, d'ailleurs, nous effectuons des tâches cibles non pas une à la fois, mais toutes en même temps :
~/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 : $
Leçon vidéo
Pour en savoir plus sur la façon de faciliter le développement de Kubernetes avec Eclipse JKube, regardez ce didacticiel vidéo sur la façon de déployer rapidement une simple application Spring Boot sur Minikube :
Conclusion
Dans cet article, nous avons montré comment Eclipse JKube facilite la vie d'un développeur Java lorsqu'il travaille avec Kubernetes. Plus d’informations sur Eclipse JKube peuvent être trouvées sur et .
Source: habr.com