Clever Geek Handbook

DĂ©veloppement d'applications Java pour Kubernetes Ă  l'aide d'Eclipse JKube

Il y a 25 ans, Java est entré dans les programmeurs grand public pour finalement devenir l'un des piliers autour desquels les piles d'applications sont construites. Cependant, aujourd'hui, de nombreuses personnes et organisations fidÚles à Java depuis des années sont occupées à migrer ou envisagent de migrer vers Kubernetes ou ses dérivés tels que Red Hat OpenShift ou Amazon EKS .







Hélas, Kubernetes a une courbe d'apprentissage abrupte et introduit une autre couche opérationnelle dans le processus de développement Java. Aujourd'hui, nous allons vous montrer comment utiliser Eclipse JKubepour simplifier ces opérations supplémentaires liées à Kubernetes et aux conteneurs, et fournir une migration sans douleur vers la plate-forme 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



Le processus de développement Java traditionnel (Figure 1) signifie qu'un développeur écrit du code, puis crée des unités de déploiement sous forme de fichiers JAR ou WAR, puis déploie et exécute ces fichiers sur un serveur Web ou d'applications. La plupart du temps, ils utilisent Maven à partir de la ligne de commande ou utilisent un IDE comme IntelliJ ou Eclipse pour coder et empaqueter des applications. Les développeurs ont l'habitude d'apporter des modifications au code et de tout tester soigneusement avant de valider le code et de le soumettre au contrÎle de code source.







Figure: 1. Processus de développement Java traditionnel.



Processus de développement Java pour le cloud



Le passage aux applications cloud ajoute Kubernetes et des conteneurs au schĂ©ma ci - dessus . Par consĂ©quent, le dĂ©veloppeur doit dĂ©sormais empaqueter les applications Java dans des images de conteneur et crĂ©er des manifestes Kubernetes dĂ©crivant ces images. Ces manifestes sont ensuite appliquĂ©s au serveur de production sur lequel Kubernetes s'exĂ©cute. À son tour, Kubernetes prend ces images du registre et dĂ©ploie des applications selon les configurations que nous avons Ă©crites dans les manifestes, qui sont gĂ©nĂ©ralement des fichiers YAML.



La métamorphose du développement Java traditionnel lors de la transition vers le cloud est illustrée à la Fig. 2.







Figure: 2. Processus de développement Java pour le cloud.



Eclipse JKube



Le passage à Kubernetes ajoute une autre couche opérationnelle au processus de développement, ce qui est déconcertant pour de nombreux développeurs car ils veulent faire leur travail de base - la logique des applications - pas comment les déployer. C'est là qu'Eclipse JKube entre en jeu , qui permet aux développeurs d'utiliser leurs bibliothÚques et plugins ( JKube Kit avec le plugin Kubernetes Maven ou OpenShift Maven Plugin ) pour effectuer sans effort des opérations liées aux conteneurs et à Kubernetes en suivant le diagramme de la Fig. 2.



Dans le reste de cet article, nous allons vous montrer comment simplifier le processus de développement Java de Kubernetes en utilisant Eclipse JKube avec le plugin Kubernetes Maven.



Processus de développement cloud à l'aide d'Eclipse JKube



Examinons le cadre de développement Java légÚrement modifié pour le cloud de la figure 2, présentant le plug-in Eclipse JKube et Kubernetes Maven, comme illustré à la figure 2. 3.







Figure: 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, répertoriées dans le tableau. 1.



Tab. 1. Tùches par défaut Eclipse JKube.



Tñche Étape La description
k8s: construire PRE_INTEGRATION_TEST Création d'images Docker
k8s: pousser INSTALLER Téléchargement d'images Docker dans le registre
k8s: ressource PROCESS_RESOURCES Générer des manifestes K8
k8s: appliquer COMPILER Application de manifestes générés aux K8
k8s: annuler le déploiement UNDEPLOY Suppression des ressources K8s déployées avec k8s: apply et k8s: deploy


Remarque: si vous ne souhaitez pas que les tĂąches utilisent ces valeurs par dĂ©faut, vous pouvez personnaliser manuellement Eclipse JKube pour vous-mĂȘme, car il prend en charge la configuration via XML et les ressources .



Examinons maintenant des exemples d'utilisation du plugin Eclipse JKube et Kubernetes Maven lorsque vous travaillez avec des applications.



DĂ©ployer l'application Java sur Kubernetes Ă  l'aide d'Eclipse JKube



Dans cet exemple, nous déploierons une application Java simple sur le cluster Minikube à l' aide d'Eclipse JKube. En utilisant le plugin Kubernetes Maven, nous pouvons définir les options de déploiement sans avoir à écrire de configuration.



Comme exemple d'application, nous utilisons un simple générateur de nombres aléatoires 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 plug-in Kubernetes Maven Le plug-



