For 25 years, Java has been embraced by a wide range of programmers, ultimately becoming one of the core technologies around which application stacks are built. However, today many people and organizations that have long been loyal to Java are transitioning or considering a move to the platform or its derivatives, such as eller .
Unfortunately, Kubernetes comes with 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 these additional operations related to Kubernetes and containers, as well as to ensure a seamless migration to the cloud platform while retaining the familiar Java ecosystem. Moreover, 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) implies that the developer writes code, then creates deployment units in the form of JAR or WAR files, and subsequently deploys and runs these files on a web server or application server. Primarily, Maven from the command line is used for this, 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 sending it to the version control system.
Fig. 1. Traditional Java development process.
The Java development process for the cloud
When moving to cloud applications, Kubernetes and the described above schema introduce . Therefore, now the developer must package Java applications into and create Kubernetes manifests that describe these images. Then, these manifests are applied to the production server where Kubernetes is running. In turn, Kubernetes takes these images from the registry and deploys the 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 illustrated in Fig. 2.
Fig. 2. Java development process for the cloud.
Eclipse JKube
Overgangen til Kubernetes tilføjer et ekstra driftsniveau i udviklingsprocessen, hvilket kan gøre mange udviklere nervøse, da de ønsker at fokusere på deres kerneopgave – applikationslogik – i stedet for hvordan de skal implementeres. Her kommer , som gør det muligt for udviklere at bruge deres biblioteker og plugins ( sammen med eller ), for uden besvær at udføre operationer relateret til containere og Kubernetes, som vist i figur 2.
I den resterende del af denne artikel vil vi vise, hvordan man kan forenkle processen for Java-udvikling i Kubernetes-miljøet ved at bruge Eclipse JKube med Kubernetes Maven Plugin.
Udviklingsprocessen for skyen ved hjælp af Eclipse JKube
Lad os se på et let modificeret diagram over Java-udvikling for skyen fra figur 2, introducerende Eclipse JKube og Kubernetes Maven Plugin, som vist i figur 3.
Figur 3. Java-udviklingsprocessen for skyen ved hjælp af Eclipse JKube.
Som vi kan se, erstattes alle operationer til interaktion med Kubernetes og containere (fremhævet i rødt i diagrammet) af standardmål for Eclipse JKube, som er anført i tabel 1.
Tabel 1. Standardopgaver for Eclipse JKube.
Regler for godkendelse af merge-requests
Trin
Description
PRE_INTEGRATION_TEST
Bygning af Docker-billeder
INSTALL
Push af Docker-billeder til registret
PROCESS_RESOURCES
Generering af K8s-manifest
COMPILE
Anvendelse af de genererede manifester til K8s
UNDEPLOY
Fjernelse af K8s-ressourcer, der blev implementeret via k8s:apply og k8s:deploy
Bemærk: Hvis du ikke ønsker, at opgaverne bruger disse strenge standarder (opinionated defaults), kan du manuelt konfigurere Eclipse JKube, da det understøtter konfiguration via og .
Lad os nu se på eksempler på brugen af Eclipse JKube og Kubernetes Maven Plugin i forbindelse med applikationer.
Implementering af Java-applikation i Kubernetes ved hjælp af Eclipse JKube
I dette eksempel vil vi implementere en simpel Java-applikation i en klynge ved hjælp af Eclipse JKube. Ved at bruge Kubernetes Maven Plugin kan vi angive implementeringsparametre uden at skulle specificere nogen konfiguration.
Som eksempel på en applikation bruger vi , der returnerer JSON-output på endpoint’en /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"
}
Trin 1. Download Kubernetes Maven Plugin
Kubernetes Maven Plugin findes i repositoryet . For at bruge Eclipse JKube skal du tilføje Kubernetes Maven Plugin til din pom.xml som en afhængighed:
org.eclipse.jkube
kubernetes-maven-plugin
${jkube.version}
Hvis du bruger OpenShift i stedet for ren Kubernetes, skal pom.xml ændres som følger:
org.eclipse.jkube
openshift-maven-plugin
${jkube.version}
Trin 2. Byg docker-billedet
JAR-filen til applikationen kan bygges med kommandoen mvn package, og derefter kan du bruge goal-kommandoen mvn k8s:build for at bygge docker-billedet af denne applikation. Bemærk, at vi har overskrevet standardbilledets navn med denne egenskab:
docker.io/rohankanojia/random-generator:${project.version}
Før du bygger billedet, skal du sørge for, at docker-dæmonen er korrekt eksponeret. Dette kan gøres med følgende kommando:
$ eval $(minikube docker-env)
Derefter indtaster vi kommandoen mvn k8s:build, og her er hvad vi ser på skærmen, når docker-billedet bygges med build-opgaven fra 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 : $
Trin 3. Sender billedet til docker-register
Efter at vi har bygget docker-billedet med en konfigureret push-repository (i vores tilfælde docker.io), kan vi sende dette billede til registeret. Her er hvad der vises på skærmen, når vi beder Eclipse JKube om at udføre push-opgaven mvn k8s:push:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:push
[INFO] Scanner efter projekter...
[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: Kører i Kubernetes-tilstand
[INFO] k8s: Bygger Docker-billede i Kubernetes-tilstand
[INFO] k8s: Kører generator spring-boot
[INFO] k8s: spring-boot: Bruger Docker-billede quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 som base \/ builder
[INFO] k8s: Push henviser til repository [docker.io\/rohankanojia\/random-generator]
5dcd9556710f: Laget eksisterer allerede
b7139ad07aa8: Laget eksisterer allerede
b6f081e4b2b6: Laget eksisterer allerede
d8e1f35641ac: Laget eksisterer allerede
[INFO] k8s: 0.0.1: digest: sha256:9f9eda2a13b8cab1d2c9e474248500145fc09e2922fe3735692f9bda4c76002d størrelse: 1162
[INFO] k8s: Pushed docker.io\/rohankanojia\/random-generator:0.0.1 på 7 sekunder
[INFO] ------------------------------------------------------------------------
[INFO] BYGNING SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total tid: 11.222 s
[INFO] Afsluttet den: 2020-08-10T11:35:37+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $
Efter at have sendt billedet skal vi kontrollere, at det er ankommet til registeret. I vores tilfælde ser vi det blot i Docker Hub, som vist på Fig. 4.
Fig. 4. Det sendte billede er dukket op i Docker Hub.
Trin 4. Genererer Kubernetes-ressource-mani-fester til applikationen
Så vi har bygget applikationsbilledet, nu skal vi skrive Kubernetes-mani-fester. Til dette har Eclipse JKube en opgave, der genererer faste ressourcemani-fester, baseret på det underliggende Java-framework (, , Vert.x eller et andet). Det er også muligt at konfigurere manifestet ved hjælp af en konfigurations-XML-fil og placere raw-fragmenter (fragmenter af det nødvendige ressource-manifest) i applikationens src\/main\/jkube-mappe. I så fald vil din konfiguration blive indlæst i de genererede mani-fester.
I vores eksempel lader vi alt være som det er, og derfor genererer Eclipse JKube et manifest for standardudrulningen og for en service af typen ClusterIP. Senere modificerer vi derefter service-manifestet for at ændre service-typen til NodePort. Den standard adfærd kan overstyres ved hjælp af følgende egenskab:
<jkube.enricher.jkube-service.type>NodePort<\/jkube.enricher.jkube-service.type>
Sådan ser skærmuddataene ud efter, at vi beder Eclipse JKube om at udføre ressource-opgaven mvn k8s:resource.
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:resource
[INFO] Scanner 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: Kører generator spring-boot
[INFO] k8s: spring-boot: Bruger Docker-billede quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 som base \/ builder
[INFO] k8s: jkube-controller: Tilføjer en standard Deployment
[INFO] k8s: jkube-service: Tilføjer en standard service 'random-generator' med porte [8080]
[INFO] k8s: jkube-healthcheck-spring-boot: Tilføjer readiness probe på port 8080, sti='\/actuator\/health', skema='HTTP', med indledende forsinkelse på 10 sekunder
[INFO] k8s: jkube-healthcheck-spring-boot: Tilføjer liveness probe på port 8080, sti='\/actuator\/health', skema='HTTP', med indledende forsinkelse på 180 sekunder
[INFO] k8s: jkube-revision-history: Tilføjer revisionshistorik begrænsning til 2
[INFO] ------------------------------------------------------------------------
[INFO] BYG SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total tid: 3.344 s
[INFO] Afsluttet 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 : $
Trin 5. Udrul applikationen i Kubernetes-klyngen
Nu er vi klar til at udføre udrulningen af applikationen: vi har genereret dens billede og derefter automatisk genereret ressource-manifesterne. Nu er alt, hvad der er tilbage, at anvende det hele til Kubernetes-klyngen. For at udrulle applikationen kan vi selvfølgelig bruge kommandoen kubectl apply -f, men pluginnet kan også gøre det for os. Her er, hvad der vises på skærmen, efter vi beder Eclipse JKube om at udføre apply-opgaven mvn k8s:apply:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:apply
[INFO] Scanner efter projekter...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Bygger random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] k8s: Bruger Kubernetes på https:\/\/192.168.39.145:8443\/ i namespaces default med manifest \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/classes\/META-INF\/jkube\/kubernetes.yml
[INFO] k8s: Bruger namespace: default
[INFO] k8s: Opretter en service fra kubernetes.yml namespace default navn random-generator
[INFO] k8s: Oprettet service: target\/jkube\/applyJson\/default\/service-random-generator.json
[INFO] k8s: Opretter en deployment fra kubernetes.yml namespace default navn random-generator
[INFO] k8s: Oprettet deployment: target\/jkube\/applyJson\/default\/deployment-random-generator.json
[INFO] k8s: HINT: Brug kommandoen `kubectl get pods -w` for at overvåge opstarten af dine pods
[INFO] ------------------------------------------------------------------------
[INFO] BYG SUCCES
[INFO] ------------------------------------------------------------------------
[INFO] Total tid: 7.306 s
[INFO] Færdig: 2020-08-10T11:40:57+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get pods -w
NAVN KLAR STATUS GENSTARTS ALDER
random-generator-58b7847d7f-9m9df 0\/1 Kører 0 7s
random-generator-58b7847d7f-9m9df 1\/1 Kører 0 17s
^C~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get svc
NAVN TYPE KLUSTER-IP EKSTERN-IP PORT(S) ALDER
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 % Modtaget % Xferd Gennemsnitlig Hastighed Tid Tid Tid Nuværende
Dload Upload Total Brugte Venstre Hastighed
100 45 0 45 0 0 1800 0 --:--:-- --:--:-- --:--:-- 1875
{
"id": "42e5571f-a20f-44b3-8184-370356581d10"
}
Trin 6. Udrulning af applikationen fra Kubernetes-klustret
Dette udføres med opgaven undeploy, der blot sletter alle ressourcer, der blev anvendt i det forrige trin, altså ved udførelsen af opgaven apply. Her er, hvad vi vil se på skærmen, efter at vi har bedt Eclipse JKube udføre undeploy-opgaven 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 : $
Hvad mere kan man gøre med Eclipse JKube
Vi har nu set på de grundlæggende mål og opgaver i Eclipse JKube og Kubernetes Maven Plugin, som letter udviklingen af Java-applikationer til Kubernetes-platformen. Hvis du ikke ønsker at indtaste disse opgaver manuelt hele tiden, kan du skrive dem ind i plugin-konfigurationen, eksempelvis sådan her:
org.eclipse.jkube
kubernetes-maven-plugin
${project.version}
build
resource
apply
Det skal siges, at vi ikke har dækket alle de mål og opgaver, der findes i Eclipse JKube og Kubernetes Maven Plugin i denne artikel, derfor bringer vi i Tabel 2 en liste over yderligere opgaver, som også kan være nyttige for dig.
Tabel 2. Yderligere målopgaver i Eclipse JKube.
Regler for godkendelse af merge-requests
Trin
Description
VALIDERE
Hentning af logs fra en applikation, der kører på Kubernetes.
PAKKE
Åbning af en debugging-port for at kunne debugge applikationen, der kører på Kubernetes, direkte fra IDE'en.
INSTALL
Oprettelse af en fork til Install-opgaven og anvendelse af de genererede manifests på Kubernetes-klyngen præcist som ved apply-opgaven.
PAKKE
Automatisk hot deployment af applikationen ved at overvåge dens navnerum.
Deployment af Java-applikationer på Red Hat OpenShift ved hjælp af OpenShift Maven Plugin.
For at implementere applikationen fra vores eksempel på Red Hat OpenShift-platformen, anvender vi plugin'et. . Den eneste forskel vil være, at opgavepræfikset ændres fra k8s til oc. Som standard laver Kubernetes Maven-plugin'et -builds, mens OpenShift Maven-plugin'et laver builds. . Vi laver ingen ændringer i vores projekt, bortset fra at fjerne egenskaben jkube.generator.name, da den ikke er nødvendigt ved upload til registreret (under byggeprocessen placerer OpenShift billedet i sit interne register). Og her er, hvad der kommer til at vises på skærmen, når vi kører vores eksempel, hvor vi for øvrigt udfører goal-opgaverne, ikke en ad gangen, men alle på én gang:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn oc:build oc:resource oc:apply
[INFO] Scanner projekter...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[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: Bruger OpenShift-byg med strategi S2I
[INFO] oc: Kører i OpenShift-tilstand
[INFO] oc: Kører generator spring-boot
[INFO] oc: spring-boot: Bruger Docker-billede quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 som base \/ builder
[INFO] oc: [random-generator:0.0.1] "spring-boot": Oprettet docker kilde tar \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/docker\/random-generator\/0.0.1\/tmp\/docker-build.tar
[INFO] oc: Tilføjer til Secret pullsecret-jkube
[INFO] oc: Bruger Secret pullsecret-jkube
[INFO] oc: Oprettelse af BuildServiceConfig random-generator-s2i for Source build
[INFO] oc: Oprettelse af ImageStream random-generator
[INFO] oc: Starter Build random-generator-s2i
[INFO] oc: Venter på at bygge random-generator-s2i-1 skal være færdig...
[INFO] oc: Cacher blobs under "\/var\/cache\/blobs".
[INFO] oc: Får billedkilde 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 billede destination
[INFO] oc: Gemmer signaturer
[INFO] oc: Genererer dockerfile med builder billede quay.io\/jkube\/jkube-java-binary-s2i:0.0.7
[INFO] oc: TRIN 1: FRA quay.io\/jkube\/jkube-java-binary-s2i:0.0.7
[INFO] oc: TRIN 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: TRIN 3: ENV JAVA_APP_DIR="\/deployments" OPENSHIFT_BUILD_NAME="random-generator-s2i-1" OPENSHIFT_BUILD_NAMESPACE="default"
[INFO] oc: TRIN 4: BRUGER root
[INFO] oc: TRIN 5: KOPIER upload\/src \/tmp\/src
[INFO] oc: TRIN 6: KØR chown -R 1000:0 \/tmp\/src
[INFO] oc: TRIN 7: BRUGER 1000
[INFO] oc: TRIN 8: KØR \/usr\/local\/s2i\/assemble
[INFO] oc: INFO S2I kildebyg med almindelige binære filer registreret
[INFO] oc: INFO S2I binære byg fra fabric8-maven-plugin registreret
[INFO] oc: INFO Kopierer binære filer fra \/tmp\/src\/deployments til \/deployments ...
[INFO] oc: random-generator-0.0.1.jar
[INFO] oc: INFO Kopierer deployment fra deployments til \/deployments...
[INFO] oc: '\/tmp\/src\/deployments\/random-generator-0.0.1.jar' -> '\/deployments\/random-generator-0.0.1.jar'
[INFO] oc: TRIN 9: CMD \/usr\/local\/s2i\/run
[INFO] oc: TRIN 10: FORPLIGT temp.builder.openshift.io\/default\/random-generator-s2i-1:48795e41
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Billed operativsystem mismatch: billedet bruger "", forventer "linux""
[INFO] oc: time="2020-08-10T06:37:49Z" level=info msg="Billed arkitektur mismatch: billedet bruger "", forventer "amd64""
[INFO] oc: Får billedkilde 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 billede destination
[INFO] oc: Gemmer signaturer
[INFO] oc: --> 27aaadaf28e
[INFO] oc: 27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Får billedkilde signaturer
[INFO] oc:
[INFO] oc: Skubber billede 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 billede destination
[INFO] oc: Gemmer signaturer
[INFO] oc: Billede image-registry.openshift-image-registry.svc:5000\/default\/random-generator@sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d er blevet skubbet med succes
[INFO] oc: Push succesfuld
[INFO] oc: Byg random-generator-s2i-1 er i status Fuldfø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: Bruger dockerbillednavn i namespace: default
[INFO] oc: Kører generator spring-boot
[INFO] oc: spring-boot: Bruger Docker-billede quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 som base \/ builder
[INFO] oc: jkube-controller: Tilføjer en standard DeploymentConfig
[INFO] oc: jkube-service: Tilføjer en standard service 'random-generator' med porte [8080]
[INFO] oc: jkube-healthcheck-spring-boot: Tilføjer readines Probe på port 8080, sti='\/actuator\/health', skema='HTTP', med initial forsinkelse på 10 sekunder
[INFO] oc: jkube-healthcheck-spring-boot: Tilføjer livlighed Probe på port 8080, sti='\/actuator\/health', skema='HTTP', med initial forsinkelse på 180 sekunder
[INFO] oc: jkube-revision-history: Tilføjer revisionshistorikgrænse til 2
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] oc: Bruger OpenShift på https:\/\/api.crc.testing:6443\/ i namespace default med manifest \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/classes\/META-INF\/jkube\/openshift.yml
[INFO] oc: OpenShift-platform registreret
[INFO] oc: Bruger projekt: default
[INFO] oc: Opretter en Service fra openshift.yml namespace default navn random-generator
[INFO] oc: Oprettet Service: target\/jkube\/applyJson\/default\/service-random-generator.json
[INFO] oc: Opretter en DeploymentConfig fra openshift.yml namespace default navn random-generator
[INFO] oc: Oprettet DeploymentConfig: target\/jkube\/applyJson\/default\/deploymentconfig-random-generator.json
[INFO] oc: Opretter Rute default:random-generator vært: null
[INFO] oc: TIP: Brug kommandoen `oc get pods -w` for at overvåge dine pods starte op
[INFO] ------------------------------------------------------------------------
[INFO] BYG SUCCES
[INFO] ------------------------------------------------------------------------
[INFO] Total tid: 01:07 min
[INFO] Færdig på: 2020-08-10T12:08:00+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $ oc get pods -w
NAVN KLAR STATUS GENSTARTER ALDER
random-generator-1-deploy 1\/1 Kører 0 14s
random-generator-1-vnrm9 0\/1 Kører 0 11s
random-generator-s2i-1-build 0\/1 Fuldført 0 1m
random-generator-1-vnrm9 1\/1 Kører 0 24s
random-generator-1-deploy 0\/1 Fuldfø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 % Modtaget % Transf. Gennemsn. Hastighed Tid Tid Tid Nuværende
Dload Upload Total Brugt Tilbage Hastighed
100 45 0 45 0 0 1666 0 --:--:-- --:--:-- --:--:-- 1730
{
"id": "d80052d9-2f92-43cb-b9eb-d7cffb879798"
}
~\/work\/repos\/eclipse-jkube-demo-project : $
Videovejledning
For at lære mere om, hvordan du forenkler Kubernetes-udvikling med Eclipse JKube, skal du se videovejledningen til hurtig implementering af en simpel Spring Boot-applikation på Minikube:
Konklusion
I denne artikel har vi vist, hvordan Eclipse JKube gør livet lettere for Java-udviklere, når de arbejder med Kubernetes. Du kan finde yderligere information om Eclipse JKube på og på .
Kilde: habr.com
