Hace 25 años, Java entró en la corriente principal de la programación y finalmente se convirtió en uno de los elementos centrales en torno a los cuales se construyen las pilas de aplicaciones. Hoy en día, sin embargo, muchas personas y organizaciones que han sido leales a Java durante muchos años están ocupadas migrando o considerando migrar a la plataforma. o sus derivados como o .
Desafortunadamente, Kubernetes tiene una curva de aprendizaje pronunciada e introduce otra capa operativa en el proceso de desarrollo a la que los programadores de Java están acostumbrados. Hoy te contamos cómo utilizar , para simplificar estas operaciones adicionales asociadas con Kubernetes y contenedores, y garantizar 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
Proceso de desarrollo tradicional (Figura 1) implica que el desarrollador escriba código, luego cree unidades de implementación en forma de archivos JAR o WAR y luego implemente y ejecute estos archivos en un servidor web o de aplicaciones. La forma principal de hacerlo es utilizar Maven desde la línea de comandos o utilizar un IDE como IntelliJ o Eclipse para codificar y empaquetar las aplicaciones. Los desarrolladores están acostumbrados a realizar cambios en el código y probar todo minuciosamente antes de enviar el código y enviarlo al control de versiones.
Arroz. 1. Proceso de desarrollo tradicional de Java.
Proceso de desarrollo de Java para la nube
Al pasar a aplicaciones en la nube, Kubernetes y . Por lo tanto, ahora el desarrollador necesita empaquetar aplicaciones Java en y crear manifiestos de Kubernetes que describan estas imágenes. Luego, estos manifiestos se aplican al servidor de producción que ejecuta Kubernetes. A su vez, Kubernetes toma estas imágenes del registro y despliega aplicaciones según las configuraciones que hayamos escrito en manifiestos, que suelen ser archivos YAML.
La metamorfosis del proceso de desarrollo tradicional de Java en la transición a la nube se muestra en la Fig. 2.
Arroz. 2. Proceso de desarrollo de Java para la nube.
eclipse jkube
La migración a Kubernetes agrega otra capa operativa al proceso de desarrollo, y muchos desarrolladores están nerviosos porque quieren centrarse en su trabajo principal (la lógica de la aplicación) en lugar de cómo implementarlas. Y aquí es donde entra en juego. , que permite a los desarrolladores utilizar sus bibliotecas y complementos ( con o ) para realizar sin esfuerzo operaciones relacionadas con contenedores y Kubernetes siguiendo el diagrama de la Figura. 2.
En el resto de este artículo, le mostraremos cómo simplificar el proceso de desarrollo de Java en el entorno de Kubernetes utilizando Eclipse JKube con el complemento Kubernetes Maven.
Proceso de desarrollo en la nube utilizando Eclipse JKube
Consideremos un esquema de desarrollo de Java ligeramente modificado para la nube de la Fig. 2, introduciendo en él Eclipse JKube y Kubernetes Maven Plugin, como se muestra en la Fig. 3.
Arroz. 3. Proceso de desarrollo 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 tareas de objetivo predeterminadas de Eclipse JKube, que se enumeran en la tabla. 1.
Mesa 1. Tareas predeterminadas de Eclipse JKube.
Tarea
Etapa
Descripción
PRUEBA_PRE_INTEGRACIÓN
Imágenes de la ventana acoplable del edificio
INSTALAR
Subir imágenes de Docker al registro
PROCESO_RECURSOS
Generando manifiestos K8
COMPILAR
Aplicar manifiestos generados a K8
DESPLEGAR
Eliminación de recursos de K8 que se implementaron usando k8s:apply y k8s:deploy
Nota: Si no desea que las tareas utilicen estos valores predeterminados obstinados, puede configurar manualmente Eclipse JKube usted mismo, ya que admite la configuración a través de и .
Ahora veamos ejemplos de uso de Eclipse JKube y Kubernetes Maven Plugin cuando trabajamos con aplicaciones.
Implementación de una aplicación Java en Kubernetes usando Eclipse JKube
En este ejemplo implementaremos una aplicación Java simple en un clúster. utilizando Eclipse JKube. Con el complemento Kubernetes Maven, podemos establecer parámetros de implementación sin tener que escribir ninguna configuración.
Como aplicación de ejemplo utilizamos , 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 está en el repositorio . 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, entonces 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 crear con el comando del paquete mvn y luego la tarea de objetivo mvn k8s:build se puede utilizar para crear una imagen acoplable de la aplicación. Tenga en cuenta que hemos anulado el nombre de imagen predeterminado 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 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 veremos en la pantalla al construir la imagen de la ventana acoplable usando la tarea de compilación de 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. Sube la imagen al registro de Docker
Después de haber creado la imagen de Docker con el registro push configurado (en nuestro caso es docker.io), podemos enviar esta imagen al registro. Esto es lo que se mostrará después de que le pidamos a Eclipse JKube que realice 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, debes comprobar que esté incluida en el registro. En nuestro caso, simplemente lo vemos en Docker Hub, como se muestra en la Fig. 4.
Arroz. 4. La imagen enviada al registro apareció en Docker Hub.
Paso 4. Generar manifiestos de recursos de Kubernetes para la aplicación.
Entonces, hemos recopilado 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 rígidos basados en el marco Java subyacente (, , Vert.x o algún otro). También puede personalizar el manifiesto utilizando un archivo de configuración XML y colocando fragmentos sin formato (fragmentos del manifiesto de recursos requerido) 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 la implementación predeterminada y para el servicio con tipo ClusterIP. Y solo entonces modificamos el manifiesto del servicio para cambiar el tipo de servicio a NodePort. Puede anular el comportamiento predeterminado utilizando 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 realice la tarea de recursos 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: [email protected]: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
Ahora estamos listos para implementar la aplicación: generamos su imagen y luego generamos automáticamente manifiestos de recursos. Ahora solo queda aplicar todo esto al cluster de Kubernetes. Para implementar la aplicación, por supuesto, puede usar el comando kubectl apply -f, pero el complemento puede hacerlo por nosotros. Esto es lo que aparecerá en la pantalla después de que le pidamos 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. Anular la implementación de aplicaciones del clúster de Kubernetes
Para ello se utiliza la tarea undeploy, que simplemente elimina todos los recursos que se aplicaron en el paso anterior, es decir, cuando se ejecuta la tarea apply. Esto es lo que veremos en la pantalla después de pedirle a Eclipse JKube que realice 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?
Entonces, analizamos las tareas principales de Eclipse JKube y Kubernetes Maven Plugin, que facilitan el desarrollo de aplicaciones Java para la plataforma Kubernetes. Si no deseas ingresar constantemente estas tareas desde el teclado, puedes 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>
Hay que decir que en este artículo no hemos considerado todas las tareas objetivo que se encuentran en Eclipse JKube y Kubernetes Maven Plugin, por lo que proporcionamos en la Tabla 2 una lista de tareas adicionales que también pueden resultarle útiles.
Mesa 2. Tareas de objetivos adicionales de Eclipse JKube.
Tarea
Etapa
Descripción
VALIDAR
Recibir registros de una aplicación que se ejecuta en Kubernetes.
PAQUETE
Abra un puerto de depuración para poder depurar su aplicación que se ejecuta en Kubernetes directamente desde el IDE.
INSTALAR
Crear una bifurcación para la tarea de instalación y aplicar los manifiestos generados al clúster de Kubernetes de la misma manera que en el caso de la tarea de aplicación.
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 utilizando el complemento OpenShift Maven
Para implementar la aplicación de nuestro ejemplo en la plataforma Red Hat OpenShift, usamos el complemento . La única diferencia será que el prefijo de la tarea cambiará de k8s a oc. De forma predeterminada, el complemento Kubernetes Maven no -ensamblajes y el complemento OpenShift Maven - ensamblajes . No realizaremos ningún cambio en nuestro proyecto más que eliminar la propiedad jkube.generator.name, ya que no es necesaria al enviar al registro (OpenShift coloca la imagen en su registro interno durante la fase de compilación). Y esto es lo que aparecerá en pantalla cuando ejecutemos nuestro ejemplo, en el que, por cierto, realizamos las tareas objetivo no una a la vez, 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 lección
Para obtener más información sobre cómo facilitar el desarrollo de Kubernetes con Eclipse JKube, mire este 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 le facilita la vida a un desarrollador de Java cuando trabaja con Kubernetes. Puede encontrar más información sobre Eclipse JKube en y .
Fuente: habr.com