Hace 25 años, Java se incorporó a las masas programadoras, convirtiéndose en uno de los pilares alrededor de los cuales se construyen los stacks de aplicaciones. Sin embargo, hoy en día, muchas personas y organizaciones que durante años han sido leales a Java están ocupadas en la transición o considerando la posibilidad de cambiarse a la plataforma o sus derivados, como o .
Lamentablemente, Kubernetes presenta una curva de aprendizaje pronunciada y introduce un nivel operativo adicional en el proceso de desarrollo familiar para los programadores de Java. Hoy vamos a hablar sobre cómo utilizar , para simplificar estas operaciones adicionales relacionadas con Kubernetes y contenedores, así como asegurar una migración fluida a la plataforma en la nube manteniendo el ecosistema familiar de Java. Además, mostraremos cómo desplegar aplicaciones Java en la plataforma OpenShift utilizando el complemento OpenShift Maven.
El proceso tradicional de desarrollo en Java
El proceso de desarrollo tradicional (Ilustración 1) implica que el desarrollador escribe código, luego crea unidades de despliegue en forma de archivos JAR o WAR, y luego despliega y ejecuta estos archivos en un servidor web o en un servidor de aplicaciones. Generalmente, se utiliza Maven desde la línea de comandos o se emplea una IDE, como IntelliJ o Eclipse, para codificar y empaquetar aplicaciones. Los desarrolladores están acostumbrados a realizar cambios en el código y a probarlo exhaustivamente antes de consolidarlo y enviarlo al sistema de control de versiones.
Ilustración 1. Proceso tradicional de desarrollo en Java.
Proceso de desarrollo en Java para la nube
Al migrar a aplicaciones en la nube, se añaden Kubernetes y . Por lo tanto, ahora el desarrollador debe empaquetar las 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 las aplicaciones de acuerdo con las configuraciones que especificamos en los manifiestos, que generalmente son archivos YAML.
La metamorfosis del proceso tradicional de desarrollo en Java al pasar a la nube se muestra en la Ilustración 2.
Ilustración 2. Proceso de desarrollo en Java para la nube.
Eclipse JKube
La transición a Kubernetes añade un nivel operativo adicional al proceso de desarrollo, lo cual inquieta a muchos desarrolladores, ya que desean concentrarse en su trabajo principal: la lógica de las aplicaciones, en lugar de cómo desplegarlas. Aquí es donde entra , que permite a los desarrolladores utilizar sus bibliotecas y plugins ( junto con o ), para realizar tareas relacionadas con contenedores y Kubernetes con facilidad, siguiendo el esquema en la Fig. 2.
En el resto de este artículo, mostraremos cómo simplificar el proceso de desarrollo Java en el entorno de Kubernetes utilizando Eclipse JKube con el plugin Kubernetes Maven Plugin.
El proceso de desarrollo para la nube usando Eclipse JKube
Tomemos un esquema ligeramente modificado del desarrollo Java para la nube según la Fig. 2, introduciendo Eclipse JKube y el plugin Kubernetes Maven Plugin, como se muestra en la Fig. 3.
Fig. 3. Proceso de desarrollo Java para la nube utilizando Eclipse JKube.
Como podemos ver, todas las operaciones de interacción con Kubernetes y contenedores (resaltadas en rojo en el esquema) son reemplazadas por las tareas de goals predeterminadas de Eclipse JKube, que se enumeran en la Tab. 1.
Tabl. 1. Tareas predeterminadas de Eclipse JKube.
Tarea
Etapa
Descripción
PRE_INTEGRATION_TEST
Construcción de imágenes docker
INSTALL
Envío de imágenes docker al registro
PROCESS_RESOURCES
Generación de manifiestos K8s
COMPILE
Aplicación de los manifiestos generados a K8s
UNDEPLOY
Eliminación de recursos K8s que fueron desplegados a través de k8s:apply y k8s:deploy
Nota: Si no deseas que las tareas usen estos defaults rígidos (defaults opinativos), puedes configurar manualmente Eclipse JKube a tu gusto, ya que éste soporta configuración a través de y .
Ahora veamos ejemplos de uso de Eclipse JKube y Kubernetes Maven Plugin al trabajar con aplicaciones.
Desplegando una aplicación Java en Kubernetes con Eclipse JKube
En este ejemplo, desplegaremos una sencilla aplicación Java en un clúster de usando Eclipse JKube. Con el plugin Kubernetes Maven Plugin, podemos especificar los parámetros de despliegue sin tener que escribir ninguna configuración.
Como ejemplo de aplicación, utilizamos , que devuelve un JSON-output en el endpoint /random:
~\/work\/repos\/eclipse-jkube-demo-project : $ curl localhost:8080\/random | jq .\n % Total % Received % Xferd Average Speed Time Time Time Current\n Dload Upload Total Spent Left Speed\n100 45 0 45 0 0 818 0 --:--:-- --:--:-- --:--:-- 818\n{\n \"id\": \"e80a4d10-c79b-4b9a-aaac-7c286cb37f3c\"\n}
Paso 1. Cargamos el Plugin de Maven para Kubernetes
El Plugin de Maven para Kubernetes se encuentra en el repositorio . Para usar Eclipse JKube, debes agregar el Plugin de Maven para Kubernetes en tu pom.xml como una dependencia:
<plugin>\n <groupId>org.eclipse.jkube<\/groupId>\n <artifactId>kubernetes-maven-plugin<\/artifactId>\n <version>${jkube.version}<\/version>\n <\/plugin>
Si se utiliza OpenShift en lugar de Kubernetes puro, entonces se modifica el pom.xml de la siguiente manera:
<plugin>\n <groupId>org.eclipse.jkube<\/groupId>\n <artifactId>openshift-maven-plugin<\/artifactId>\n <version>${jkube.version}<\/version>\n <\/plugin>
Paso 2. Construimos la imagen de Docker
El archivo JAR de la aplicación se puede construir con el comando mvn package, y luego se puede usar la tarea goal mvn k8s:build para construir la imagen de Docker de esta aplicación. Ten en cuenta que hemos sobrescrito el nombre de la imagen por defecto con esta propiedad:
<jkube.generator.name>docker.io\/rohankanojia\/random-generator:${project.version}<\/jkube.generator.name>
Antes de construir la imagen, debes asegurarte de que el demonio de Docker esté correctamente expuesto. 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 Docker con la tarea de construcción de Eclipse JKube:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:build\n[INFO] Escaneando proyectos...\n[INFO] \n[INFO] ----------------------< meetup:random-generator >-----------------------\n[INFO] Construyendo random-generator 0.0.1\n[INFO] --------------------------------[ jar ]---------------------------------\n[INFO] \n[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---\n[INFO] k8s: Ejecutando en modo Kubernetes\n[INFO] k8s: Construyendo imagen de Docker en modo Kubernetes\n[INFO] k8s: Ejecutando generador spring-boot\n[INFO] k8s: spring-boot: Usando imagen de Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 como base \/ generador\n[INFO] k8s: [docker.io\/rohankanojia\/random-generator:0.0.1] "spring-boot": Creado docker-build.tar en 251 milisegundos\n[INFO] k8s: [docker.io\/rohankanojia\/random-generator:0.0.1] "spring-boot": Imagen construida sha256:a20e5\n[INFO] ------------------------------------------------------------------------\n[INFO] CONSTRUCCIÓN EXITOSA\n[INFO] ------------------------------------------------------------------------\n[INFO] Tiempo total: 5.053 s\n[INFO] Finalizado a: 2020-08-10T11:28:23+05:30\n[INFO] ------------------------------------------------------------------------\n~\/work\/repos\/eclipse-jkube-demo-project : $
Paso 3. Enviamos la imagen al registro de Docker
Después de haber construido la imagen de Docker con el registro de push configurado (en nuestro caso es docker.io), podemos enviar esta imagen al registro. Esto es lo que aparecerá en la pantalla después de que le pidamos a Eclipse JKube que ejecute la tarea de push mvn k8s:push:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:push
[INFO] Escaneando proyectos...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Construyendo random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:push (default-cli) @ random-generator ---
[INFO] k8s: Ejecutando en modo Kubernetes
[INFO] k8s: Construyendo la imagen Docker en modo Kubernetes
[INFO] k8s: Ejecutando generador spring-boot
[INFO] k8s: spring-boot: Usando imagen Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 como base \/ constructor
[INFO] k8s: El push se refiere al repositorio [docker.io\/rohankanojia\/random-generator]
5dcd9556710f: La capa ya existe
b7139ad07aa8: La capa ya existe
b6f081e4b2b6: La capa ya existe
d8e1f35641ac: La capa ya existe
[INFO] k8s: 0.0.1: digest: sha256:9f9eda2a13b8cab1d2c9e474248500145fc09e2922fe3735692f9bda4c76002d tamaño: 1162
[INFO] k8s: Publicado docker.io\/rohankanojia\/random-generator:0.0.1 en 7 segundos
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUCCIÓN EXITOSA
[INFO] ------------------------------------------------------------------------
[INFO] Tiempo total: 11.222 s
[INFO] Terminado en: 2020-08-10T11:35:37+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $
Después de enviar la imagen, debemos verificar que haya ido al registro. En nuestro caso, simplemente la vemos en Docker Hub, como se muestra en la Fig. 4.
Fig. 4. La imagen enviada al registro apareció en Docker Hub.
Paso 4. Generamos los manifiestos de recursos de Kubernetes para la aplicación
Entonces, hemos construido la imagen de la aplicación, ahora debemos escribir los manifiestos de Kubernetes. Para ello, Eclipse JKube tiene una tarea que genera manifiestos de recursos rígidos, basándose en el marco Java subyacente (, , Vert.x o algún otro). También se puede configurar el manifiesto utilizando un archivo XML de configuración y colocando fragmentos en crudo (fragmentos del manifiesto de recursos requerido) en la carpeta de la aplicación src\/main\/jkube. En tal caso, su configuración se incorporará 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 tipo ClusterIP. Luego modificamos el manifiesto del servicio para cambiar el tipo de servicio a NodePort. Se puede sobrescribir el comportamiento predeterminado con la siguiente propiedad:
<jkube.enricher.jkube-service.type>NodePort<\/jkube.enricher.jkube-service.type>
Así es como se ve la salida en pantalla después de que pedimos a Eclipse JKube que ejecute la tarea de recursos mvn k8s:resource.
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:resource
[INFO] Escaneando proyectos...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Construyendo random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:resource (default-cli) @ random-generator ---
[INFO] k8s: Ejecutando generador spring-boot
[INFO] k8s: spring-boot: Usando imagen de Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 como base \/ constructor
[INFO] k8s: jkube-controller: Agregando un despliegue por defecto
[INFO] k8s: jkube-service: Agregando un servicio por defecto 'random-generator' con puertos [8080]
[INFO] k8s: jkube-healthcheck-spring-boot: Agregando sonda de disponibilidad en el puerto 8080, ruta='\/actuator\/health', esquema='HTTP', con un retraso inicial de 10 segundos
[INFO] k8s: jkube-healthcheck-spring-boot: Agregando sonda de vivacidad en el puerto 8080, ruta='\/actuator\/health', esquema='HTTP', con un retraso inicial de 180 segundos
[INFO] k8s: jkube-revision-history: Agregando límite de historial de revisiones a 2
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUCCIÓN EXITOSA
[INFO] ------------------------------------------------------------------------
[INFO] Tiempo total: 3.344 s
[INFO] Terminado en: 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. Desplegando la aplicación en el clúster de Kubernetes
Entonces, estamos listos para desplegar la aplicación: hemos generado su imagen y luego hemos generado automáticamente los manifiestos de recursos. Ahora solo queda aplicar todo esto al clúster de Kubernetes. Para desplegar la aplicación, se puede utilizar el comando kubectl apply -f, pero el plugin también 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 de aplicar mvn k8s:apply:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:apply
[INFO] Escaneando proyectos...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Construyendo random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] k8s: Usando Kubernetes en https:\/\/192.168.39.145:8443\/ en el namespace default con el manifiesto \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/classes\/META-INF\/jkube\/kubernetes.yml
[INFO] k8s: Usando namespace: default
[INFO] k8s: Creando un Servicio desde kubernetes.yml namespace default nombre random-generator
[INFO] k8s: Servicio creado: target\/jkube\/applyJson\/default\/service-random-generator.json
[INFO] k8s: Creando un Deployment desde kubernetes.yml namespace default nombre random-generator
[INFO] k8s: Deployment creado: target\/jkube\/applyJson\/default\/deployment-random-generator.json
[INFO] k8s: SUGERENCIA: Usa el comando `kubectl get pods -w` para observar el inicio de tus pods
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUCCIÓN EXITOSA
[INFO] ------------------------------------------------------------------------
[INFO] Tiempo total: 7.306 s
[INFO] Terminado en: 2020-08-10T11:40:57+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get pods -w
NOMBRE LISTO ESTADO REINICIOS EDAD
random-generator-58b7847d7f-9m9df 0\/1 En ejecución 0 7s
random-generator-58b7847d7f-9m9df 1\/1 En ejecución 0 17s
^C~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get svc
NOMBRE TIPO CLUSTER-IP EXTERNAL-IP PUERTO(S) EDAD
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 % Recibido % Transferido Velocidad Media Tiempo Tiempo Tiempo Actual
Dload Upload Total Gastado Queda Velocidad
100 45 0 45 0 0 1800 0 --:--:-- --:--:-- --:--:-- 1875
{
"id": "42e5571f-a20f-44b3-8184-370356581d10"
}
Paso 6. Realizando undeploy de la aplicación desde el clúster de Kubernetes
Para esto se utiliza la tarea undeploy, que simplemente elimina todos los recursos que fueron aplicados en el paso anterior, es decir, al ejecutar la tarea apply. Esto es lo que veremos en la pantalla después de que le pidamos a Eclipse JKube que ejecute la tarea de undeploy mvn k8s: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 443\/TCP 18d
service\/random-generator NodePort 10.97.172.147 8080:32186\/TCP 5m21s
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps\/random-generator 1\/1 1 1 5m21s
NAME DESIRED CURRENT READY AGE
replicaset.apps\/random-generator-58b7847d7f 1 1 1 5m21s
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:undeploy
[INFO] Scanning for projects...
[INFO]
[INFO] ---------------------------------------------
[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 443\/TCP 18d
~\/work\/repos\/eclipse-jkube-demo-project : $
¿Qué más se puede hacer con Eclipse JKube?
Hemos revisado los objetivos principales de Eclipse JKube y el Plugin de Maven para Kubernetes, que facilitan el desarrollo de aplicaciones Java para la plataforma Kubernetes. Si no deseas ingresar constantemente estos objetivos manualmente, puedes escribirlos en la configuración del plugin, por ejemplo, de esta manera:
org.eclipse.jkube
kubernetes-maven-plugin
${project.version}
build
resource
apply
Cabe destacar que en este artículo solo hemos abordado algunos de los objetivos de Eclipse JKube y del Plugin de Maven para Kubernetes, por lo que presentamos en la Tabla 2 una lista de tareas adicionales que también pueden ser útiles.
Tabla 2. Tareas adicionales de Eclipse JKube.
Tarea
Etapa
Descripción
VALIDAR
Obteniendo registros de la aplicación que se ejecuta en Kubernetes.
PAQUETE
Abrir el puerto de depuración para depurar la aplicación que se ejecuta en Kubernetes directamente desde la IDE.
INSTALL
Crear un fork para la tarea de Install y aplicar los manifiestos generados al clúster de Kubernetes de la misma manera que en la tarea apply.
PAQUETE
Implementación automática en caliente de la aplicación mediante el seguimiento de su espacio de nombres.
Despliegue de aplicaciones Java en Red Hat OpenShift utilizando OpenShift Maven Plugin
Para desplegar la aplicación de nuestro ejemplo en la plataforma Red Hat OpenShift, aplicaremos el plugin . La única diferencia será que el prefijo de las tareas cambiará de k8s a oc. Por defecto, el plugin Kubernetes Maven hace -construcciones, mientras que el plugin OpenShift Maven realiza construcciones . No haremos ningún cambio en nuestro proyecto, excepto eliminar la propiedad jkube.generator.name, ya que no es necesaria al enviar a un registro (en la etapa de construcción, OpenShift coloca la imagen en su registro interno). Y esto es lo que aparecerá en la pantalla cuando ejecutemos nuestro ejemplo, donde, por cierto, estamos ejecutando las tareas goal no una por una, sino todas a la vez:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn oc:build oc:resource oc:apply
[INFO] Escaneando proyectos...
[INFO]
[INFO] ---------------------------------------------
[INFO] Construyendo random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] oc: Usando la construcción de OpenShift con estrategia S2I
[INFO] oc: Ejecutando en modo OpenShift
[INFO] oc: Ejecutando generador spring-boot
[INFO] oc: spring-boot: Usando la imagen Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 como base \/ builder
[INFO] oc: [random-generator:0.0.1] "spring-boot": Creada la tar de fuente docker \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/docker\/random-generator\/0.0.1\/tmp\/docker-build.tar
[INFO] oc: Añadiendo a Secret pullsecret-jkube
[INFO] oc: Usando Secret pullsecret-jkube
[INFO] oc: Creando BuildServiceConfig random-generator-s2i para construcción de Fuente
[INFO] oc: Creando ImageStream random-generator
[INFO] oc: Iniciando Build random-generator-s2i
[INFO] oc: Esperando a que finalice la construcción random-generator-s2i-1...
[INFO] oc: Almacenando blobs bajo "\/var\/cache\/blobs".
[INFO] oc: Obteniendo firmas de fuente de imagen
[INFO] oc: Copiando blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Copiando blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Copiando blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Copiando config sha256:52d6788fcfdd39595264d34a3959464a5dabc1d4ef0ae188802b20fc2d6a857b
[INFO] oc: Escribiendo el manifiesto en el destino de la imagen
[INFO] oc: Almacenando firmas
[INFO] oc: Generando dockerfile con la imagen builder quay.io\/jkube\/jkube-java-binary-s2i:0.0.7
[INFO] oc: PASO 1: FROM quay.io\/jkube\/jkube-java-binary-s2i:0.0.7
[INFO] oc: PASO 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: PASO 3: ENV JAVA_APP_DIR="\/deployments" OPENSHIFT_BUILD_NAME="random-generator-s2i-1" OPENSHIFT_BUILD_NAMESPACE="default"
[INFO] oc: PASO 4: USER root
[INFO] oc: PASO 5: COPY upload\/src \/tmp\/src
[INFO] oc: PASO 6: RUN chown -R 1000:0 \/tmp\/src
[INFO] oc: PASO 7: USER 1000
[INFO] oc: PASO 8: RUN \/usr\/local\/s2i\/assemble
[INFO] oc: INFO Se detectó una construcción S2I con binarios en plano
[INFO] oc: INFO Se detectó una construcción S2I binaria del fabric8-maven-plugin
[INFO] oc: INFO Copiando binarios de \/tmp\/src\/deployments a \/deployments ...
[INFO] oc: random-generator-0.0.1.jar
[INFO] oc: INFO Copiando despliegues de deployments a \/deployments...
[INFO] oc: '\/tmp\/src\/deployments\/random-generator-0.0.1.jar' -> '\/deployments\/random-generator-0.0.1.jar'
[INFO] oc: PASO 9: CMD \/usr\/local\/s2i\/run
[INFO] oc: PASO 10: COMMITEAR temp.builder.openshift.io\/default\/random-generator-s2i-1:48795e41
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Desajuste del sistema operativo de la imagen: la imagen usa "", esperando "linux""
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Desajuste de arquitectura de la imagen: la imagen usa "", esperando "amd64""
[INFO] oc: Obteniendo firmas de fuente de imagen
[INFO] oc: Copiando blob sha256:d8e1f35641acb80b562f70cf49911341dfbe8c86f4d522b18efbf3732aa74223
[INFO] oc: Copiando blob sha256:b6f081e4b2b6de8be4b1dec132043d14c121e968384dd624fb69c2c07b482edb
[INFO] oc: Copiando blob sha256:b7139ad07aa8ce4ed5a132f7c5cc9f1de0f5099b5e155027a23d57f7fbe78b16
[INFO] oc: Copiando blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Copiando config sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Escribiendo el manifiesto en el destino de la imagen
[INFO] oc: Almacenando firmas
[INFO] oc: --> 27aaadaf28e
[INFO] oc: 27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Obteniendo firmas de fuente de imagen
[INFO] oc:
[INFO] oc: Empujando la imagen image-registry.openshift-image-registry.svc:5000\/default\/random-generator:0.0.1 ...
[INFO] oc: Copiando blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Copiando blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Copiando blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Copiando blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Copiando config sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Escribiendo el manifiesto en el destino de la imagen
[INFO] oc: Almacenando firmas
[INFO] oc: Imagen pushada exitosamente - image-registry.openshift-image-registry.svc:5000\/default\/random-generator@sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: Push exitoso
[INFO] oc: Build random-generator-s2i-1 en estado Completo
[INFO] oc: Encontrada etiqueta en ImageStream random-generator etiqueta: sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: ImageStream random-generator escrito en \/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: Usando el nombre de imagen docker del namespace: default
[INFO] oc: Ejecutando generador spring-boot
[INFO] oc: spring-boot: Usando la imagen Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 como base \/ builder
[INFO] oc: jkube-controller: Añadiendo un DeploymentConfig predeterminado
[INFO] oc: jkube-service: Añadiendo un servicio predeterminado 'random-generator' con puertos [8080]
[INFO] oc: jkube-healthcheck-spring-boot: Añadiendo probe de disponibilidad en el puerto 8080, ruta='\/actuator\/health', esquema='HTTP', con un retraso inicial de 10 segundos
[INFO] oc: jkube-healthcheck-spring-boot: Añadiendo probe de vivacidad en el puerto 8080, ruta='\/actuator\/health', esquema='HTTP', con un retraso inicial de 180 segundos
[INFO] oc: jkube-revision-history: Añadiendo límite de historial de revisiones a 2
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] oc: Usando OpenShift en https:\/\/api.crc.testing:6443\/ en el namespace default con el manifiesto \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/classes\/META-INF\/jkube\/openshift.yml
[INFO] oc: Plataforma OpenShift detectada
[INFO] oc: Usando proyecto: default
[INFO] oc: Creando un Servicio desde openshift.yml namespace default nombre random-generator
[INFO] oc: Servicio creado: target\/jkube\/applyJson\/default\/service-random-generator.json
[INFO] oc: Creando un DeploymentConfig desde openshift.yml namespace default nombre random-generator
[INFO] oc: DeploymentConfig creado: target\/jkube\/applyJson\/default\/deploymentconfig-random-generator.json
[INFO] oc: Creando Route default:random-generator host: null
[INFO] oc: SUGERENCIA: Usa el comando `oc get pods -w` para observar cómo se inician tus pods
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUCCIÓN EXITOSA
[INFO] ------------------------------------------------------------------------
[INFO] Tiempo total: 01:07 min
[INFO] Finalizado en: 2020-08-10T12:08:00+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $ oc get pods -w
NOMBRE LISTO ESTADO REINICIOS EDAD
random-generator-1-deploy 1\/1 En ejecución 0 14s
random-generator-1-vnrm9 0\/1 En ejecución 0 11s
random-generator-s2i-1-build 0\/1 Completado 0 1m
random-generator-1-vnrm9 1\/1 En ejecución 0 24s
random-generator-1-deploy 0\/1 Completado 0 28s
~\/work\/repos\/eclipse-jkube-demo-project : $ oc get routes
NOMBRE HOST\/PUERTO RUTA SERVICIOS PUERTO TERMINACIÓN WILDCARD
random-generator random-generator-default.apps-crc.testing random-generator 8080 Ninguno
~\/work\/repos\/eclipse-jkube-demo-project : $ curl random-generator-default.apps-crc.testing\/random
% Total % Recibido % Transferido Velocidad Media Tiempo Tiempo Tiempo Actual
Dload Subida Total Gastado Restante Velocidad
100 45 0 45 0 0 1666 0 --:--:-- --:--:-- --:--:-- 1730
{
"id": "d80052d9-2f92-43cb-b9eb-d7cffb879798"
}
~\/work\/repos\/eclipse-jkube-demo-project : $
Video tutorial
Para saber más sobre cómo simplificar el desarrollo de Kubernetes con Eclipse JKube, vea el video tutorial sobre el despliegue rápido de una aplicación Spring Boot simple en Minikube:
Conclusión
En este artículo, mostramos cómo Eclipse JKube facilita la vida a los desarrolladores de Java que trabajan con Kubernetes. Más información sobre Eclipse JKube se puede encontrar en y en .
Fuente: habr.com
