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
Russian
Italian
German
Polish
Estonian
Albanian
Bulgarian
Croatian
Czech
Danish
Dutch
English
French
Hungarian
Latvian
Norwegian
Portuguese
Romanian
Slovak
Slovenian
Spanish
Swedish