For 25 years, Java has been widely adopted by programmers, ultimately becoming one of the pillars around which application stacks are built. However, today many individuals and organizations that have long remained loyal to Java are busy transitioning or considering a move to the platform or its derivatives, such as eller .
Unfortunately, Kubernetes has a steep learning curve and introduces yet another operational layer into the development process familiar to Java developers. Today, we will discuss how to use , to simplify the additional operations associated with Kubernetes and containers, as well as ensure a smooth migration to the cloud platform while retaining the familiar Java ecosystem. Furthermore, we will demonstrate how to deploy Java applications on the OpenShift platform using the OpenShift Maven plugin.
The traditional Java development process
The traditional development process (Fig. 1) involves the developer writing code, then creating deployment units in the form of JAR or WAR files, and subsequently deploying and running these files on a web server or application server. Generally, Maven is used from the command line, or IDEs like IntelliJ or Eclipse are utilized to code and package applications. Developers are accustomed to making changes to the code and thoroughly testing everything before committing the code and pushing it to the version control system.
Fig. 1. The traditional Java development process.
The Java development process for the cloud
When transitioning to cloud applications, Kubernetes and are added to the scheme described above. As a result, the developer now needs to package Java applications into and create Kubernetes manifests describing these images. These manifests are then applied to the production server running Kubernetes. In turn, Kubernetes retrieves these images from the registry and deploys applications according to the configurations specified in the manifests, which are typically YAML files.
The metamorphosis of the traditional Java development process when moving to the cloud is shown in Fig. 2.
Fig. 2. The Java development process for the cloud.
Eclipse JKube
Overgangen til Kubernetes tilfører et nytt driftsnivå i utviklingsprosessen, og mange utviklere føler seg stresset, fordi de ønsker å fokusere på sitt hovedarbeid – applikasjonslogikken – og ikke på hvordan de skal distribuere det. Her kommer , som lar utviklere bruke sine biblioteker og plugins ( sammen med eller ), for enkelt å utføre operasjoner knyttet til containere og Kubernetes, i samsvar med diagrammet i Fig. 2.
I den resterende delen av denne artikkelen vil vi vise hvordan vi kan forenkle Java-utviklingsprosessen i et Kubernetes-miljø ved å bruke Eclipse JKube med Kubernetes Maven Plugin.
Utviklingsprosess for skyen med Eclipse JKube
La oss se på et lett modifisert diagram over Java-utvikling for skyen med Fig. 2, der vi introduserer Eclipse JKube og Kubernetes Maven Plugin, som vist i Fig. 3.
Fig. 3. Java-utviklingsprosess for skyen med Eclipse JKube.
Som vi ser, blir alle operasjoner for interaksjon med Kubernetes og containere (markert i rødt på diagrammet) erstattet av Eclipse JKubes standardmåloppgaver, som er oppført i Tabell 1.
Tabell 1. Standardoppgaver for Eclipse JKube.
Oppgave
Etappe
Description
PRE_INTEGRATION_TEST
Bygging av docker-bilder
INSTALL
Sending av docker-bilder til registret
PROCESS_RESOURCES
Generering av K8s-manifester
COMPILE
Anvendelse av de genererte manifestene til K8s
UNDEPLOY
Fjerning av K8s-ressurser som ble distribuert via k8s:apply og k8s:deploy
Merk: Hvis du ikke vil at oppgavene skal bruke disse strenge standardene (opinionated defaults), kan du manuelt konfigurere Eclipse JKube etter dine behov, siden det støtter konfigurasjon via og .
Nå skal vi se på eksempler på bruk av Eclipse JKube og Kubernetes Maven Plugin i arbeidet med applikasjoner.
Distribuerer Java-applikasjon i Kubernetes ved hjelp av Eclipse JKube
I dette eksempelet skal vi distribuere en enkel Java-applikasjon i en klynge ved hjelp av Eclipse JKube. Ved å bruke Kubernetes Maven Plugin kan vi angi distribusjonsparametere uten å måtte skrive noen konfigurasjon.
Som et eksempel på applikasjonen bruker vi , som gir JSON-output på endpointen /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"
}
Trinn 1. Laster opp Kubernetes Maven Plugin
Kubernetes Maven Plugin finnes i depotet . For å bruke Eclipse JKube må du legge til Kubernetes Maven Plugin i din pom.xml som et avhengighet:
org.eclipse.jkube
kubernetes-maven-plugin
${jkube.version}
Hvis det brukes OpenShift i stedet for ren Kubernetes, modifiseres pom.xml som følger:
org.eclipse.jkube
openshift-maven-plugin
${jkube.version}
Trinn 2. Bygger docker-image
JAR-filen til applikasjonen kan bygges med kommandoen mvn package, og deretter kan målet mvn k8s:build brukes for å bygge docker-image av denne applikasjonen. Vær oppmerksom på at vi har overskrevet det standard image-navnet med denne egenskapen:
docker.io/rohankanojia/random-generator:${project.version}
Før vi bygger imaget, er det viktig å sikre at docker-demonen er korrekt eksponert. Dette kan gjøres med følgende kommando:
$ eval $(minikube docker-env)
Deretter skriver vi inn kommandoen mvn k8s:build, og her er hva vi vil se på skjermen når vi bygger docker-image med Eclipse JKube bygningsoppgave:
~/work/repos/eclipse-jkube-demo-project : $ mvn k8s:build
[INFO] Skanner etter prosjekter...
[INFO]
[INFO] ---------------------------------------------
[INFO] Bygger random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] k8s: Kjører i Kubernetes-modus
[INFO] k8s: Bygger Docker-image i Kubernetes-modus
[INFO] k8s: Kjører generator spring-boot
[INFO] k8s: spring-boot: Bruker Docker-image quay.io/jkube/jkube-java-binary-s2i:0.0.7 som grunnlag / bygg
[INFO] k8s: [docker.io/rohankanojia/random-generator:0.0.1] "spring-boot": Opprettet docker-build.tar på 251 millisekunder
[INFO] k8s: [docker.io/rohankanojia/random-generator:0.0.1] "spring-boot": Bygget image sha256:a20e5
[INFO] ------------------------------------------------------------------------
[INFO] BYGG SUKSESS
[INFO] ------------------------------------------------------------------------
[INFO] Totaltid: 5.053 s
[INFO] Ferdig den: 2020-08-10T11:28:23+05:30
[INFO] ------------------------------------------------------------------------
~/work/repos/eclipse-jkube-demo-project : $
Trinn 3. Sender imaget til docker-registeret
Etter at vi har bygget docker-imaget med en konfigurert push-register (i vårt tilfelle docker.io), kan vi sende dette imaget til registeret. Her er hva som vil vises på skjermen etter at vi ber Eclipse JKube om å utføre push-oppgaven mvn k8s:push:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:push
[INFO] Skanner etter prosjekter...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Bygger random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:push (default-cli) @ random-generator ---
[INFO] k8s: Kjører i Kubernetes-modus
[INFO] k8s: Bygger Docker-bilde i Kubernetes-modus
[INFO] k8s: Kjører generator spring-boot
[INFO] k8s: spring-boot: Bruker Docker-bilde quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 som base \/ builder
[INFO] k8s: Pushen refererer til depot [docker.io\/rohankanojia\/random-generator]
5dcd9556710f: Lagret allerede eksisterer
b7139ad07aa8: Lagret allerede eksisterer
b6f081e4b2b6: Lagret allerede eksisterer
d8e1f35641ac: Lagret allerede eksisterer
[INFO] k8s: 0.0.1: digest: sha256:9f9eda2a13b8cab1d2c9e474248500145fc09e2922fe3735692f9bda4c76002d størrelse: 1162
[INFO] k8s: Pushing docker.io\/rohankanojia\/random-generator:0.0.1 på 7 sekunder
[INFO] ------------------------------------------------------------------------
[INFO] BYGG SUKSESS
[INFO] ------------------------------------------------------------------------
[INFO] Total tid: 11.222 s
[INFO] Ferdig klokken: 2020-08-10T11:35:37+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $
Etter å ha sendt bildet, må vi sjekke at det kom til registeret. I vårt tilfelle ser vi det bare i Docker Hub, som vist i Fig. 4.
Fig. 4. Det sendte bildet har dukket opp i Docker Hub.
Steg 4. Generere manifestene for Kubernetes-ressursene til applikasjonen
Så, bildet av applikasjonen er bygget, nå må vi skrive Kubernetes-manifestene. For dette har Eclipse JKube en oppgave som genererer faste manifestene for ressursene, basert på den underliggende Java-rammeverket (, , Vert.x eller et annet). Man kan også tilpasse manifestet ved å bruke en konfigurasjons-XML-fil og legge raw-biter (biter av de nødvendige ressursmanifestene) i applikasjonens src\/main\/jkube-mappe. I så fall vil konfigurasjonen din bli innlemmet i de genererte manifestene.
I vårt eksempel lar vi alt stå som det er, og derfor genererer Eclipse JKube et manifest for den standard distribusjonen og for tjenesten med type ClusterIP. Deretter modifiserer vi manifestet for å endre tjenestetypen til NodePort. Man kan overstyre standard atferd med følgende egenskap:
<jkube.enricher.jkube-service.type>NodePort<\/jkube.enricher.jkube-service.type>
Slik ser skjermutgangen ut etter at vi ber Eclipse JKube om å utføre resource-oppgaven mvn k8s:resource.
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:resource
[INFO] Skanning for projects...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Bygger random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:resource (default-cli) @ random-generator ---
[INFO] k8s: Kjøring generator spring-boot
[INFO] k8s: spring-boot: Bruker Docker-bilde quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 som base \/ builder
[INFO] k8s: jkube-controller: Legger til en standard Distribusjon
[INFO] k8s: jkube-service: Legger til en standard tjeneste 'random-generator' med porter [8080]
[INFO] k8s: jkube-healthcheck-spring-boot: Legger til readiness probe på port 8080, bane='\/actuator\/health', skjema='HTTP', med en initial forsinkelse på 10 sekunder
[INFO] k8s: jkube-healthcheck-spring-boot: Legger til liveness probe på port 8080, bane='\/actuator\/health', skjema='HTTP', med en initial forsinkelse på 180 sekunder
[INFO] k8s: jkube-revision-history: Legger til revisjonshistorikkgrense på 2
[INFO] ------------------------------------------------------------------------
[INFO] BYGG SUKSESS
[INFO] ------------------------------------------------------------------------
[INFO] Total tid: 3.344 s
[INFO] Ferdig på: 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 : $
Trinn 5. Distribuerer applikasjonen i Kubernetes-klyngen
Så, nå er vi klare til å utføre distribusjonen av applikasjonen: vi har generert bildet, og deretter automatisk generert ressursmanifestene. Nå gjenstår det bare å bruke alt dette på Kubernetes-klyngen. For å distribuerer applikasjonen kan vi selvfølgelig bruke kommandoen kubectl apply -f, men plugin-modulen kan gjøre dette for oss. Dette er hva som vil være på skjermen etter at vi ber Eclipse JKube om å utføre apply-oppgaven mvn k8s:apply:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:apply
[INFO] Skanning for projects...
[INFO]
[INFO] ---------------------------------------------
[INFO] Bygde random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] k8s: Bruker Kubernetes på https://192.168.39.145:8443/ i namespace default med manifest /home/rohaan/work/repos/eclipse-jkube-demo-project/target/classes/META-INF/jkube/kubernetes.yml
[INFO] k8s: Bruker namespace: default
[INFO] k8s: Oppretter en tjeneste fra kubernetes.yml namespace default navn random-generator
[INFO] k8s: Opprettet tjeneste: target/jkube/applyJson/default/service-random-generator.json
[INFO] k8s: Oppretter en distribusjon fra kubernetes.yml namespace default navn random-generator
[INFO] k8s: Opprettet distribusjon: target/jkube/applyJson/default/deployment-random-generator.json
[INFO] k8s: HINT: Bruk kommandoen `kubectl get pods -w` for å se podene dine starte
[INFO] ------------------------------------------------------------------------
[INFO] BYGGING LYKKET
[INFO] ------------------------------------------------------------------------
[INFO] Total tid: 7.306 s
[INFO] Fullført på: 2020-08-10T11:40:57+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get pods -w
NAVN KLAR STATUS RESTARTS AGE
random-generator-58b7847d7f-9m9df 0\/1 Kjøring 0 7s
random-generator-58b7847d7f-9m9df 1\/1 Kjøring 0 17s
^C~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get svc
NAVN TYPE CLUSTER-IP EKSTERN-IP PORT(S) AGE
io-openliberty-sample-getting-started NodePort 10.110.4.104 9080:30570\/TCP 44h
kubernetes ClusterIP 10.96.0.1 443\/TCP 18d
random-generator NodePort 10.97.172.147 8080:32186\/TCP 22s
~\/work\/repos\/eclipse-jkube-demo-project : $ curl `minikube ip`:32186\/random | jq .
% Total % Mottatt % Xferd Gjennomsnittlig Hastighet Tid Tid Tid Nåværende
Dload Last opp Total Brukt Venstre Hastighet
100 45 0 45 0 0 1800 0 --:--:-- --:--:-- --:--:-- 1875
{
"id": "42e5571f-a20f-44b3-8184-370356581d10"
}
Trinn 6. Utfør undeploy av applikasjonen fra Kubernetes-klyngen
Dette utføres ved hjelp av oppgaven undeploy, som ganske enkelt fjerner alle ressurser som ble brukt i forrige trinn, det vil si under utførelsen av oppgaven apply. Dette er hva vi vil se på skjermen etter at vi ber Eclipse JKube om å utføre undeploy-oppgaven mvn k8s:undeploy:
~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get all
NAME READY STATUS RESTARTS AGE
pod\/random-generator-58b7847d7f-9m9df 1\/1 Running 0 5m21s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service\/kubernetes ClusterIP 10.96.0.1 443\/TCP 18d
service\/random-generator NodePort 10.97.172.147 8080:32186\/TCP 5m21s
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps\/random-generator 1\/1 1 1 5m21s
NAME DESIRED CURRENT READY AGE
replicaset.apps\/random-generator-58b7847d7f 1 1 1 5m21s
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:undeploy
[INFO] Scanning for projects...
[INFO]
[INFO] ---------------------------------------------
[INFO] Building random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:undeploy (default-cli) @ random-generator ---
[INFO] k8s: Using Kubernetes at https:\/\/192.168.39.145:8443\/ in namespace default with manifest \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/classes\/META-INF\/jkube\/kubernetes.yml
[INFO] k8s: Using namespace: default
[INFO] k8s: Deleting resource Deployment default\/random-generator
[INFO] k8s: Deleting resource Service default\/random-generator
[INFO] k8s: HINT: Use the command `kubectl get pods -w` to watch your pods start up
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.412 s
[INFO] Finished at: 2020-08-10T11:46:22+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get pods -w
^C~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get all
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service\/kubernetes ClusterIP 10.96.0.1 443\/TCP 18d
~\/work\/repos\/eclipse-jkube-demo-project : $
Hva mer kan gjøres med Eclipse JKube
Vi har nå sett på de grunnleggende målene til Eclipse JKube og Kubernetes Maven Plugin, som gjør utviklingen av Java-applikasjoner for Kubernetes-plattformen enklere. Hvis du ikke ønsker å skrive disse oppgavene hele tiden, kan du legge dem inn i plugin-konfigurasjonen, for eksempel slik:
org.eclipse.jkube
kubernetes-maven-plugin
${project.version}
build
resource
apply
Det må sies at vi i denne artikkelen ikke har dekket alle måloppgavene som finnes i Eclipse JKube og Kubernetes Maven Plugin. Vi gir derfor en liste over ekstra oppgaver som også kan være nyttige for deg i Tabell 2.
Tabell 2. Ekstra måloppgaver for Eclipse JKube.
Oppgave
Etappe
Description
VALIDERE
Hente logger fra applikasjonen som kjører på Kubernetes.
PAKKE
Åpning av feilsøkingporten for å kunne feilsøke applikasjonen som kjører på Kubernetes direkte fra IDE.
INSTALL
Oppretting av en fork for installasjonsoppgaven og anvendelse av de genererte manifestene på Kubernetes-klyngen, nøyaktig som med apply-oppgaven.
PAKKE
Automatisk varm distribusjon av applikasjonen ved å overvåke navnerommet.
Distribusjon av Java-applikasjoner på Red Hat OpenShift ved hjelp av OpenShift Maven Plugin.
For å distribuere applikasjonen fra vårt eksempel på Red Hat OpenShift-plattformen, benytter vi plugin-en. . Den eneste forskjellen vil være at oppgaveprefikset endres fra k8s til oc. Som standard lager Kubernetes Maven-pluginen -byggeoperasjoner, mens OpenShift Maven-pluginen lager . Vi gjør ingen endringer i prosjektet vårt, bortsett fra å fjerne egenskapen jkube.generator.name, siden den ikke er nødvendig ved sending til registeret (i byggeprosessen plasserer OpenShift bildet i sitt interne register). Og her er hva som vil vises på skjermen når vi starter eksempelet vårt, hvor vi for øvrig utfører oppgavefokuset ikke én om gangen, men alle samtidig:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn oc:build oc:resource oc:apply
[INFO] Skanning etter prosjekter...
[INFO]
[INFO] ---------------------------------------------
[INFO] Bygger random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] oc: Bruker OpenShift bygg med strategi S2I
[INFO] oc: Kjører i OpenShift-modus
[INFO] oc: Kjører generator spring-boot
[INFO] oc: spring-boot: Bruker Docker-bilde quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 som base \/ builder
[INFO] oc: [random-generator:0.0.1] "spring-boot": Opprettet docker kilde tar \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/docker\/random-generator\/0.0.1\/tmp\/docker-build.tar
[INFO] oc: Legger til i Secret pullsecret-jkube
[INFO] oc: Bruker Secret pullsecret-jkube
[INFO] oc: Oppretter BuildServiceConfig random-generator-s2i for kildebygg
[INFO] oc: Oppretter ImageStream random-generator
[INFO] oc: Starter bygg random-generator-s2i
[INFO] oc: Venter på at bygg random-generator-s2i-1 skal fullføres...
[INFO] oc: Cacher blobs under "\/var\/cache\/blobs".
[INFO] oc: Får bilde kilde signaturer
[INFO] oc: Kopierer blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Kopierer blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Kopierer blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Kopierer config sha256:52d6788fcfdd39595264d34a3959464a5dabc1d4ef0ae188802b20fc2d6a857b
[INFO] oc: Skriver manifest til bilde destinasjon
[INFO] oc: Lagrer signaturer
[INFO] oc: Genererer dockerfile med builder bilde quay.io\/jkube\/jkube-java-binary-s2i:0.0.7
[INFO] oc: TRINN 1: FRA quay.io\/jkube\/jkube-java-binary-s2i:0.0.7
[INFO] oc: TRINN 2: MERK "io.openshift.build.source-location"="\/tmp\/build\/inputs" "io.openshift.build.image"="quay.io\/jkube\/jkube-java-binary-s2i:0.0.7"
[INFO] oc: TRINN 3: ENV JAVA_APP_DIR="\/deployments" OPENSHIFT_BUILD_NAME="random-generator-s2i-1" OPENSHIFT_BUILD_NAMESPACE="default"
[INFO] oc: TRINN 4: BRUKER root
[INFO] oc: TRINN 5: KOPIER upload\/src \/tmp\/src
[INFO] oc: TRINN 6: KJØR chown -R 1000:0 \/tmp\/src
[INFO] oc: TRINN 7: BRUKER 1000
[INFO] oc: TRINN 8: KJØR \/usr\/local\/s2i\/assemble
[INFO] oc: INFO S2I kildebilde med rene binære oppdaget
[INFO] oc: INFO S2I binærbygg fra fabric8-maven-plugin oppdaget
[INFO] oc: INFO Kopierer binærer fra \/tmp\/src\/deployments til \/deployments ...
[INFO] oc: random-generator-0.0.1.jar
[INFO] oc: INFO Kopierer distribusjoner fra deployments til \/deployments...
[INFO] oc: '\/tmp\/src\/deployments\/random-generator-0.0.1.jar' -> '\/deployments\/random-generator-0.0.1.jar'
[INFO] oc: TRINN 9: CMD \/usr\/local\/s2i\/run
[INFO] oc: TRINN 10: FORPLIKT temp.builder.openshift.io\/default\/random-generator-s2i-1:48795e41
[INFO] oc: tid="2020-08-10T06:37:49Z" nivå=info msg="Bildesystem mismatche: bilde bruker "", forventer "linux""
[INFO] oc: tid="2020-08-10T06:37:49Z" nivå=info msg="Bildearkitektur mismatche: bilde bruker "", forventer "amd64""
[INFO] oc: Får bilde kilde signaturer
[INFO] oc: Kopierer blob sha256:d8e1f35641acb80b562f70cf49911341dfbe8c86f4d522b18efbf3732aa74223
[INFO] oc: Kopierer blob sha256:b6f081e4b2b6de8be4b1dec132043d14c121e968384dd624fb69c2c07b482edb
[INFO] oc: Kopierer blob sha256:b7139ad07aa8ce4ed5a132f7c5cc9f1de0f5099b5e155027a23d57f7fbe78b16
[INFO] oc: Kopierer blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Kopierer config sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Skriver manifest til bilde destinasjon
[INFO] oc: Lagrer signaturer
[INFO] oc: --> 27aaadaf28e
[INFO] oc: 27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Får bilde kilde signaturer
[INFO] oc:
[INFO] oc: Pusher bilde image-registry.openshift-image-registry.svc:5000\/default\/random-generator:0.0.1 ...
[INFO] oc: Kopierer blob sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Kopierer blob sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Kopierer blob sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Kopierer blob sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Kopierer config sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Skriver manifest til bilde destinasjon
[INFO] oc: Lagrer signaturer
[INFO] oc: Succesfully pushed image-registry.openshift-image-registry.svc:5000\/default\/random-generator@sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: Push vellykket
[INFO] oc: Bygg random-generator-s2i-1 i status Fullført
[INFO] oc: Fant tag på ImageStream random-generator tag: sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: ImageStream random-generator skrevet til \/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: Bruker docker bilde navn av navnerom: default
[INFO] oc: Kjører generator spring-boot
[INFO] oc: spring-boot: Bruker Docker-bilde quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 som base \/ builder
[INFO] oc: jkube-controller: Legger til en standard DeploymentConfig
[INFO] oc: jkube-service: Legger til en standard tjeneste 'random-generator' med porter [8080]
[INFO] oc: jkube-healthcheck-spring-boot: Legger til readiness probe på port 8080, sti='\/actuator\/health', skjema='HTTP', med initial forsinkelse 10 sekunder
[INFO] oc: jkube-healthcheck-spring-boot: Legger til liveness probe på port 8080, sti='\/actuator\/health', skjema='HTTP', med initial forsinkelse 180 sekunder
[INFO] oc: jkube-revision-history: Legger til revisjonshistorikkgrense til 2
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] oc: Bruker OpenShift på https:\/\/api.crc.testing:6443\/ i navnerom default med manifest \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/classes\/META-INF\/jkube\/openshift.yml
[INFO] oc: OpenShift plattform oppdaget
[INFO] oc: Bruker prosjekt: default
[INFO] oc: Oppretter en Tjeneste fra openshift.yml navnerom default navn random-generator
[INFO] oc: Opprettet Tjeneste: target\/jkube\/applyJson\/default\/service-random-generator.json
[INFO] oc: Oppretter en DeploymentConfig fra openshift.yml navnerom default navn random-generator
[INFO] oc: Opprettet DeploymentConfig: target\/jkube\/applyJson\/default\/deploymentconfig-random-generator.json
[INFO] oc: Oppretter Rute default:random-generator vert: null
[INFO] oc: HINT: Bruk kommandoen `oc get pods -w` for å se på podene dine starte opp
[INFO] ------------------------------------------------------------------------
[INFO] BYGG SUKSESS
[INFO] ------------------------------------------------------------------------
[INFO] Total tid: 01:07 min
[INFO] Fullført på: 2020-08-10T12:08:00+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $ oc get pods -w
NAVN KLAR STATUS RESTARTS AGE
random-generator-1-deploy 1\/1 Kjørende 0 14s
random-generator-1-vnrm9 0\/1 Kjørende 0 11s
random-generator-s2i-1-build 0\/1 Fullført 0 1m
random-generator-1-vnrm9 1\/1 Kjørende 0 24s
random-generator-1-deploy 0\/1 Fullført 0 28s
~\/work\/repos\/eclipse-jkube-demo-project : $ oc get routes
NAVN VERT\/PORT STI TJENESTER PORT TERMINERING WILDCARD
random-generator random-generator-default.apps-crc.testing random-generator 8080 Ingen
~\/work\/repos\/eclipse-jkube-demo-project : $ curl random-generator-default.apps-crc.testing\/random
% Total % Mottatt % Xferd Gjennomsnittlig Hastighet Tid Tid Tid Nåværende
Dload Last opp Totalt Brukt Venstre Hastighet
100 45 0 45 0 0 1666 0 --:--:-- --:--:-- --:--:-- 1730
{
"id": "d80052d9-2f92-43cb-b9eb-d7cffb879798"
}
~\/work\/repos\/eclipse-jkube-demo-project : $
Videoleksjon
For å lære mer om hvordan du kan forenkle Kubernetes-utviklingen med Eclipse JKube, se videoleksjonen om rask distribusjon av en enkel Spring Boot-applikasjon på Minikube:
Konklusjon
I denne artikkelen har vi vist hvordan Eclipse JKube gjør livet lettere for Java-utviklere som arbeider med Kubernetes. Ytterligere informasjon om Eclipse JKube finner du på og på .
Kilde: habr.com
Russian
Italian
German
Polish
Estonian
Albanian
Bulgarian
Croatian
Czech
Danish
Dutch
English
French
Hungarian
Latvian
Norwegian
Portuguese
Romanian
Slovak
Slovenian
Spanish
Swedish