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: 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Ă©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
