Clever Geek Handbook

Desenvolvendo aplicativos Java para Kubernetes usando Eclipse JKube

25 anos atrás, Java entrou nos programadores convencionais para eventualmente se tornar um dos pilares em torno do qual as pilhas de aplicativos são construídas. No entanto, hoje muitas pessoas e organizações que têm sido fiéis ao Java por anos estão ocupadas migrando ou considerando a migração para o Kubernetes ou seus derivados, como Red Hat OpenShift ou Amazon EKS .







Infelizmente, o Kubernetes tem uma curva de aprendizado íngreme e introduz ainda outra camada operacional no processo de desenvolvimento Java. Hoje vamos mostrar como usar o Eclipse JKubepara simplificar essas operações adicionais relacionadas a Kubernetes e contêineres, bem como fornecer migração indolor para a plataforma de nuvem enquanto mantém o ecossistema Java familiar. Além disso, mostraremos como implantar aplicativos Java na plataforma OpenShift usando o plugin OpenShift Maven.



Processo de desenvolvimento Java tradicional



O processo de desenvolvimento Java tradicional (Figura 1) significa que um desenvolvedor grava o código e, em seguida, cria unidades de implantação como arquivos JAR ou WAR e, em seguida, implanta e executa esses arquivos em um servidor da web ou de aplicativos. Geralmente, eles usam Maven a partir da linha de comando ou usam um IDE como IntelliJ ou Eclipse para codificar e empacotar aplicativos. Os desenvolvedores estão acostumados a fazer alterações no código e a testar tudo completamente antes de confirmar o código e enviá-lo ao controle de origem.







Figura: 1. O processo de desenvolvimento Java tradicional.



Processo de desenvolvimento Java para a nuvem



Mudar para aplicativos em nuvem adiciona Kubernetes e contêineres ao esquema acima . Portanto, o desenvolvedor agora precisa empacotar aplicativos Java em imagens de contêiner e criar manifestos Kubernetes que descrevem essas imagens. Esses manifestos são então aplicados ao servidor de produção em que o Kubernetes está sendo executado. Por sua vez, o Kubernetes obtém essas imagens do registro e implanta aplicativos de acordo com as configurações que escrevemos nos manifestos, que geralmente são arquivos YAML.



A metamorfose do desenvolvimento Java tradicional na transição para a nuvem é mostrada na Fig. 2







Figura: 2. Processo de desenvolvimento Java para a nuvem.



Eclipse JKube



A mudança para o Kubernetes adiciona outra camada operacional ao processo de desenvolvimento, e isso é enervante para muitos desenvolvedores porque eles querem fazer seu trabalho principal - a lógica dos aplicativos - não como implantá-los. É aqui que entra o Eclipse JKube , que permite que os desenvolvedores usem suas bibliotecas e plug-ins ( JKube Kit junto com o Kubernetes Maven Plugin ou OpenShift Maven Plugin ) para realizar operações de contêiner e relacionadas ao Kubernetes sem esforço, seguindo o diagrama da Figura 2.



No restante deste artigo, mostraremos como simplificar o processo de desenvolvimento Java no Kubernetes usando o Eclipse JKube com o plug-in Kubernetes Maven.



Processo de desenvolvimento em nuvem usando Eclipse JKube



Vejamos a estrutura de desenvolvimento Java ligeiramente modificada para a nuvem da Figura 2, apresentando o Eclipse JKube e o plug-in Kubernetes Maven, conforme mostrado na Figura 2. 3 -







Figura: 3. Processo de desenvolvimento Java para nuvem usando Eclipse JKube.



Como podemos ver, aqui todas as operações para interagir com Kubernetes e contêineres (destacadas em vermelho no diagrama) são substituídas por tarefas de meta Eclipse JKube padrão, que estão listadas na Tabela. 1.



Tab. 1. Tarefas padrão do Eclipse JKube.



