Hai 25 anos, Java entrou na corrente principal da programación e, finalmente, converteuse nun dos elementos fundamentais arredor dos que se constrúen as pilas de aplicacións. Hoxe, porén, moitas persoas e organizacións que foron leais a Java durante moitos anos están ocupadas migrando ou considerando migrar á plataforma. ou os seus derivados como ou .
Desafortunadamente, Kubernetes ten unha curva de aprendizaxe pronunciada e introduce outra capa operativa no proceso de desenvolvemento ao que están afeitos os programadores de Java. Hoxe imos dicirche como usar , para simplificar estas operacións adicionais asociadas a Kubernetes e contedores, e garantir unha migración sen dolor á plataforma na nube mantendo o ecosistema Java familiar. Ademais, mostraremos como implementar aplicacións Java na plataforma OpenShift usando o complemento OpenShift Maven.
Proceso de desenvolvemento tradicional de Java
Proceso de desenvolvemento tradicional (Figura 1) implica que o programador escribe código, despois crea unidades de despregamento en forma de ficheiros JAR ou WAR e, a continuación, implanta e executa estes ficheiros nun servidor web ou de aplicacións. A principal forma de facelo é usar Maven desde a liña de comandos ou usar un IDE como IntelliJ ou Eclipse para codificar e empaquetar as aplicacións. Os desenvolvedores están afeitos a facer cambios no código e probar todo a fondo antes de comprometer o código e envialo ao control de versións.
Arroz. 1. Proceso de desenvolvemento tradicional de Java.
Proceso de desenvolvemento de Java para a nube
Ao pasar a aplicacións na nube, Kubernetes e . Polo tanto, agora o programador necesita empaquetar aplicacións Java e crea manifestos de Kubernetes que describen estas imaxes. Estes manifestos aplícanse despois ao servidor de produción que executa Kubernetes. Á súa vez, Kubernetes toma estas imaxes do rexistro e desprega aplicacións segundo as configuracións que escribimos nos manifestos, que normalmente son ficheiros YAML.
A metamorfose do proceso de desenvolvemento tradicional de Java na transición á nube móstrase na Fig. 2.
Arroz. 2. Proceso de desenvolvemento de Java para a nube.
Eclipse JKube
A migración a Kubernetes engade outra capa operativa ao proceso de desenvolvemento, e moitos desenvolvedores están nerviosos por iso porque queren centrarse no seu traballo principal (a lóxica da aplicación) en lugar de como implementalas. E aquí é onde entra en xogo. , que permite aos desenvolvedores usar as súas bibliotecas e complementos ( xunto con ou ) para realizar sen esforzo operacións relacionadas co contedor e Kubernetes seguindo o diagrama da figura. 2.
No resto deste artigo, mostrarémosche como simplificar o proceso de desenvolvemento de Java no ambiente Kubernetes usando Eclipse JKube co complemento Kubernetes Maven.
Proceso de desenvolvemento na nube usando Eclipse JKube
Consideremos un esquema de desenvolvemento Java lixeiramente modificado para a nube da figura 2, introducindo nel Eclipse JKube e o complemento Kubernetes Maven, como se mostra na figura. 3.
Arroz. 3. Proceso de desenvolvemento de Java para a nube mediante Eclipse JKube.
Como podemos ver, aquí todas as operacións para interactuar con Kubernetes e contedores (resaltadas en vermello no diagrama) substitúense por defecto por tarefas de obxectivos de Eclipse JKube, que se enumeran na Táboa. 1.
Táboa 1. Tarefas predeterminadas de Eclipse JKube.
Tarefa
Etapa
Descrición
PRE_INTEGRATION_TEST
Creación de imaxes docker
Instalar
Cargando imaxes docker ao rexistro
PROCESS_RESOURCES
Xeración de manifestos K8s
COMPILAR
Aplicando manifestos xerados aos K8
DESDEPREGO
Eliminando os recursos de K8s que se despregaron usando k8s:apply e k8s:deploy
Nota: Se non queres que as tarefas usen estes valores predeterminados de opinión, podes configurar manualmente Eclipse JKube por ti mesmo, xa que admite a configuración mediante и .
Agora vexamos exemplos de uso de Eclipse JKube e Kubernetes Maven Plugin ao traballar con aplicacións.
Implementación dunha aplicación Java en Kubernetes usando Eclipse JKube
Neste exemplo, implementaremos unha aplicación Java sinxela nun clúster usando Eclipse JKube. Usando o complemento Kubernetes Maven, podemos establecer parámetros de implementación sen ter que escribir ningunha configuración.
Como aplicación de exemplo usamos , que produce saída JSON no 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. Descarga o complemento Kubernetes Maven
O complemento Kubernetes Maven está no repositorio . Para usar Eclipse JKube, debes engadir o complemento Kubernetes Maven ao teu pom.xml como dependencia:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>kubernetes-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Se se usa OpenShift en lugar de Kubernetes puro, entón pom.xml modifícase do seguinte xeito:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>openshift-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Paso 2. Constrúe a imaxe do docker
O ficheiro JAR da aplicación pódese crear co comando mvn package e, a continuación, a tarefa mvn goal k8s:build pódese usar para construír unha imaxe docker da aplicación. Teña en conta que substituímos o nome da imaxe predeterminado con esta propiedade:
<jkube.generator.name>docker.io/rohankanojia/random-generator:${project.version}</jkube.generator.name>
Antes de construír a imaxe, cómpre asegurarse de que o daemon docker está exposto correctamente. Isto pódese facer co seguinte comando:
$ eval $(minikube docker-env)
Despois introducimos o comando mvn k8s:build, e isto é o que veremos na pantalla ao crear a imaxe docker usando a tarefa 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. Cargue a imaxe no rexistro docker
Despois de construír a imaxe docker co rexistro push configurado (no noso caso é docker.io), podemos enviar esta imaxe ao rexistro. Isto é o que se mostrará despois de que lle pidamos a Eclipse JKube que realice a tarefa 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 : $
Despois de enviar a imaxe, cómpre comprobar que está incluída no rexistro. No noso caso, simplemente vémolo en Docker Hub, como se mostra na Fig. 4.
Arroz. 4. A imaxe enviada ao rexistro apareceu en Docker Hub.
Paso 4. Xera manifestos de recursos de Kubernetes para a aplicación
Entón, recollemos a imaxe da aplicación, agora necesitamos escribir manifestos de Kubernetes. Para iso, Eclipse JKube ten unha tarefa que xera manifestos de recursos ríxidos baseados no marco Java subxacente (, , Vert.x ou algún outro). Tamén pode personalizar o manifesto usando un ficheiro de configuración XML e colocando fragmentos en bruto (fragmentos do manifesto do recurso necesario) no cartafol da aplicación src/main/jkube. Neste caso, a súa configuración cargarase nos manifestos xerados.
No noso exemplo, deixamos todo como está e, polo tanto, Eclipse JKube xera un manifesto para a implantación predeterminada e para o servizo con tipo ClusterIP. E só entón modificamos o manifesto do servizo para cambiar o tipo de servizo a NodePort. Pode anular o comportamento predeterminado usando a seguinte propiedade:
<jkube.enricher.jkube-service.type>NodePort</jkube.enricher.jkube-service.type>
Este é o aspecto da saída da pantalla despois de que lle pedimos a Eclipse JKube que realice a tarefa 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: [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. Implementa a aplicación no clúster de Kubernetes
Agora xa estamos preparados para implementar a aplicación: xeramos a súa imaxe e despois xeramos automaticamente manifestos de recursos. Agora só queda aplicar todo isto ao clúster de Kubernetes. Para implementar a aplicación, pode, por suposto, usar o comando kubectl apply -f, pero o complemento pode facelo por nós. Isto é o que aparecerá na pantalla despois de que lle pidamos a Eclipse JKube que execute a tarefa 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 a implantación de aplicacións do clúster de Kubernetes
Para iso, utilízase a tarefa de non despregamento, que simplemente elimina todos os recursos que se aplicaron no paso anterior, é dicir, cando se executa a tarefa de aplicación. Isto é o que veremos na pantalla despois de que lle pidamos a Eclipse JKube que realice a tarefa 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 máis podes facer con Eclipse JKube
Así, analizamos as tarefas principais de Eclipse JKube e Kubernetes Maven Plugin, que facilitan o desenvolvemento de aplicacións Java para a plataforma Kubernetes. Se non queres introducir constantemente estas tarefas desde o teclado, podes escribilas na configuración do complemento, por exemplo, 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>
Cómpre dicir que neste artigo non consideramos todas as tarefas de obxectivos que hai en Eclipse JKube e Kubernetes Maven Plugin, polo que ofrecemos na Táboa 2 unha lista de tarefas adicionais que tamén che poden ser útiles.
Táboa 2. Tarefas adicionais do obxectivo de Eclipse JKube.
Tarefa
Etapa
Descrición
VALIDAR
Recibir rexistros dunha aplicación que se executa en Kubernetes.
Paquete
Abre un porto de depuración para que poidas depurar a túa aplicación que se executa en Kubernetes directamente desde o IDE.
Instalar
Crear unha bifurcación para a tarefa Instalar e aplicar os manifestos xerados ao clúster de Kubernetes do mesmo xeito que no caso da tarefa de aplicación.
Paquete
Implementación automática en quente dunha aplicación mediante o seguimento do seu espazo de nomes.
Implementación de aplicacións Java en Red Hat OpenShift usando o complemento OpenShift Maven
Para implementar a aplicación do noso exemplo na plataforma Red Hat OpenShift, usamos o complemento . A única diferenza será que o prefixo da tarefa cambiará de k8s a oc. Por defecto, o complemento Kubernetes Maven faino -conxuntos e o complemento OpenShift Maven - conxuntos . Non estamos a facer ningún cambio no noso proxecto, agás a eliminación da propiedade jkube.generator.name, xa que non é necesaria ao empurrar ao rexistro (Durante a fase de compilación, OpenShift coloca a imaxe no seu rexistro interno). E isto é o que aparecerá na pantalla cando executemos o noso exemplo, no que, por certo, realizamos tarefas de obxectivos non unha a unha, senón todas á 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 obter máis información sobre como facilitar o desenvolvemento de Kubernetes con Eclipse JKube, vexa este tutorial en vídeo sobre como implementar rapidamente unha aplicación Spring Boot sinxela en Minikube:
Conclusión
Neste artigo, mostramos como Eclipse JKube facilita a vida dun programador Java cando traballa con Kubernetes. Podes atopar máis información sobre Eclipse JKube en e .
Fonte: www.habr.com