Há 25 anos, o Java foi divulgado entre os programadores, tornando-se um dos pilares em torno dos quais são construídos os stacks de aplicativos. No entanto, hoje muitas pessoas e organizações que há anos mantêm lealdade ao Java estão ocupadas mudando ou considerando a mudança para a plataforma ou suas variantes, como ou .
Infelizmente, o Kubernetes tem uma curva de aprendizado íngreme e introduz mais um nível operacional no processo de desenvolvimento familiar para os programadores Java. Hoje, vamos mostrar como usar , para simplificar essas operações adicionais relacionadas ao Kubernetes e containers, além de garantir uma migração tranquila para a plataforma em nuvem mantendo o ecossistema Java conhecido. Além disso, mostraremos como implantar aplicações Java na plataforma OpenShift usando o plugin OpenShift Maven.
O processo tradicional de desenvolvimento Java
O processo tradicional de desenvolvimento (Fig. 1) implica que o desenvolvedor escreve o código, depois cria as unidades de implantação na forma de arquivos JAR ou WAR e, em seguida, implementa e executa esses arquivos em um servidor web ou servidor de aplicativos. Normalmente, isso é feito usando o Maven a partir da linha de comando ou utilizando uma IDE, como IntelliJ ou Eclipse, para codificar e empacotar aplicativos. Os desenvolvedores estão acostumados a fazer alterações no código e testar tudo cuidadosamente antes de fixar o código e enviá-lo para o sistema de controle de versões.
Fig. 1. O processo tradicional de desenvolvimento Java.
O processo de desenvolvimento Java para a nuvem
Ao migrar para aplicações em nuvem, o esquema descrito acima é complementado pelo Kubernetes e . Portanto, agora o desenvolvedor precisa empacotar aplicações Java em e criar manifests do Kubernetes que descrevam essas imagens. Em seguida, esses manifests são aplicados ao servidor de produção, onde o Kubernetes está operando. Por sua vez, o Kubernetes pega essas imagens do registro e implanta as aplicações de acordo com as configurações que descrevemos nos manifests, que geralmente são arquivos YAML.
A metamorfose do processo tradicional de desenvolvimento Java ao migrar para a nuvem é mostrada na Fig. 2.
Fig. 2. O processo de desenvolvimento Java para a nuvem.
Eclipse JKube
A transição para o Kubernetes adiciona mais um nível operacional ao processo de desenvolvimento, e muitos desenvolvedores ficam nervosos com isso, pois desejam se concentrar em seu trabalho principal - a lógica dos aplicativos - e não na forma como implantá-los. E aqui entra , que permite aos desenvolvedores usar suas bibliotecas e plugins ( junto com ou ), para realizar operações relacionadas a contêineres e Kubernetes sem esforço, seguindo o esquema na Fig. 2.
Na parte restante deste artigo, mostraremos como simplificar o processo de desenvolvimento Java em um ambiente Kubernetes, utilizando o Eclipse JKube com o plugin Kubernetes Maven.
Processo de desenvolvimento para a nuvem com Eclipse JKube
Vamos considerar um esquema ligeiramente modificado de desenvolvimento Java para a nuvem com a Fig. 2, introduzindo o Eclipse JKube e o Kubernetes Maven Plugin, como mostrado na Fig. 3.
Fig. 3. Processo de desenvolvimento Java para a nuvem com Eclipse JKube.
Como podemos ver, todas as operações de interação com Kubernetes e contêineres (destacadas em vermelho no esquema) são substituídas por tarefas padrão do Eclipse JKube, que estão listadas na Tab. 1.
Tab. 1. Tarefas padrão do Eclipse JKube.
Tarefa
Etapa
Descrição
PRE_INTEGRATION_TEST
Construção de imagens Docker
INSTALL
Envio de imagens Docker para o registro
PROCESS_RESOURCES
Geração de manifestos K8s
COMPILE
Aplicação dos manifestos gerados ao K8s
UNDEPLOY
Remoção de recursos K8s que foram implantados via k8s:apply e k8s:deploy
Nota: Se você não quiser que as tarefas usem esses padrões rígidos (defaults opinionados), pode personalizar manualmente o Eclipse JKube, já que ele suporta configuração através de e .
Agora vamos considerar exemplos de uso do Eclipse JKube e do Kubernetes Maven Plugin ao trabalhar com aplicativos.
Implantando um aplicativo Java no Kubernetes com Eclipse JKube
Neste exemplo, vamos implantar um simples aplicativo Java em um cluster com o Eclipse JKube. Usando o Kubernetes Maven Plugin, podemos definir os parâmetros de implantação sem ter que especificar qualquer configuração.
Como exemplo de aplicativo, usamos , que produz uma saída JSON no endpoint \/random:
~\/work\/repos\/eclipse-jkube-demo-project : $ curl localhost:8080\/random | jq .
% Total % Recebido % Transferido Velocidade Média Tempo Tempo Tempo Atual
Download Upload Total Gastos Restante Velocidade
100 45 0 45 0 0 818 0 --:--:-- --:--:-- --:--:-- 818
{
"id": "e80a4d10-c79b-4b9a-aaac-7c286cb37f3c"
}
Etapa 1. Carregando o Kubernetes Maven Plugin
O Kubernetes Maven Plugin está no repositório . Para usar o Eclipse JKube, você deve adicionar o Kubernetes Maven Plugin ao seu pom.xml como uma dependência:
org.eclipse.jkube
kubernetes-maven-plugin
${jkube.version}
Se em vez do Kubernetes puro você estiver usando o OpenShift, então o pom.xml deve ser modificado da seguinte forma:
org.eclipse.jkube
openshift-maven-plugin
${jkube.version}
Etapa 2. Construindo a imagem docker
O arquivo JAR da aplicação pode ser gerado com o comando mvn package, e em seguida você pode usar a tarefa goal mvn k8s:build para construir a imagem docker dessa aplicação. Observe que redefinimos o nome da imagem padrão usando esta propriedade:
docker.io/rohankanojia/random-generator:${project.version}
Antes de construir a imagem, é necessário garantir que o daemon do docker esteja corretamente exposto. Você pode fazer isso com o seguinte comando:
$ eval $(minikube docker-env)
Em seguida, digite o comando mvn k8s:build, e aqui está o que veremos na tela ao construir a imagem docker com a tarefa de build do Eclipse JKube:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:build
[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: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. Enviando a imagem para o registro docker
Após construirmos a imagem docker com o registro de push configurado (neste caso, docker.io), podemos enviar essa imagem para o registro. Aqui está o que será exibido na tela após pedirmos ao Eclipse JKube para executar a tarefa de push mvn k8s:push:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:push
[INFO] Escaneando projetos...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Construindo random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:push (default-cli) @ random-generator ---
[INFO] k8s: Executando em modo Kubernetes
[INFO] k8s: Construindo imagem Docker em modo Kubernetes
[INFO] k8s: Executando gerador spring-boot
[INFO] k8s: spring-boot: Usando imagem Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 como base \/ builder
[INFO] k8s: O push se refere ao repositório [docker.io\/rohankanojia\/random-generator]
5dcd9556710f: Camada já existe
b7139ad07aa8: Camada já existe
b6f081e4b2b6: Camada já existe
d8e1f35641ac: Camada já existe
[INFO] k8s: 0.0.1: digest: sha256:9f9eda2a13b8cab1d2c9e474248500145fc09e2922fe3735692f9bda4c76002d tamanho: 1162
[INFO] k8s: Enviado docker.io\/rohankanojia\/random-generator:0.0.1 em 7 segundos
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUÇÃO COM SUCESSO
[INFO] ------------------------------------------------------------------------
[INFO] Tempo total: 11.222 s
[INFO] Finalizado em: 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 chegou ao repositório. No nosso caso, podemos vê-la no Docker Hub, como mostrado na Fig. 4.
Fig. 4. A imagem enviada para o repositório apareceu no Docker Hub.
Passo 4. Gerando manifestos de recursos Kubernetes para o aplicativo
Assim, a imagem do aplicativo foi criada, agora precisamos escrever os manifestos Kubernetes. Para isso, o Eclipse JKube possui uma tarefa que gera manifestos rígidos de recursos, baseando-se no framework Java subjacente (, , Vert.x ou algum outro). Também é possível configurar o manifesto utilizando um arquivo XML de configuração e colocando fragmentos em bruto (fragmentos do manifesto de recursos requerido) na pasta src\/main\/jkube do aplicativo. Nesse caso, sua configuração será incorporada aos manifestos gerados.
No nosso exemplo, deixamos tudo como está, e por isso o Eclipse JKube gera o manifesto para a implantação padrão e para o serviço com tipo ClusterIP. Em seguida, modificamos o manifesto do serviço para mudar o tipo de serviço para NodePort. O comportamento padrão pode ser sobrescrito com a seguinte propriedade:
<jkube.enricher.jkube-service.type>NodePort<\/jkube.enricher.jkube-service.type>
Veja como fica a saída na tela após pedirmos 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] ---------------------------------------------
[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 : $
Passo 5. Implantando a aplicação no cluster Kubernetes
Agora estamos prontos para realizar a implantação da aplicação: geramos sua imagem e, em seguida, os manifestos de recursos foram gerados automaticamente. Agora, tudo o que resta é aplicar isso ao cluster Kubernetes. Para implantar a aplicação, você pode usar o comando kubectl apply -f, mas o plugin também pode fazer isso por nós. Veja o que aparecerá na tela após pedirmos ao Eclipse JKube para executar a tarefa de apply: mvn k8s:apply:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:apply
[INFO] Escaneando projetos...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Construindo 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 em https:\/\/192.168.39.145:8443\/ no namespace default com o manifesto \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/classes\/META-INF\/jkube\/kubernetes.yml
[INFO] k8s: Usando namespace: default
[INFO] k8s: Criando um Service a partir de kubernetes.yml namespace default nome random-generator
[INFO] k8s: Service criado: target\/jkube\/applyJson\/default\/service-random-generator.json
[INFO] k8s: Criando um Deployment a partir de kubernetes.yml namespace default nome random-generator
[INFO] k8s: Deployment criado: target\/jkube\/applyJson\/default\/deployment-random-generator.json
[INFO] k8s: DICA: Use o comando `kubectl get pods -w` para observar seus pods iniciando
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUÇÃO COM SUCESSO
[INFO] ------------------------------------------------------------------------
[INFO] Tempo total: 7.306 s
[INFO] Finalizado em: 2020-08-10T11:40:57+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get pods -w
NOME PRONTO STATUS RESTARTS IDADE
random-generator-58b7847d7f-9m9df 0\/1 Executando 0 7s
random-generator-58b7847d7f-9m9df 1\/1 Executando 0 17s
^C~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get svc
NOME TIPO CLUSTER-IP EXTERNAL-IP PORT(S) IDADE
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 % Recebido % Transferido Velocidade Média Tempo Tempo Tempo Atual
Dload Upload Total Gasto Restante Velocidade
100 45 0 45 0 0 1800 0 --:--:-- --:--:-- --:--:-- 1875
{
"id": "42e5571f-a20f-44b3-8184-370356581d10"
}
Passo 6. Fazendo undeploy do aplicativo do cluster Kubernetes
Para isso, utiliza-se a tarefa undeploy, que simplesmente remove todos os recursos que foram aplicados na etapa anterior, ou seja, ao executar a tarefa apply. É isso que veremos na tela após solicitarmos ao Eclipse JKube executar a tarefa 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: DICA: 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 : $
O que mais pode ser feito com o Eclipse JKube
Agora, revisamos as principais metas do Eclipse JKube e do Kubernetes Maven Plugin, que facilitam o desenvolvimento de aplicativos Java para a plataforma Kubernetes. Se você não quer digitar essas tarefas o tempo todo, pode escrevê-las na configuração do plugin, por exemplo, assim:
org.eclipse.jkube
kubernetes-maven-plugin
${project.version}
build
resource
apply
Devo dizer que este artigo não examinou todas as metas disponíveis no Eclipse JKube e no Kubernetes Maven Plugin, portanto, apresentamos na Tabela 2 uma lista de tarefas adicionais que também podem ser úteis para você.
Tabela 2. Tarefas adicionais do Eclipse JKube.
Tarefa
Etapa
Descrição
VALIDAR
Obter logs do aplicativo em execução no Kubernetes.
PACOTE
Abertura da porta de depuração para realizar a depuração de um aplicativo em execução no Kubernetes diretamente do IDE.
INSTALL
Criação de um fork para a tarefa de instalação e aplicação dos manifestos gerados ao cluster Kubernetes da mesma forma que na tarefa apply.
PACOTE
Implantação automática em tempo real do aplicativo através do monitoramento de seu namespace.
Implantação de aplicativos Java no Red Hat OpenShift usando o OpenShift Maven Plugin
Para implantar o aplicativo do nosso exemplo na plataforma Red Hat OpenShift, utilizaremos o plugin . A única diferença será que o prefixo das tarefas mudará de k8s para oc. Por padrão, o plugin Kubernetes Maven faz -builds, enquanto o plugin OpenShift Maven faz builds . Não fazemos alterações no nosso projeto, exceto pela remoção da propriedade jkube.generator.name, pois não é necessária ao enviar para o registro (na fase de construção, o OpenShift armazena a imagem em seu registro interno). E aqui está o que aparecerá na tela ao executarmos nosso exemplo, onde, aliás, estamos realizando as tarefas goal 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] ---------------------------------------------
[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: Utilizando OpenShift para construir com estratégia S2I
[INFO] oc: Executando em modo OpenShift
[INFO] oc: Executando gerador spring-boot
[INFO] oc: spring-boot: Usando imagem Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 como base \/ builder
[INFO] oc: [random-generator:0.0.1] "spring-boot": Criada tar de origem docker \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/docker\/random-generator\/0.0.1\/tmp\/docker-build.tar
[INFO] oc: Adicionando ao Secret pullsecret-jkube
[INFO] oc: Usando Secret pullsecret-jkube
[INFO] oc: Criando BuildServiceConfig random-generator-s2i para construção de origem
[INFO] oc: Criando ImageStream random-generator
[INFO] oc: Iniciando Build random-generator-s2i
[INFO] oc: Aguardando a conclusão da build random-generator-s2i-1...
[INFO] oc: Armazenando blobs em "\/var\/cache\/blobs".
[INFO] oc: Obtendo assinaturas da imagem de origem
[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: Escrevendo manifest para destino da imagem
[INFO] oc: Armazenando assinaturas
[INFO] oc: Gerando dockerfile com imagem builder quay.io\/jkube\/jkube-java-binary-s2i:0.0.7
[INFO] oc: ETAPA 1: FROM quay.io\/jkube\/jkube-java-binary-s2i:0.0.7
[INFO] oc: ETAPA 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: ETAPA 3: ENV JAVA_APP_DIR="\/deployments" OPENSHIFT_BUILD_NAME="random-generator-s2i-1" OPENSHIFT_BUILD_NAMESPACE="default"
[INFO] oc: ETAPA 4: USUÁRIO root
[INFO] oc: ETAPA 5: COPIAR upload\/src \/tmp\/src
[INFO] oc: ETAPA 6: RUN chown -R 1000:0 \/tmp\/src
[INFO] oc: ETAPA 7: USUÁRIO 1000
[INFO] oc: ETAPA 8: RUN \/usr\/local\/s2i\/assemble
[INFO] oc: INFO: Construção de origem S2I com binários simples detectada
[INFO] oc: INFO: Construção binária S2I do fabric8-maven-plugin detectada
[INFO] oc: INFO: Copiando binários de \/tmp\/src\/deployments para \/deployments ...
[INFO] oc: random-generator-0.0.1.jar
[INFO] oc: INFO: Copiando implantações de deployments para \/deployments...
[INFO] oc: '\/tmp\/src\/deployments\/random-generator-0.0.1.jar' -> '\/deployments\/random-generator-0.0.1.jar'
[INFO] oc: ETAPA 9: CMD \/usr\/local\/s2i\/run
[INFO] oc: ETAPA 10: COMMIT temp.builder.openshift.io\/default\/random-generator-s2i-1:48795e41
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Imagem do sistema operacional em desacordo: imagem usa "", esperando "linux""
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Imagem arquitetura em desacordo: imagem usa "", esperando "amd64""
[INFO] oc: Obtendo assinaturas da imagem de origem
[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: Escrevendo manifest para destino da imagem
[INFO] oc: Armazenando assinaturas
[INFO] oc: --> 27aaadaf28e
[INFO] oc: 27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Obtendo assinaturas da imagem de origem
[INFO] oc:
[INFO] oc: Enviando imagem 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: Escrevendo manifest para destino da imagem
[INFO] oc: Armazenando assinaturas
[INFO] oc: Imagem enviada com sucesso para image-registry.openshift-image-registry.svc:5000\/default\/random-generator@sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: Envio bem-sucedido
[INFO] oc: Construção random-generator-s2i-1 em status Completo
[INFO] oc: Encontrado tag no ImageStream random-generator tag: sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: ImageStream random-generator escrito para \/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 nome da imagem docker do namespace: default
[INFO] oc: Executando gerador spring-boot
[INFO] oc: spring-boot: Usando imagem Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 como base \/ builder
[INFO] oc: jkube-controller: Adicionando um DeploymentConfig padrão
[INFO] oc: jkube-service: Adicionando um serviço padrão 'random-generator' com portas [8080]
[INFO] oc: jkube-healthcheck-spring-boot: Adicionando probe de readiness na porta 8080, caminho='\/actuator\/health', esquema='HTTP', com atraso inicial de 10 segundos
[INFO] oc: jkube-healthcheck-spring-boot: Adicionando probe de liveness na porta 8080, caminho='\/actuator\/health', esquema='HTTP', com atraso inicial de 180 segundos
[INFO] oc: jkube-revision-history: Adicionando limite de histórico de revisões para 2
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] oc: Usando OpenShift em https:\/\/api.crc.testing:6443\/ no namespace default com manifesto \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/classes\/META-INF\/jkube\/openshift.yml
[INFO] oc: Plataforma OpenShift detectada
[INFO] oc: Usando projeto: default
[INFO] oc: Criando um serviço a partir de openshift.yml namespace default nome random-generator
[INFO] oc: Serviço criado: target\/jkube\/applyJson\/default\/service-random-generator.json
[INFO] oc: Criando um DeploymentConfig a partir de openshift.yml namespace default nome random-generator
[INFO] oc: DeploymentConfig criado: target\/jkube\/applyJson\/default\/deploymentconfig-random-generator.json
[INFO] oc: Criando Rota default:random-generator host: null
[INFO] oc: DICA: Use o comando `oc get pods -w` para observar o inicialização dos seus pods
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUÇÃO SUCESSO
[INFO] ------------------------------------------------------------------------
[INFO] Tempo total: 01:07 min
[INFO] Finalizado em: 2020-08-10T12:08:00+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $ oc get pods -w
NOME PRONTO STATUS REINICIAÇÕES IDADE
random-generator-1-deploy 1\/1 Executando 0 14s
random-generator-1-vnrm9 0\/1 Executando 0 11s
random-generator-s2i-1-build 0\/1 Concluído 0 1m
random-generator-1-vnrm9 1\/1 Executando 0 24s
random-generator-1-deploy 0\/1 Concluído 0 28s
~\/work\/repos\/eclipse-jkube-demo-project : $ oc get routes
NOME HOST\/PORT CAMINHO SERVIÇOS PORTA TERMINAÇÃO WILDCARD
random-generator random-generator-default.apps-crc.testing random-generator 8080 Nenhum
~\/work\/repos\/eclipse-jkube-demo-project : $ curl random-generator-default.apps-crc.testing\/random
% Total % Recebido % Transferido Velocidade Média Tempo Tempo Tempo Atual
Dload Upload Total Gasto Restante Velocidade
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 simplificar o desenvolvimento de Kubernetes com Eclipse JKube, assista ao vídeo-aula sobre a implementação rápida de uma aplicação Spring Boot simples no Minikube:
Conclusão
Neste artigo, mostramos como o Eclipse JKube facilita a vida do desenvolvedor Java ao trabalhar com Kubernetes. Mais informações sobre o Eclipse JKube podem ser encontradas em e no .
Fonte: habr.com