Tarefa Palco Descrição
k8s: build PRE_INTEGRATION_TEST Criação de imagens docker
k8s: push INSTALAR Carregando imagens do docker para o registro
k8s: recurso PROCESS_RESOURCES Gerando manifestos K8s
k8s: aplicar COMPILAR Aplicando Manifestos Gerados a K8s
k8s: desdobrar UNDEPLOY Removendo ativos K8s que foram implantados com k8s: apply e k8s: deploy


Nota: Se você não deseja que as tarefas usem esses padrões opinativos, você pode customizar manualmente o Eclipse JKube para você mesmo, uma vez que ele suporta configuração via XML e recursos .



Agora, vamos ver exemplos de como usar o Eclipse JKube e o plug-in Kubernetes Maven ao trabalhar com aplicativos.



Implante o aplicativo Java no Kubernetes usando Eclipse JKube



Neste exemplo, vamos implementar um aplicativo Java simples no cluster Minikube usando Eclipse JKube. Usando o plug-in Maven do Kubernetes, podemos definir opções de implantação sem precisar escrever nenhuma configuração.



Como um aplicativo de exemplo, usamos um gerador de número aleatório simples que produz saída JSON no endpoint / 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"
}


Etapa 1. Baixe o plug-in Maven do Kubernetes O



plug-in Maven do Kubernetes está localizado no repositório central do Maven . Para usar o Eclipse JKube, você precisa adicionar o plug-in Kubernetes Maven ao seu pom.xml como uma dependência: 



<plugin>
     <groupId>org.eclipse.jkube</groupId>
     <artifactId>kubernetes-maven-plugin</artifactId>
     <version>${jkube.version}</version>
 </plugin>


Se OpenShift for usado em vez de Kubernetes puro, o pom.xml será modificado da seguinte maneira: 



<plugin>
     <groupId>org.eclipse.jkube</groupId>
     <artifactId>openshift-maven-plugin</artifactId>
     <version>${jkube.version}</version>
 </plugin>


Etapa 2. Construir a imagem docker O



arquivo JAR do aplicativo pode ser construído com o comando mvn package e, em seguida, você pode usar a tarefa mvn k8s: build goal para construir a imagem docker deste aplicativo. Observe que substituímos o nome da imagem padrão por esta propriedade: 



<jkube.generator.name>docker.io/rohankanojia/random-generator:${project.version}</jkube.generator.name>


Antes de construir a imagem, você precisa se certificar de que o daemon do docker está exposto corretamente. Isso pode ser feito com o seguinte comando: 



$ eval $(minikube docker-env)


Em seguida, inserimos o comando mvn k8s: build, e isso é o que vemos na tela ao construir a imagem do docker usando a tarefa de construção 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 : $


Etapa 3. Carregando a imagem para o registro do docker



Depois de criar a imagem do docker com o registro push configurado (em nosso caso, é docker.io), podemos enviar essa imagem para o registro. Isso é o que é exibido depois que pedimos ao Eclipse JKube para executar 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 : $


Depois de enviar a imagem, é necessário verificar se ela está no registro. Em nosso caso, apenas o vemos no Docker Hub, conforme mostrado na Fig. 4 -







Figura: 4. A imagem carregada no registro apareceu no Docker Hub.



Etapa 4. Gerando manifestos de recursos do Kubernetes para o aplicativo



Então, montamos a imagem do aplicativo, agora precisamos escrever manifestos do Kubernetes. Para fazer isso, o Eclipse JKube tem uma tarefa que gera manifestos de recursos físicos com base na estrutura Java subjacente ( Spring Boot , Quarkus , Vert.x ou algum outro). Você também pode personalizar o manifesto usando um arquivo XML de configuração e colocando fragmentos brutos (fragmentos do manifesto de recurso necessário) na pasta do aplicativo src / main / jkube. Nesse caso, sua configuração será enviada para os manifestos gerados.



