Há 25 anos, Java entrou no mainstream da programação e eventualmente se tornou um dos elementos centrais em torno dos quais as pilhas de aplicativos são construídas. Hoje, porém, muitas pessoas e organizações que são leais ao Java há muitos anos estão ocupadas migrando ou considerando migrar para a plataforma. ou seus derivados, como ou .
Infelizmente, o Kubernetes tem uma curva de aprendizado acentuada e introduz outra camada operacional no processo de desenvolvimento com a qual os programadores Java estão acostumados. Hoje vamos te contar como usar , para simplificar essas operações adicionais associadas ao Kubernetes e contêineres e garantir uma migração tranquila para a plataforma em nuvem, mantendo o ecossistema Java familiar. Além disso, mostraremos como implantar aplicativos Java na plataforma OpenShift usando o plugin OpenShift Maven.
Processo tradicional de desenvolvimento Java
Processo de desenvolvimento tradicional (Figura 1) envolve a escrita do código pelo desenvolvedor, a criação de unidades de implantação na forma de arquivos JAR ou WAR e a implantação e execução desses arquivos em um servidor Web ou de aplicativos. A principal maneira de fazer isso é usar o Maven na linha de comando ou usar um IDE como IntelliJ ou Eclipse para codificar e empacotar os aplicativos. Os desenvolvedores estão acostumados a fazer alterações no código e testar tudo minuciosamente antes de submeter o código e submetê-lo ao controle de versão.
Arroz. 1. Processo tradicional de desenvolvimento Java.
Processo de desenvolvimento Java para a nuvem
Ao migrar para aplicativos em nuvem, Kubernetes e . Portanto, agora o desenvolvedor precisa empacotar aplicativos Java em e crie manifestos do Kubernetes que descrevam essas imagens. Esses manifestos são então aplicados ao servidor de produção que executa o Kubernetes. Por sua vez, o Kubernetes pega essas imagens do registro e implanta os aplicativos de acordo com as configurações que escrevemos nos manifestos, que geralmente são arquivos YAML.
A metamorfose do processo tradicional de desenvolvimento Java na transição para a nuvem é mostrada na Fig. 2.
Arroz. 2. Processo de desenvolvimento Java para a nuvem.
Eclipse JKube
A migração para o Kubernetes adiciona outra camada operacional ao processo de desenvolvimento, e muitos desenvolvedores ficam nervosos com isso porque querem se concentrar em seu trabalho principal – a lógica do aplicativo – em vez de em como implantá-los. E é aqui que entra em jogo. , que permite aos desenvolvedores usar suas bibliotecas e plug-ins ( com ou ) para executar facilmente operações relacionadas ao contêiner e ao Kubernetes seguindo o diagrama da Figura. 2.
No restante deste artigo, mostraremos como simplificar o processo de desenvolvimento Java no ambiente Kubernetes usando Eclipse JKube com o plug-in Kubernetes Maven.
Processo de desenvolvimento em nuvem usando Eclipse JKube
Vamos considerar um esquema de desenvolvimento Java ligeiramente modificado para a nuvem da Fig. 2, introduzindo Eclipse JKube e Kubernetes Maven Plugin nele, conforme mostrado na Fig. 3.
Arroz. 3. Processo de desenvolvimento Java para nuvem usando Eclipse JKube.
Como podemos ver, aqui todas as operações de interação com Kubernetes e contêineres (destacadas em vermelho no diagrama) são substituídas pelas tarefas de meta padrão do Eclipse JKube, listadas na Tabela. 1.
Mesa 1. Tarefas padrão do Eclipse JKube.
Tarefa
Etapa
descrição
PRE_INTEGRATION_TEST
Construindo imagens do Docker
INSTALAR
Fazendo upload de imagens do Docker para o registro
PROCESS_RESOURCES
Gerando manifestos K8s
COMPILAR
Aplicando manifestos gerados a K8s
DESEMPREGAR
Removendo recursos K8s que foram implantados usando k8s:apply e k8s:deploy
Nota: Se não quiser que as tarefas usem esses padrões opinativos, você pode configurar manualmente o Eclipse JKube por conta própria, pois ele suporta configuração via и .
Agora vamos ver exemplos de uso do Eclipse JKube e Kubernetes Maven Plugin ao trabalhar com aplicativos.
Implantando um aplicativo Java no Kubernetes usando Eclipse JKube
Neste exemplo iremos implantar uma aplicação Java simples em um cluster usando Eclipse JKube. Usando o plug-in Kubernetes Maven, podemos definir parâmetros de implantação sem precisar escrever nenhuma configuração.
Como exemplo de aplicação usamos , 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 Kubernetes Maven
O plug-in Kubernetes Maven está no repositório . 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 o OpenShift for usado em vez do Kubernetes puro, o pom.xml será modificado da seguinte forma:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>openshift-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Etapa 2. Construir a imagem do Docker
O arquivo JAR do aplicativo pode ser construído com o comando mvn package e, em seguida, a tarefa mvn goal k8s:build pode ser usada para construir uma imagem docker do 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 ter certeza 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 que veremos na tela ao construir a imagem docker usando a tarefa de construção do 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. Faça upload da imagem para o registro do Docker
Depois de construirmos a imagem docker com o registro push configurado (no nosso caso é docker.io), podemos enviar esta imagem para o registro. Isto é o que será exibido depois que pedirmos 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 : $
Após o envio da imagem, é necessário verificar se ela está incluída no registro. No nosso caso, simplesmente vemos isso no Docker Hub, conforme mostrado na Fig. 4.
Arroz. 4. A imagem enviada ao registro apareceu no Docker Hub.
Etapa 4. Gerar manifestos de recursos do Kubernetes para o aplicativo
Então, coletamos a imagem do aplicativo, agora precisamos escrever os manifestos do Kubernetes. Para fazer isso, o Eclipse JKube possui uma tarefa que gera manifestos de recursos rígidos com base na estrutura Java subjacente (, , Vert.x ou algum outro). Você também pode personalizar o manifesto usando um arquivo de configuração XML e colocando fragmentos brutos (fragmentos do manifesto de recurso necessário) na pasta do aplicativo src/main/jkube. Neste caso, sua configuração será carregada nos manifestos gerados.
Em nosso exemplo, deixamos tudo como está e, portanto, o Eclipse JKube gera um manifesto para a implantação padrão e para o serviço do tipo ClusterIP. E só então 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 de recurso 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 : $
Etapa 5. Implantar o aplicativo no cluster Kubernetes
Agora estamos prontos para implantar o aplicativo: geramos sua imagem e, em seguida, geramos manifestos de recursos automaticamente. Agora só falta aplicar tudo isso ao cluster Kubernetes. Para implantar o aplicativo, você pode, é claro, usar o comando kubectl apply -f, mas o plug-in pode fazer isso por nós. Isto é o que aparecerá na tela depois que pedirmos 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. Cancelar implantação de aplicativos do cluster Kubernetes
Para isso, utiliza-se a tarefa undeploy, que simplesmente remove todos os recursos que foram aplicados na etapa anterior, ou seja, quando a tarefa apply é executada. Isto é o que veremos na tela depois de pedirmos ao Eclipse JKube para executar 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 : $
O que mais você pode fazer com Eclipse JKube
Assim, analisamos as principais tarefas do Eclipse JKube e do Kubernetes Maven Plugin, que facilitam o desenvolvimento de aplicativos Java para a plataforma Kubernetes. Se você não quiser entrar constantemente nessas tarefas pelo 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>
Deve-se dizer que neste artigo não consideramos todas as tarefas de objetivo que estão no Eclipse JKube e no Kubernetes Maven Plugin, portanto, fornecemos na Tabela 2 uma lista de tarefas adicionais que também podem ser úteis para você.
Mesa 2. Tarefas adicionais de meta do Eclipse JKube.
Tarefa
Etapa
descrição
VALIDAR
Recebendo logs de um aplicativo em execução no Kubernetes.
PACKAGE
Abra uma porta de depuração para poder depurar seu aplicativo em execução no Kubernetes diretamente do IDE.
INSTALAR
Criar uma bifurcação para a tarefa Instalar e aplicar os manifestos gerados ao cluster Kubernetes da mesma forma que no caso da tarefa aplicar.
PACKAGE
Implantação dinâmica 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 do nosso exemplo na plataforma Red Hat OpenShift, usamos o plugin . A única diferença será que o prefixo da tarefa mudará de k8s para oc. Por padrão, o plugin Kubernetes Maven faz -assemblies e o plugin OpenShift Maven - assemblies . Não estamos fazendo nenhuma alteração em nosso projeto além de remover a propriedade jkube.generator.name, pois ela não é necessária ao enviar para o registro (o OpenShift coloca a imagem em seu registro interno durante a fase de construção). E é isso que aparecerá na tela quando executarmos nosso exemplo, no qual, aliás, realizamos tarefas objetivas não uma de cada vez, 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 aula
Para saber mais sobre como facilitar o desenvolvimento do Kubernetes com Eclipse JKube, assista a este tutorial em vídeo sobre como implantar rapidamente um aplicativo Spring Boot simples no Minikube:
Conclusão
Neste artigo, mostramos como o Eclipse JKube facilita a vida de um desenvolvedor Java ao trabalhar com Kubernetes. Mais informações sobre o Eclipse JKube podem ser encontradas em e .
Fonte: habr.com