Por desgracia, Kubernetes tiene una curva de aprendizaje pronunciada e introduce otra capa operativa en el proceso de desarrollo de Java. Hoy te mostraremos cómo usar Eclipse JKubepara simplificar estas operaciones adicionales relacionadas con Kubernetes y contenedores, así como proporcionar una migración sencilla a la plataforma en la nube mientras se mantiene el ecosistema Java familiar. Además, mostraremos cómo implementar aplicaciones Java en la plataforma OpenShift utilizando el complemento OpenShift Maven.
Proceso de desarrollo tradicional de Java
El proceso de desarrollo de Java tradicional (Figura 1) significa que un desarrollador escribe código, luego crea unidades de implementación como archivos JAR o WAR y luego implementa y ejecuta esos archivos en un servidor web o de aplicaciones. En su mayoría, usan Maven desde la línea de comandos o usan un IDE como IntelliJ o Eclipse para codificar y empaquetar aplicaciones. Los desarrolladores están acostumbrados a realizar cambios en el código y probar todo a fondo antes de confirmar el código y enviarlo al control de código fuente.
Figura: 1. El proceso de desarrollo tradicional de Java.
Proceso de desarrollo de Java para la nube
El cambio a aplicaciones en la nube agrega Kubernetes y contenedores al esquema anterior . Por lo tanto, el desarrollador ahora necesita empaquetar aplicaciones Java en imágenes de contenedor y crear manifiestos de Kubernetes que describan estas imágenes. Luego, estos manifiestos se aplican al servidor de producción en el que se ejecuta Kubernetes. A su vez, Kubernetes toma estas imágenes del registro y despliega las aplicaciones según las configuraciones que hemos escrito en los manifiestos, que suelen ser archivos YAML.
La metamorfosis del desarrollo tradicional de Java en la transición a la nube se muestra en la Fig. 2.
Figura: 2. Proceso de desarrollo de Java para la nube.
Eclipse JKube
Pasar a Kubernetes agrega otra capa operativa al proceso de desarrollo, y esto es desconcertante para muchos desarrolladores porque quieren hacer su trabajo principal, la lógica de las aplicaciones, no cómo implementarlas. Aquí es donde entra en juego Eclipse JKube , que permite a los desarrolladores usar sus bibliotecas y complementos ( JKube Kit junto con Kubernetes Maven Plugin o OpenShift Maven Plugin ) para realizar sin esfuerzo operaciones de contenedor y relacionadas con Kubernetes siguiendo el diagrama de la Fig. 2.
En el resto de este artículo, le mostraremos cómo simplificar el proceso de desarrollo de Java en Kubernetes utilizando Eclipse JKube con el complemento Kubernetes Maven.
Proceso de desarrollo en la nube con Eclipse JKube
Veamos el marco de desarrollo de Java ligeramente modificado para la nube de la Figura 2, presentando el complemento Eclipse JKube y Kubernetes Maven, como se muestra en la Figura 2. 3.
Figura: 3. Proceso de desarrollo de Java para la nube utilizando Eclipse JKube.
Como podemos ver, aquí todas las operaciones para interactuar con Kubernetes y contenedores (resaltadas en rojo en el diagrama) se reemplazan por las tareas de objetivo predeterminadas de Eclipse JKube, que se enumeran en la Tabla. 1.
Tab. 1. Tareas predeterminadas de Eclipse JKube.
| Tarea | Etapa | Descripción |
|---|---|---|
| k8s: construir | PRE_INTEGRATION_TEST | Imágenes de docker building |
| k8s: empujar | INSTALAR EN PC | Subir imágenes de Docker al registro |
| k8s: recurso | PROCESS_RESOURCES | Generando manifiestos de K8 |
| k8s: aplicar | COMPILAR | Aplicación de manifiestos generados a K8 |
| k8s: anular la implementación | DESEMPLEAR | Eliminación de activos de K8 que se implementaron con k8s: apply y k8s: deploy |
Nota: Si no desea que las tareas utilicen estos valores predeterminados obstinados, puede personalizar manualmente Eclipse JKube usted mismo, ya que admite la configuración a través de XML y recursos .
Ahora veamos ejemplos del uso de Eclipse JKube y Kubernetes Maven Plugin al trabajar con aplicaciones.
Implemente la aplicación Java en Kubernetes usando Eclipse JKube
En este ejemplo, implementaremos una aplicación Java simple en el clúster de Minikube usando Eclipse JKube. Con el complemento Kubernetes Maven, podemos establecer opciones de implementación sin tener que escribir ninguna configuración.
Como aplicación de ejemplo, utilizamos un generador de números aleatorios simple que produce una salida JSON en el punto final / 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"
}
Paso 1. Descargue el complemento Kubernetes Maven El complemento
Kubernetes Maven se encuentra en el repositorio central de Maven . Para usar Eclipse JKube, debe agregar el complemento Kubernetes Maven a su pom.xml como una dependencia:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>kubernetes-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Si se usa OpenShift en lugar de Kubernetes puro, pom.xml se modifica de la siguiente manera:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>openshift-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Paso 2. Cree la imagen de
la ventana acoplable El archivo JAR de la aplicación se puede compilar con el comando mvn package, y luego puede usar la tarea mvn k8s: build goal para generar la imagen de la ventana acoplable de esta aplicación. Tenga en cuenta que hemos anulado el nombre de la imagen predeterminada con esta propiedad:
<jkube.generator.name>docker.io/rohankanojia/random-generator:${project.version}</jkube.generator.name>
Antes de crear la imagen, debe asegurarse de que el demonio de la ventana acoplable esté expuesto correctamente. Esto se puede hacer con el siguiente comando:
$ eval $(minikube docker-env)
Luego ingresamos el comando mvn k8s: build, y esto es lo que vemos en la pantalla cuando construimos la imagen de la ventana acoplable usando la tarea de compilación 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 : $
Paso 3. Carga de la imagen en el registro de la ventana acoplable
Después de haber creado la imagen de la ventana acoplable con el registro de inserción configurado (en nuestro caso, es docker.io), podemos enviar esta imagen al registro. Esto es lo que se muestra después de pedirle a Eclipse JKube que ejecute la tarea 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 : $
Después de enviar la imagen, debe verificar que esté en el registro. En nuestro caso, solo lo vemos en el Docker Hub, como se muestra en la Fig. 4.
Figura: 4. La imagen cargada en el registro apareció en Docker Hub.
Paso 4. Generación de manifiestos de recursos de Kubernetes para la aplicación
Entonces, hemos ensamblado la imagen de la aplicación, ahora necesitamos escribir manifiestos de Kubernetes. Para hacer esto, Eclipse JKube tiene una tarea que genera manifiestos de recursos físicos basados en el marco de Java subyacente ( Spring Boot , Quarkus , Vert.x, o algún otro). También puede personalizar el manifiesto utilizando un archivo XML de configuración y colocando fragmentos sin procesar (fragmentos del manifiesto de recursos necesarios) en la carpeta de la aplicación src / main / jkube. En este caso, su configuración se cargará en los manifiestos generados.
En nuestro ejemplo, dejamos todo como está y, por lo tanto, Eclipse JKube genera un manifiesto para el despliegue predeterminado y para el servicio con el tipo ClusterIP. Luego modificamos el manifiesto del servicio para cambiar el tipo de servicio a NodePort. Puede anular el comportamiento predeterminado mediante la siguiente propiedad:
<jkube.enricher.jkube-service.type>NodePort</jkube.enricher.jkube-service.type>
Así es como se ve la salida de la pantalla después de que le pedimos a Eclipse JKube que ejecute la tarea 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 : $
Paso 5. Implementar la aplicación en el clúster de Kubernetes
Entonces, estamos listos para implementar la aplicación: generamos su imagen y luego generamos automáticamente los manifiestos de recursos. Ahora todo lo que queda es aplicar todo esto al clúster de Kubernetes. Para implementar la aplicación, puede, por supuesto, usar el comando kubectl apply -f, pero el complemento puede hacerlo por nosotros. Esto es lo que aparece en la pantalla después de que le pedimos a Eclipse JKube que ejecute la tarea 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"
}
Paso 6. Realizar la anulación de implementación de la aplicación del clúster de Kubernetes
Para ello se utiliza la tarea de anulación de la implementación , que simplemente elimina todos los recursos que se aplicaron en el paso anterior, es decir, cuando se ejecutó la tarea de aplicar. Esto es lo que vemos en la pantalla después de que le pedimos a Eclipse JKube que ejecute la tarea 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 : $
¿Qué más puedes hacer con Eclipse JKube?
Por lo tanto, hemos cubierto los objetivos principales de Eclipse JKube y Kubernetes Maven Plugin, que facilitan el desarrollo de aplicaciones Java para la plataforma Kubernetes. Si no desea ingresar constantemente estas tareas desde el teclado, puede escribirlas en la configuración del complemento, por ejemplo, así:
<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>
Debo decir que en este artículo hemos considerado lejos de todas las tareas-objetivo que se encuentran en Eclipse JKube y Kubernetes Maven Plugin, por lo tanto, presentamos en la Tabla 2 una lista de tareas adicionales que también pueden serle útiles.
Lengüeta. 2. Objetivos adicionales de Eclipse JKube.
| Tarea | Etapa | Descripción |
|---|---|---|
| k8s: registro | VALIDAR | Recibir registros de una aplicación que se ejecuta en Kubernetes. |
| k8s: depurar | PAQUETE | Abrir un puerto de depuración para depurar su aplicación de Kubernetes directamente desde el IDE. |
| k8s: implementar | INSTALAR EN PC | Bifurcar la tarea de instalación y aplicar los manifiestos generados al clúster de Kubernetes es exactamente lo mismo que en el caso de la tarea de aplicación. |
| k8s: reloj | PAQUETE | Implementación automática en caliente de una aplicación mediante el seguimiento de su espacio de nombres. |
Implementación de aplicaciones Java en Red Hat OpenShift mediante el complemento OpenShift Maven
Para implementar la aplicación de nuestro ejemplo en la plataforma Red Hat OpenShift, usaremos el complemento OpenShift Maven . La única diferencia es que el prefijo de la tarea cambiará de k8s a oc. De forma predeterminada, el complemento Kubernetes Maven hace docker -sborki y conecta OpenShift Maven - ensamblaje S2i . No realizamos ningún cambio en nuestro proyecto, a excepción de eliminar la propiedad jkube.generator.name, ya que no es necesario al enviarlo al registro (durante la fase de compilación, OpenShift coloca la imagen en su registro interno). Y esto es lo que aparecerá en pantalla cuando ejecutemos nuestro ejemplo, en el que, por cierto, realizamos tareas-objetivo no una a una, sino todas a la vez:
~/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 : $
Video tutorial
Para obtener más información sobre cómo simplificar el desarrollo de Kubernetes con Eclipse JKube, vea el video tutorial sobre cómo implementar rápidamente una aplicación Spring Boot simple en Minikube:
Conclusión
En este artículo, mostramos cómo Eclipse JKube facilita la vida al desarrollador de Java cuando trabaja con Kubernetes. Se puede encontrar más información sobre Eclipse JKube en el sitio del proyecto y en GitHub .