För 25 år sedan kom Java in i programmeringens mainstream och blev så småningom ett av kärnelementen kring vilka applikationsstackar byggs. Idag är dock många människor och organisationer som har varit lojala mot Java i många år upptagna med att migrera eller överväga att migrera till plattformen. eller dess derivat som t.ex eller .
Tyvärr har Kubernetes en brant inlärningskurva och introducerar ytterligare ett operativt lager i utvecklingsprocessen som Java-programmerare är vana vid. Idag kommer vi att berätta hur du använder , för att förenkla dessa ytterligare operationer associerade med Kubernetes och behållare, och säkerställa en smärtfri migrering till molnplattformen samtidigt som det välbekanta Java-ekosystemet bibehålls. Dessutom kommer vi att visa hur man distribuerar Java-applikationer på OpenShift-plattformen med OpenShift Maven-plugin.
Traditionell Java-utvecklingsprocess
Traditionell utvecklingsprocess (Figur 1) innebär att utvecklaren skriver kod, sedan skapar distributionsenheter i form av JAR- eller WAR-filer, och sedan distribuerar och kör dessa filer på en webb- eller applikationsserver. Det huvudsakliga sättet att göra detta är att använda Maven från kommandoraden eller använda en IDE som IntelliJ eller Eclipse för att koda och paketera applikationerna. Utvecklare är vana vid att göra kodändringar och testa allt noggrant innan de begår koden och skickar in den till versionskontroll.
Ris. 1. Traditionell Java utvecklingsprocess.
Java utvecklingsprocess för molnet
Vid övergång till molnapplikationer, Kubernetes och . Därför måste utvecklaren nu paketera Java-applikationer och skapa Kubernetes-manifest som beskriver dessa bilder. Dessa manifest appliceras sedan på produktionsservern som kör Kubernetes. I sin tur tar Kubernetes dessa bilder från registret och distribuerar applikationer enligt de konfigurationer som vi har skrivit i manifest, som vanligtvis är YAML-filer.
Metamorfosen av den traditionella Java-utvecklingsprocessen i övergången till molnet visas i fig. 2.
Ris. 2. Java utvecklingsprocess för molnet.
Eclipse JKube
Att migrera till Kubernetes lägger till ytterligare ett operativt lager till utvecklingsprocessen, och många utvecklare är nervösa för det eftersom de vill fokusera på sitt kärnarbete – applikationslogiken – snarare än hur de ska distribuera dem. Och det är här det spelar in. , som tillåter utvecklare att använda sina bibliotek och plugins ( med eller ) för att enkelt utföra container- och Kubernetes-relaterade operationer genom att följa diagrammet i figuren. 2.
I resten av den här artikeln kommer vi att visa dig hur du förenklar Java-utvecklingsprocessen i Kubernetes-miljön genom att använda Eclipse JKube med Kubernetes Maven-plugin.
Molnutvecklingsprocess med Eclipse JKube
Låt oss överväga ett något modifierat Java-utvecklingsschema för molnet från Fig. 2, och introducera Eclipse JKube och Kubernetes Maven Plugin i det, som visas i Fig. 3.
Ris. 3. Java utvecklingsprocess för molnet med Eclipse JKube.
Som vi kan se ersätts här alla operationer för att interagera med Kubernetes och behållare (markerade i rött i diagrammet) av Eclipse JKube-måluppgifter som är listade i tabell. 1.
Tabell 1. Eclipse JKubes standarduppgifter.
Uppgift
stadium
beskrivning
PRE_INTEGRATION_TEST
Bygga hamnarbetare bilder
INSTALLERA
Ladda upp docker-bilder till registret
PROCESS_RESOURCES
Genererar K8-manifest
SAMMANSTÄLLA
Applicera genererade manifest på K8s
ARBETSATS
Ta bort K8s-resurser som distribuerades med k8s:apply och k8s:deploy
Notera: Om du inte vill att uppgifter ska använda dessa påstådda standardinställningar kan du manuellt konfigurera Eclipse JKube för dig själv, eftersom den stöder konfiguration via и .
Låt oss nu titta på exempel på att använda Eclipse JKube och Kubernetes Maven Plugin när du arbetar med applikationer.
Distribuera en Java-applikation på Kubernetes med Eclipse JKube
I det här exemplet kommer vi att distribuera en enkel Java-applikation på ett kluster med Eclipse JKube. Genom att använda Kubernetes Maven Plugin kan vi ställa in implementeringsparametrar utan att behöva skriva någon konfiguration.
Som en exempelapplikation använder vi , som producerar JSON-utdata vid /random endpoint:
~/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"
}
Steg 1. Ladda ner Kubernetes Maven Plugin
Kubernetes Maven Plugin finns i förvaret . För att använda Eclipse JKube måste du lägga till Kubernetes Maven Plugin till din pom.xml som ett beroende:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>kubernetes-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Om OpenShift används istället för ren Kubernetes, ändras pom.xml enligt följande:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>openshift-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Steg 2. Bygg docker-bilden
Applikationens JAR-fil kan byggas med mvn-paketkommandot, och sedan kan mvn-måluppgiften k8s:build användas för att bygga en docker-bild av applikationen. Observera att vi har åsidosatt standardbildnamnet med denna egenskap:
<jkube.generator.name>docker.io/rohankanojia/random-generator:${project.version}</jkube.generator.name>
Innan du bygger bilden måste du se till att docker-demonen är korrekt exponerad. Detta kan göras med följande kommando:
$ eval $(minikube docker-env)
Sedan anger vi kommandot mvn k8s:build, och det här är vad vi kommer att se på skärmen när vi bygger docker-bilden med Eclipse JKube-bygguppgiften:
~/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 : $
Steg 3. Ladda upp bilden till docker-registret
Efter att vi har byggt docker-avbildningen med push-registret konfigurerat (i vårt fall är det docker.io), kan vi skicka denna bild till registret. Detta är vad som kommer att visas efter att vi har bett Eclipse JKube att utföra mvn k8s:push push-uppgiften:
~/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 : $
Efter att ha skickat bilden måste du kontrollera att den finns med i registret. I vårt fall ser vi det helt enkelt i Docker Hub, som visas i fig. 4.
Ris. 4. Bilden som skickades till registret dök upp i Docker Hub.
Steg 4. Generera Kubernetes resursmanifest för applikationen
Så vi har samlat in applikationsbilden, nu måste vi skriva Kubernetes-manifest. För att göra detta har Eclipse JKube en uppgift som genererar stela resursmanifest baserat på det underliggande Java-ramverket (, , Vert.x eller något annat). Du kan också anpassa manifestet genom att använda en XML-konfigurationsfil och placera råfragment (fragment av det nödvändiga resursmanifestet) i applikationsmappen src/main/jkube. I det här fallet kommer din konfiguration att laddas upp till de genererade manifesten.
I vårt exempel lämnar vi allt som det är, och därför genererar Eclipse JKube ett manifest för standardinstallationen och för tjänsten med typen ClusterIP. Och först då modifierar vi tjänstemanifestet för att ändra tjänstetypen till NodePort. Du kan åsidosätta standardbeteendet med hjälp av följande egenskap:
<jkube.enricher.jkube-service.type>NodePort</jkube.enricher.jkube-service.type>
Så här ser skärmutgången ut efter att vi har bett Eclipse JKube att utföra resursuppgiften 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 : $
Steg 5. Distribuera programmet till Kubernetes-klustret
Nu är vi redo att distribuera programmet: vi har genererat dess image och sedan automatiskt genererat resursmanifest. Nu återstår bara att tillämpa allt detta på Kubernetes-klustret. För att distribuera applikationen kan du naturligtvis använda kommandot kubectl apply -f, men plugin-programmet kan göra detta åt oss. Detta är vad som kommer att visas på skärmen efter att vi har bett Eclipse JKube att utföra mvn k8s:apply application-uppgiften:
~/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"
}
Steg 6. Avinstallera program från Kubernetes-klustret
För att göra detta används den avinstallerade uppgiften, som helt enkelt tar bort alla resurser som tillämpades i föregående steg, det vill säga när tillämpningsuppgiften körs. Det här är vad vi kommer att se på skärmen efter att vi har bett Eclipse JKube att utföra uppgiften 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 : $
Vad mer kan du göra med Eclipse JKube
Så vi tittade på huvudmålsuppgifterna för Eclipse JKube och Kubernetes Maven Plugin, som underlättar utvecklingen av Java-applikationer för Kubernetes-plattformen. Om du inte ständigt vill ange dessa uppgifter från tangentbordet, kan du skriva dem i plugin-konfigurationen, till exempel så här:
<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>
Det måste sägas att vi i den här artikeln inte har beaktat alla måluppgifter som finns i Eclipse JKube och Kubernetes Maven Plugin, så vi tillhandahåller i Tabell 2 en lista över ytterligare uppgifter som också kan vara användbara för dig.
Tabell 2. Ytterligare måluppgifter för Eclipse JKube.
Uppgift
stadium
beskrivning
BEKRÄFTA
Ta emot loggar från ett program som körs på Kubernetes.
PAKET
Öppna en felsökningsport så att du kan felsöka ditt program som körs på Kubernetes direkt från IDE.
INSTALLERA
Skapa en gaffel för installationsuppgiften och applicera de genererade manifesten på Kubernetes-klustret på samma sätt som i fallet med tillämpningsuppgiften.
PAKET
Automatisk hetdistribution av ett program genom att spåra dess namnområde.
Distribuera Java-applikationer på Red Hat OpenShift med hjälp av OpenShift Maven-plugin
För att distribuera applikationen från vårt exempel på Red Hat OpenShift-plattformen använder vi plugin . Den enda skillnaden är att uppgiftsprefixet kommer att ändras från k8s till oc. Som standard gör insticksprogrammet Kubernetes Maven det -assemblies, och OpenShift Maven-plugin - assemblies . Vi gör inga ändringar i vårt projekt förutom att ta bort egenskapen jkube.generator.name eftersom den inte krävs när du trycker till registret (OpenShift placerar bilden i sitt interna register under byggfasen). Och det här är vad som kommer att visas på skärmen när vi kör vårt exempel, där vi förresten utför måluppgifter inte en i taget, utan alla på en gång:
~/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 : $
Videolektion
För att lära dig mer om hur du gör utvecklingen av Kubernetes enklare med Eclipse JKube, titta på den här videohandledningen om hur du snabbt distribuerar en enkel Spring Boot-applikation på Minikube:
Slutsats
I den här artikeln visade vi hur Eclipse JKube gör livet lättare för en Java-utvecklare när de arbetar med Kubernetes. Mer information om Eclipse JKube finns på och .
Källa: will.com