in Kubernetes Maven se trouve dans le référentiel central Maven . 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, le 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Ă©ation de l'image docker Le



fichier JAR de l'application peut ĂȘtre gĂ©nĂ©rĂ© avec la commande mvn package, puis vous pouvez utiliser la tĂąche mvn k8s: build goal pour crĂ©er l'image docker de cette 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 la commande mvn k8s: build, et c'est ce que nous voyons Ă  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Ă©chargement de l'image vers 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 pousser cette image vers le registre. Voici ce qui s'affiche aprÚs avoir demandé à Eclipse JKube d'exécuter 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 se trouve dans le registre. Dans notre cas, nous le voyons simplement dans le Docker Hub, comme le montre la Fig. 4.







Figure: 4. L'image téléchargée dans le registre est apparue sur le Docker Hub.



Étape 4. GĂ©nĂ©ration de manifestes de ressources Kubernetes pour l'application



Nous avons donc assemblé l'image de l'application, nous devons maintenant écrire des manifestes Kubernetes. Pour ce faire, Eclipse JKube a une tùche qui génÚre des manifestes de ressources matérielles basés sur le framework Java sous-jacent ( Spring Boot , Quarkus , Vert.x ou autre). Vous pouvez également personnaliser le manifeste en utilisant un fichier XML de configuration et en plaçant des fragments bruts (fragments du manifeste de ressource requis) dans le dossier de l'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 le JKube Eclipse génÚre un manifeste pour le déploiement par défaut et pour le service avec le type ClusterIP. Ensuite, nous modifions le manifeste de 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'exécuter la tùche mvn k8s: resource 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: 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Ă©ployez l'application sur le cluster Kubernetes



Nous sommes donc prĂȘts Ă  dĂ©ployer l'application: nous avons gĂ©nĂ©rĂ© son image, puis gĂ©nĂ©rĂ© automatiquement des 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Ăźt Ă  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. Annulation du dĂ©ploiement de l'application depuis le cluster Kubernetes



Pour cela, la tùche d' annulation de 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 a été exécutée. C'est ce que nous voyons à l'écran aprÚs avoir demandé à Eclipse JKube d'exécuter 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 peut-on faire d'autre avec Eclipse JKube



Nous avons donc couvert les principaux objectifs de Eclipse JKube et Kubernetes Maven Plugin, qui facilitent le développement d'applications Java pour la plate-forme Kubernetes. Si vous ne souhaitez pas saisir constamment ces tùches à partir du 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>


Je dois dire que dans cet article, nous avons considĂ©rĂ© loin de toutes les tĂąches d'objectif qui se trouvent dans Eclipse JKube et Kubernetes Maven Plugin.Par consĂ©quent, nous prĂ©sentons dans le tableau 2 une liste de tĂąches supplĂ©mentaires qui peuvent Ă©galement vous ĂȘtre utiles.



Languette. 2. Objectifs supplémentaires Eclipse JKube.



Tñche Étape La description
k8s: journal VALIDER Réception des journaux d'une application exécutée sur Kubernetes.
k8s: débogage PAQUET Ouverture d'un port de débogage pour déboguer votre application Kubernetes directement depuis l'EDI.
k8s: dĂ©ployer INSTALLER Le fork de la tĂąche d'installation et l'application des manifestes gĂ©nĂ©rĂ©s au cluster Kubernetes sont exactement les mĂȘmes que dans le cas de la tĂąche d'application.
k8s: montre PAQUET 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 plug-in OpenShift Maven



Pour déployer l'application de notre exemple sur la plate-forme Red Hat OpenShift, nous utiliserons le plugin OpenShift Maven . La seule différence est que le préfixe de la tùche passera de k8s à oc. Par défaut, le plugin Kubernetes Maven fait docker -sborki et plug OpenShift Maven - assembly S2i . Nous n'apportons aucune modification à notre projet, à l'exception de la suppression de la propriété jkube.generator.name, car elle n'est pas requise lors de la soumission au registre (au stade de la construction, OpenShift place l'image dans son registre interne). Et c'est ce qui apparaßtra à l'écran lorsque nous exécuterons notre exemple, dans lequel, en passant, nous effectuons des tùches d'objectif non pas une par une, mais toutes à la fois: 



~/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 : $


Didacticiel vidéo



Pour en savoir plus sur la façon de simplifier le développement Kubernetes avec Eclipse JKube, regardez le didacticiel vidéo expliquant comment déployer rapidement une application Spring Boot simple sur Minikube:





Conclusion



Dans cet article, nous avons montrĂ© comment Eclipse JKube facilite la vie du dĂ©veloppeur Java lorsqu'il travaille avec Kubernetes. Plus d'informations sur le JKube Eclipse peuvent ĂȘtre trouvĂ©es sur le site du projet et sur GitHub .


More articles:


All Articles