Em nosso exemplo, deixamos tudo como está e, portanto, o Eclipse JKube gera um manifesto para a implementação padrão e para o serviço com o tipo ClusterIP. Em seguida, modificamos o manifesto do serviço para alterar o tipo de serviço para NodePort. Você pode substituir o comportamento padrão usando a seguinte propriedade: 



<jkube.enricher.jkube-service.type>NodePort</jkube.enricher.jkube-service.type>


Esta é a aparência da saída da tela depois que pedimos ao Eclipse JKube para executar 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: 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 : $


Etapa 5. Implantar o aplicativo no cluster Kubernetes



Então, estamos prontos para implantar o aplicativo: geramos sua imagem e, em seguida, geramos manifestos de recursos automaticamente. Agora, tudo o que resta é aplicar tudo isso ao cluster do Kubernetes. Para implantar o aplicativo, você pode, é claro, usar o comando kubectl apply -f, mas o plug-in pode fazer isso por nós. Isso é o que aparece na tela depois que pedimos ao Eclipse JKube para executar 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"
}


Etapa 6. Desfazemos a implantação do aplicativo do cluster Kubernetes



Para isso, é utilizada a tarefa de desimplantar , que simplesmente exclui todos os recursos que foram aplicados na etapa anterior, ou seja, quando a tarefa de aplicação foi executada. Isso é o que vemos na tela depois de pedirmos ao Eclipse JKube para executar o mvn k8s: undeploy undeploy task: 



~/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 : $


O que mais você pode fazer com Eclipse JKube



Portanto, cobrimos os principais objetivos do Eclipse JKube e do Kubernetes Maven Plugin, que facilitam o desenvolvimento de aplicativos Java para a plataforma Kubernetes. Se não quiser entrar constantemente nessas tarefas a partir do teclado, você pode escrevê-las na configuração do plugin, por exemplo, assim: 



<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>


Devo dizer que neste artigo consideramos longe de todas as tarefas-objetivo que estão no Eclipse JKube e no Plug-in do Kubernetes Maven, portanto, apresentamos na Tabela 2 uma lista de tarefas adicionais que também podem ser úteis para você.



Aba. 2. Objetivos adicionais do Eclipse JKube.



Tarefa Palco Descrição
k8s: log VALIDAR Receber registros de um aplicativo em execução no Kubernetes.
k8s: debug PACOTE Abrindo uma porta de depuração para depurar seu aplicativo Kubernetes diretamente do IDE.
k8s: deploy INSTALAR A bifurcação da tarefa de instalação e a aplicação dos manifestos gerados ao cluster Kubernetes são exatamente as mesmas da tarefa de aplicação.
k8s: assistir PACOTE Implantação automática automática de um aplicativo rastreando seu namespace.


Implantando aplicativos Java no Red Hat OpenShift usando o plug-in OpenShift Maven



Para implantar o aplicativo de nosso exemplo na plataforma Red Hat OpenShift, usaremos o plugin OpenShift Maven . A única diferença é que o prefixo da tarefa mudará de k8s para oc. Por padrão, o plugin Kubernetes Maven faz docker -sborki e plug OpenShift Maven - assembly S2i . Não fazemos nenhuma alteração em nosso projeto, exceto para remover a propriedade jkube.generator.name, uma vez que não é necessária ao enviar para o registro (durante a fase de construção, o OpenShift coloca a imagem em seu registro interno). E é isso que aparecerá na tela quando executarmos nosso exemplo, no qual, a propósito, realizamos tarefas-objetivo não uma a uma, mas todas de uma 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 : $


Vídeo tutorial



Para saber mais sobre como simplificar o desenvolvimento do Kubernetes com Eclipse JKube, assista ao tutorial em vídeo sobre como implantar rapidamente um aplicativo Spring Boot simples no Minikube:





Conclusão



Neste artigo, mostramos como o Eclipse JKube torna a vida mais fácil para um desenvolvedor Java ao trabalhar com Kubernetes. Mais informações sobre o Eclipse JKube podem ser encontradas no site do projeto e no GitHub .


More articles:


All Articles