Il y a 25 ans, Java a été largement adopté par les programmeurs, devenant ainsi l'un des piliers autour desquels s'articulent les stacks d'applications. Cependant, aujourd'hui, de nombreuses personnes et organisations ayant longtemps fidÚlement utilisé Java se trouvent occupées à migrer ou à envisager une migration vers la plateforme ou ses dérivés, tels que ou .
Malheureusement, Kubernetes se distingue par sa courbe d'apprentissage abrupte et introduit un niveau opérationnel supplémentaire dans le processus de développement familier aux programmeurs Java. Aujourd'hui, nous allons expliquer comment utiliser , afin de simplifier ces opérations supplémentaires liées à Kubernetes et aux conteneurs, tout en assurant une migration fluide vers une plateforme cloud tout en préservant l'écosystÚme Java habituel. De plus, nous allons montrer comment déployer des applications Java sur la plateforme OpenShift à l'aide du plugin OpenShift Maven.
Le processus de développement Java traditionnel
Le processus de développement traditionnel (Fig. 1) implique que le développeur écrit le code, puis crée des unités de déploiement sous forme de fichiers JAR ou WAR, avant de déployer et d'exécuter ces fichiers sur un serveur web ou un serveur d'applications. Pour cela, il utilise principalement Maven depuis la ligne de commande ou un IDE comme IntelliJ ou Eclipse pour coder et empaqueter les applications. Les développeurs ont l'habitude de modifier le code et de tout tester soigneusement avant de l'enregistrer et de le soumettre à un systÚme de gestion de version.
Fig. 1. Processus de développement Java traditionnel.
Processus de développement Java pour le cloud
Lors de la transition vers des applications cloud, Kubernetes et s'ajoutent à ce schéma décrit ci-dessus. Par conséquent, le développeur doit maintenant empaqueter les applications Java dans des et créer des manifestes Kubernetes décrivant ces images. Ensuite, ces manifestes sont appliqués au serveur de production, sur lequel Kubernetes fonctionne. à son tour, Kubernetes récupÚre ces images à partir du registre et déploie les applications selon les configurations que nous avons spécifiées dans les manifestes, qui sont généralement des fichiers YAML.
La métamorphose du processus traditionnel de développement Java lors de la transition vers le cloud est illustrée à la Fig. 2.
Fig. 2. Processus de développement Java pour le cloud.
Eclipse JKube
La migration vers Kubernetes ajoute un niveau opĂ©rationnel supplĂ©mentaire au processus de dĂ©veloppement, ce qui peut inquiĂ©ter de nombreux dĂ©veloppeurs qui prĂ©fĂšrent se concentrer sur leur cĆur de mĂ©tier : la logique des applications, plutĂŽt que sur leur dĂ©ploiement. C'est ici qu'entre en jeu , qui permet aux dĂ©veloppeurs d'utiliser leurs bibliothĂšques et plugins ( avec ou ), afin d'effectuer sans effort les opĂ©rations liĂ©es aux conteneurs et Ă Kubernetes, suivant le schĂ©ma de la Fig. 2.
Dans le reste de cet article, nous montrerons comment simplifier le processus de développement Java dans un environnement Kubernetes en utilisant Eclipse JKube avec le plugin Kubernetes Maven Plugin.
Le processus de développement pour le cloud avec Eclipse JKube
Considérons un schéma légÚrement modifié de développement Java pour le cloud selon la Fig. 2, en y intégrant Eclipse JKube et Kubernetes Maven Plugin, comme illustré à la Fig. 3.
Fig. 3. Processus de développement Java pour le cloud avec Eclipse JKube.
Comme nous le voyons ici, toutes les opérations d'interaction avec Kubernetes et les conteneurs (soulignées en rouge sur le schéma) sont remplacées par les objectifs par défaut d'Eclipse JKube énumérés dans le Tab. 1.
Tab. 1. Tùches par défaut d'Eclipse JKube.
La tĂąche
L'Ă©tape
Description
PRE_INTEGRATION_TEST
Construction d'images Docker
INSTALL
Envoi d'images Docker au registre
PROCESS_RESOURCES
Génération de manifestes K8s
COMPILE
Application des manifestes générés à K8s
UNDEPLOY
Suppression des ressources K8s qui ont été déployées via k8s:apply et k8s:deploy
Remarque : Si vous ne souhaitez pas que les tùches utilisent ces défauts rigides (défauts opportuns), vous pouvez configurer manuellement Eclipse JKube selon vos besoins, car il prend en charge la configuration via et .
Examinons maintenant des exemples d'utilisation d'Eclipse JKube et du Kubernetes Maven Plugin lors du travail avec des applications.
DĂ©ploiement d'une application Java dans Kubernetes avec Eclipse JKube
Dans cet exemple, nous déploierons une simple application Java dans un cluster avec Eclipse JKube. En utilisant le Kubernetes Maven Plugin, nous pouvons spécifier les paramÚtres de déploiement sans avoir à écrire de configuration.
Comme exemple d'application, nous utilisons , qui produit une sortie JSON Ă l'endpoint /random :
~\/work\/repos\/eclipse-jkube-demo-project : $ curl localhost:8080\/random | jq .\n % Total % Received % Xferd Average Speed Time Time Time Current\n Dload Upload Total Spent Left Speed\n100 45 0 45 0 0 818 0 --:--:-- --:--:-- --:--:-- 818\n{\n \"id\": \"e80a4d10-c79b-4b9a-aaac-7c286cb37f3c\"\n}
Ătape 1. TĂ©lĂ©chargez le plugin Maven Kubernetes
Le plugin Maven Kubernetes se trouve dans le dépÎt . Pour utiliser Eclipse JKube, ajoutez le plugin Maven Kubernetes dans votre pom.xml en tant que dépendance :
org.eclipse.jkube
kubernetes-maven-plugin
${jkube.version}
Si OpenShift est utilisé au lieu de Kubernetes pur, modifiez pom.xml comme suit :
org.eclipse.jkube
openshift-maven-plugin
${jkube.version}
Ătape 2. CrĂ©ez l'image Docker
Le fichier JAR de l'application peut ĂȘtre crĂ©Ă© avec la commande mvn package, puis utilisez la tĂąche goal mvn k8s:build pour crĂ©er l'image Docker de cette application. Notez que nous avons remplacĂ© le nom de l'image par dĂ©faut avec cette propriĂ©tĂ© :
docker.io/rohankanojia/random-generator:${project.version}
Avant de crĂ©er l'image, assurez-vous que le dĂ©mon Docker est correctement exposĂ©. Cela peut ĂȘtre fait avec la commande suivante :
$ eval $(minikube docker-env)
Ensuite, saisissez la commande mvn k8s:build, et voici ce que nous verrons à l'écran lors de la création de l'image Docker avec la tùche build d'Eclipse JKube :
~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:build
[INFO] Analyse des projets...
[INFO]
[INFO] ---------------------------------------------
[INFO] Création de random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] k8s: Fonctionnement en mode Kubernetes
[INFO] k8s: Création de l'image Docker en mode Kubernetes
[INFO] k8s: Exécution du générateur spring-boot
[INFO] k8s: spring-boot : Utilisation de l'image Docker quay.io/jkube/jkube-java-binary-s2i:0.0.7 comme base / constructeur
[INFO] k8s: [docker.io/rohankanojia/random-generator:0.0.1] "spring-boot": Créé docker-build.tar en 251 millisecondes
[INFO] k8s: [docker.io/rohankanojia/random-generator:0.0.1] "spring-boot": Image construite sha256:a20e5
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUCTION RĂUSSIE
[INFO] ------------------------------------------------------------------------
[INFO] Temps total : 5.053 s
[INFO] Terminé à : 2020-08-10T11:28:23+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $
Ătape 3. Poussez l'image vers le registre Docker
AprÚs avoir construit l'image Docker avec le registre de push configuré (dans notre cas, c'est docker.io), nous pouvons envoyer cette image vers le registre. Voici ce qui sera affiché à l'écran aprÚs avoir demandé à Eclipse JKube d'exécuter la tùche push mvn k8s:push :
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:push
[INFO] Recherche de projets...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Construction de random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:push (default-cli) @ random-generator ---
[INFO] k8s: Exécution en mode Kubernetes
[INFO] k8s: Construction de l'image Docker en mode Kubernetes
[INFO] k8s: Exécution du générateur spring-boot
[INFO] k8s: spring-boot: Utilisation de l'image Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 comme base \/ constructeur
[INFO] k8s: La poussée se réfÚre au dépÎt [docker.io\/rohankanojia\/random-generator]
5dcd9556710f: La couche existe dĂ©jĂ
b7139ad07aa8: La couche existe dĂ©jĂ
b6f081e4b2b6: La couche existe dĂ©jĂ
d8e1f35641ac: La couche existe dĂ©jĂ
[INFO] k8s: 0.0.1: digest: sha256:9f9eda2a13b8cab1d2c9e474248500145fc09e2922fe3735692f9bda4c76002d taille: 1162
[INFO] k8s: Poussé docker.io\/rohankanojia\/random-generator:0.0.1 en 7 secondes
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUCTION RĂUSSIE
[INFO] ------------------------------------------------------------------------
[INFO] Temps total: 11.222 s
[INFO] Terminé à : 2020-08-10T11:35:37+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $
AprÚs l'envoi de l'image, il faut vérifier qu'elle est bien arrivée dans le registre. Dans notre cas, nous pouvons simplement la voir sur Docker Hub, comme indiqué à la Fig. 4.
Fig. 4. L'image envoyée est apparue dans Docker Hub.
Ătape 4. GĂ©nĂ©ration des manifestes des ressources Kubernetes pour l'application
Ainsi, nous avons construit l'image de l'application, maintenant nous devons écrire les manifestes Kubernetes. Pour cela, Eclipse JKube dispose d'une tùche qui génÚre des manifestes de ressources rigides, en se basant sur le framework Java sous-jacent (, , Vert.x ou un autre). Il est également possible de configurer le manifeste en utilisant un fichier XML de configuration et en plaçant des morceaux bruts (fragments du manifeste des ressources requis) dans le dossier de l'application src\/main\/jkube. Dans ce cas, votre configuration sera intégrée aux 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 avec le type ClusterIP. Ensuite, nous modifierons le manifeste du service pour changer le type de service en NodePort. Le comportement par dĂ©faut peut ĂȘtre remplacĂ© Ă l'aide de la propriĂ©tĂ© suivante :
<jkube.enricher.jkube-service.type>NodePort<\/jkube.enricher.jkube-service.type>
Voici à quoi ressemble la sortie à l'écran aprÚs que nous ayons demandé à Eclipse JKube d'exécuter la tùche de ressources 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 : $
Ătape 5. DĂ©ployons l'application dans le cluster Kubernetes
Nous sommes donc prĂȘts Ă procĂ©der au dĂ©ploiement de l'application : nous avons gĂ©nĂ©rĂ© son image et ensuite crĂ©Ă© automatiquement les manifestes de ressources. Il ne reste plus qu'Ă appliquer tout cela au cluster Kubernetes. Pour dĂ©ployer l'application, nous pourrions bien sĂ»r utiliser la commande kubectl apply -f, mais le plugin peut aussi le faire pour nous. Voici ce qui s'affichera Ă l'Ă©cran aprĂšs avoir demandĂ© Ă Eclipse JKube d'exĂ©cuter la tĂąche 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"
}
Ătape 6. DĂ©ployer l'application depuis le cluster Kubernetes
Cela utilise la tùche undeploy, qui supprime simplement toutes les ressources qui ont été appliquées lors de l'étape précédente, c'est-à -dire lors de l'exécution de la tùche apply. Voici ce que nous verrons à l'écran aprÚs avoir demandé à Eclipse JKube d'exécuter la tùche de déploiement mvn k8s:undeploy:
~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get all
NAME READY STATUS RESTARTS AGE
pod\/random-generator-58b7847d7f-9m9df 1\/1 En cours 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] Scan des projets...
[INFO]
[INFO] ---------------------------------------------
[INFO] Construction de random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:undeploy (default-cli) @ random-generator ---
[INFO] k8s: Utilisation de Kubernetes à https:\/\/192.168.39.145:8443\/ dans l'espace de noms par défaut avec le manifeste \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/classes\/META-INF\/jkube\/kubernetes.yml
[INFO] k8s: Utilisation de l'espace de noms : par défaut
[INFO] k8s: Suppression de la ressource Deployment default\/random-generator
[INFO] k8s: Suppression de la ressource Service default\/random-generator
[INFO] k8s: CONSEIL : Utilisez la commande `kubectl get pods -w` pour surveiller le démarrage de vos pods
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUCTION RĂUSSIE
[INFO] ------------------------------------------------------------------------
[INFO] Temps total : 3.412 s
[INFO] Terminé à : 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 : $
Que puis-je faire d'autre avec Eclipse JKube
Nous avons examiné les principales tùches du goal d'Eclipse JKube et du Kubernetes Maven Plugin, qui facilitent le développement d'applications Java sur la plateforme Kubernetes. Si vous ne souhaitez pas saisir ces tùches en permanence au clavier, vous pouvez les écrire dans la configuration du plugin, par exemple, comme ceci :
org.eclipse.jkube
kubernetes-maven-plugin
${project.version}
build
resource
apply
Il faut dire que dans cet article, nous n'avons pas examinĂ© toutes les tĂąches des goals d'Eclipse JKube et du Kubernetes Maven Plugin, c'est pourquoi nous prĂ©sentons dans le tableau 2 une liste de tĂąches supplĂ©mentaires qui peuvent Ă©galement vous ĂȘtre utiles.
Tableau 2. Tùches supplémentaires des goals d'Eclipse JKube.
La tĂąche
L'Ă©tape
Description
VALIDER
Récupération des logs de l'application fonctionnant sur Kubernetes.
PACKAGE
Ouverture d'un port de débogage pour effectuer le débogage d'une application fonctionnant sur Kubernetes directement depuis l'IDE.
INSTALL
CrĂ©ation d'un fork pour la tĂąche Install et application des manifestes gĂ©nĂ©rĂ©s au cluster Kubernetes de la mĂȘme maniĂšre que pour la tĂąche apply.
PACKAGE
DĂ©ploiement automatique Ă chaud de l'application en surveillant 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 appliquerons le plugin . La seule diffĂ©rence sera que le prĂ©fixe des tĂąches changera de k8s Ă oc. Par dĂ©faut, le plugin Kubernetes Maven effectue -des constructions, tandis que le plugin OpenShift Maven effectue des constructions . Nous ne faisons aucune modification Ă notre projet, Ă l'exception de la suppression de la propriĂ©tĂ© jkube.generator.name, car elle n'est pas nĂ©cessaire lors de l'envoi au registre (Ă l'Ă©tape de construction, OpenShift place l'image dans son registre interne). Voici ce qui apparaĂźtra Ă l'Ă©cran lorsque nous lancerons notre exemple, oĂč, soit dit en passant, nous exĂ©cutons les objectifs de tĂąches non pas un par un, mais tous en mĂȘme temps :
~\/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: Utilisation de la construction OpenShift avec stratégie S2I
[INFO] oc: Exécution en mode OpenShift
[INFO] oc: Exécution du générateur spring-boot
[INFO] oc: spring-boot: Utilisation de l'image Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 comme base \/ builder
[INFO] oc: [random-generator:0.0.1] "spring-boot": Créé l'archive source docker \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/docker\/random-generator\/0.0.1\/tmp\/docker-build.tar
[INFO] oc: Ajout au Secret pullsecret-jkube
[INFO] oc: Utilisation du Secret pullsecret-jkube
[INFO] oc: Création de BuildServiceConfig random-generator-s2i pour la construction Source
[INFO] oc: Création de ImageStream random-generator
[INFO] oc: DĂ©marrage de la construction random-generator-s2i
[INFO] oc: Attente de la construction random-generator-s2i-1 pour terminer...
[INFO] oc: Mise en cache des blobs sous "/var/cache/blobs".
[INFO] oc: Obtention des signatures de source d'image
[INFO] oc: Copie du blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Copie du blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Copie du blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Copie de la configuration sha256:52d6788fcfdd39595264d34a3959464a5dabc1d4ef0ae188802b20fc2d6a857b
[INFO] oc: Ăcriture du manifeste Ă la destination de l'image
[INFO] oc: Stockage des signatures
[INFO] oc: Génération du dockerfile avec l'image builder quay.io\/jkube\/jkube-java-binary-s2i:0.0.7
[INFO] oc: ĂTAPE 1: DE quay.io\/jkube\/jkube-java-binary-s2i:0.0.7
[INFO] oc: ĂTAPE 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: ĂTAPE 3: ENV JAVA_APP_DIR="\/deployments" OPENSHIFT_BUILD_NAME="random-generator-s2i-1" OPENSHIFT_BUILD_NAMESPACE="default"
[INFO] oc: ĂTAPE 4: USER root
[INFO] oc: ĂTAPE 5: COPY upload\/src \/tmp\/src
[INFO] oc: ĂTAPE 6: RUN chown -R 1000:0 \/tmp\/src
[INFO] oc: ĂTAPE 7: USER 1000
[INFO] oc: ĂTAPE 8: RUN \/usr\/local\/s2i\/assemble
[INFO] oc: INFO Construction S2I source avec des binaires simples détectés
[INFO] oc: INFO Construction binaire S2I à partir de fabric8-maven-plugin détectée
[INFO] oc: INFO Copie des binaires de \/tmp\/src\/deployments vers \/deployments ...
[INFO] oc: random-generator-0.0.1.jar
[INFO] oc: INFO Copie des déploiements de deployments vers \/deployments...
[INFO] oc: '\/tmp\/src\/deployments\/random-generator-0.0.1.jar' -> '\/deployments\/random-generator-0.0.1.jar'
[INFO] oc: ĂTAPE 9: CMD \/usr\/local\/s2i\/run
[INFO] oc: ĂTAPE 10: COMMIT temp.builder.openshift.io\/default\/random-generator-s2i-1:48795e41
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Incompatibilité entre le systÚme d'exploitation de l'image : l'image utilise "", s'attendant à "linux""
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Incompatibilité d'architecture d'image : l'image utilise "", s'attendant à "amd64""
[INFO] oc: Obtention des signatures de source d'image
[INFO] oc: Copie du blob sha256:d8e1f35641acb80b562f70cf49911341dfbe8c86f4d522b18efbf3732aa74223
[INFO] oc: Copie du blob sha256:b6f081e4b2b6de8be4b1dec132043d14c121e968384dd624fb69c2c07b482edb
[INFO] oc: Copie du blob sha256:b7139ad07aa8ce4ed5a132f7c5cc9f1de0f5099b5e155027a23d57f7fbe78b16
[INFO] oc: Copie du blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Copie de la configuration sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Ăcriture du manifeste Ă la destination de l'image
[INFO] oc: Stockage des signatures
[INFO] oc: --> 27aaadaf28e
[INFO] oc: 27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Obtention des signatures de source d'image
[INFO] oc:
[INFO] oc: Poussée de l'image image-registry.openshift-image-registry.svc:5000\/default\/random-generator:0.0.1 ...
[INFO] oc: Copie du blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Copie du blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Copie du blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Copie du blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Copie de la configuration sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Ăcriture du manifeste Ă la destination de l'image
[INFO] oc: Stockage des signatures
[INFO] oc: Image-poussée réussie image-registry.openshift-image-registry.svc:5000\/default\/random-generator@sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: Poussée réussie
[INFO] oc: Construction random-generator-s2i-1 en statut Complet
[INFO] oc: Tag trouvé sur ImageStream random-generator tag: sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: ImageStream random-generator Ă©crit dans \/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: Utilisation du nom de l'image Docker de l'espace de noms : default
[INFO] oc: Exécution du générateur spring-boot
[INFO] oc: spring-boot: Utilisation de l'image Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 comme base \/ builder
[INFO] oc: jkube-controller: Ajout d'un DeploymentConfig par défaut
[INFO] oc: jkube-service: Ajout d'un service par défaut 'random-generator' avec des ports [8080]
[INFO] oc: jkube-healthcheck-spring-boot: Ajout d'une sonde de disponibilité sur le port 8080, chemin='\/actuator\/health', schéma='HTTP', avec un délai initial de 10 secondes
[INFO] oc: jkube-healthcheck-spring-boot: Ajout d'une sonde de vivacité sur le port 8080, chemin='\/actuator\/health', schéma='HTTP', avec un délai initial de 180 secondes
[INFO] oc: jkube-revision-history: Ajout d'une limite d'historique de révisions à 2
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] oc: Utilisation d'OpenShift Ă https:\/\/api.crc.testing:6443\/ dans l'espace de noms default avec le manifeste \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/classes\/META-INF\/jkube\/openshift.yml
[INFO] oc: Plateforme OpenShift détectée
[INFO] oc: Utilisation du projet : default
[INFO] oc: Création d'un Service à partir de openshift.yml espace de noms default nom random-generator
[INFO] oc: Service créé : target\/jkube\/applyJson\/default\/service-random-generator.json
[INFO] oc: Création d'un DeploymentConfig à partir de openshift.yml espace de noms default nom random-generator
[INFO] oc: DeploymentConfig créé : target\/jkube\/applyJson\/default\/deploymentconfig-random-generator.json
[INFO] oc: Création de Route default:random-generator hÎte: null
[INFO] oc: CONSEIL : Utilisez la commande `oc get pods -w` pour surveiller le démarrage de vos pods
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUCTION RĂUSSIE
[INFO] ------------------------------------------------------------------------
[INFO] Temps total : 01:07 min
[INFO] Terminé à : 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 En cours d'exécution 0 14s
random-generator-1-vnrm9 0\/1 En cours d'exécution 0 11s
random-generator-s2i-1-build 0\/1 Terminé 0 1m
random-generator-1-vnrm9 1\/1 En cours d'exécution 0 24s
random-generator-1-deploy 0\/1 Terminé 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 Aucun
~\/work\/repos\/eclipse-jkube-demo-project : $ curl random-generator-default.apps-crc.testing\/random
% Total % Reçu % Transféré Vitesse moyenne Temps Temps Temps Actuel
Dload Upload Total Dépensé Restant Vitesse
100 45 0 45 0 0 1666 0 --:--:-- --:--:-- --:--:-- 1730
{
"id": "d80052d9-2f92-43cb-b9eb-d7cffb879798"
}
~\/work\/repos\/eclipse-jkube-demo-project : $
Vidéo-tutoriel
Pour en savoir plus sur la simplification du développement Kubernetes avec Eclipse JKube, regardez le vidéo-tutoriel sur le déploiement rapide d'une application Spring Boot simple sur Minikube :
Conclusion
Dans cet article, nous avons montré comment Eclipse JKube facilite la vie des développeurs Java travaillant avec Kubernetes. Plus d'informations sur Eclipse JKube sont disponibles sur et en .
Source : habr.com
