25 jaar geleden werd Java de hoofdstroom van programmeren en werd uiteindelijk een van de kernelementen waarrond applicatiestacks worden gebouwd. Tegenwoordig zijn veel mensen en organisaties die al jaren loyaal zijn aan Java echter druk bezig met migreren of overwegen ze om naar het platform te migreren. of zijn derivaten zoals of .
Helaas heeft Kubernetes een steile leercurve en introduceert het een nieuwe operationele laag in het ontwikkelingsproces waar Java-programmeurs aan gewend zijn. Vandaag vertellen we je hoe je het moet gebruiken , om deze aanvullende bewerkingen die verband houden met Kubernetes en containers te vereenvoudigen en een pijnloze migratie naar het cloudplatform te garanderen, terwijl het vertrouwde Java-ecosysteem behouden blijft. Bovendien zullen we laten zien hoe u Java-applicaties op het OpenShift-platform kunt implementeren met behulp van de OpenShift Maven-plug-in.
Traditioneel Java-ontwikkelingsproces
Traditioneel ontwikkelingsproces (Afbeelding 1) houdt in dat de ontwikkelaar code schrijft, vervolgens implementatie-eenheden maakt in de vorm van JAR- of WAR-bestanden, en deze bestanden vervolgens implementeert en uitvoert op een web- of applicatieserver. De belangrijkste manier om dit te doen is door Maven te gebruiken vanaf de opdrachtregel of door een IDE zoals IntelliJ of Eclipse te gebruiken om de applicaties te coderen en te verpakken. Ontwikkelaars zijn gewend om codewijzigingen door te voeren en alles grondig te testen voordat ze de code committen en aan versiebeheer onderwerpen.
Rijst. 1. Traditioneel Java-ontwikkelingsproces.
Java-ontwikkelingsproces voor de cloud
Bij de overstap naar cloudapplicaties kunnen Kubernetes en . Daarom moet de ontwikkelaar nu Java-applicaties inpakken en maak Kubernetes-manifesten die deze afbeeldingen beschrijven. Deze manifesten worden vervolgens toegepast op de productieserver waarop Kubernetes draait. Op zijn beurt haalt Kubernetes deze images uit het register en implementeert applicaties volgens de configuraties die we in manifesten hebben geschreven, meestal YAML-bestanden.
De metamorfose van het traditionele Java-ontwikkelproces in de transitie naar de cloud is weergegeven in figuur 2. XNUMX.
Rijst. 2. Java-ontwikkelingsproces voor de cloud.
Eclipse JKube
Migreren naar Kubernetes voegt een nieuwe operationele laag toe aan het ontwikkelingsproces, en veel ontwikkelaars zijn er zenuwachtig over omdat ze zich willen concentreren op hun kernwerk (de applicatielogica) in plaats van op de manier waarop ze deze moeten implementeren. En dit is waar het in het spel komt. , waarmee ontwikkelaars hun bibliotheken en plug-ins kunnen gebruiken ( met of ) om moeiteloos container- en Kubernetes-gerelateerde bewerkingen uit te voeren door het diagram in figuur te volgen. 2.
In de rest van dit artikel laten we u zien hoe u het Java-ontwikkelproces in de Kubernetes-omgeving kunt vereenvoudigen door Eclipse JKube te gebruiken met de Kubernetes Maven Plugin.
Cloudontwikkelingsproces met behulp van Eclipse JKube
Laten we een enigszins aangepast Java-ontwikkelingsschema voor de cloud uit figuur 2 bekijken, waarin Eclipse JKube en Kubernetes Maven Plugin worden geïntroduceerd, zoals weergegeven in figuur 3. XNUMX.
Rijst. 3. Java-ontwikkelingsproces voor de cloud met behulp van Eclipse JKube.
Zoals we kunnen zien, worden hier alle bewerkingen voor interactie met Kubernetes en containers (rood gemarkeerd in het diagram) vervangen door standaard Eclipse JKube-doeltaken, die in de tabel worden vermeld. 1.
Tafel 1. Eclipse JKube standaardtaken.
Taak
Stadium
beschrijving
PRE_INTEGRATION_TEST
Docker-installatiekopieën maken
INSTALL
Docker-images uploaden naar het register
PROCESS_RESOURCES
K8-manifesten genereren
COMPILEREN
Gegenereerde manifesten toepassen op K8's
ONTWERKEN
K8s-bronnen verwijderen die zijn geïmplementeerd met k8s:apply en k8s:deploy
Opmerking: Als u niet wilt dat taken deze eigenzinnige standaardwaarden gebruiken, kunt u Eclipse JKube handmatig voor uzelf configureren, aangezien het configuratie ondersteunt via и .
Laten we nu eens kijken naar voorbeelden van het gebruik van Eclipse JKube en Kubernetes Maven Plugin bij het werken met applicaties.
Een Java-applicatie implementeren op Kubernetes met behulp van Eclipse JKube
In dit voorbeeld implementeren we een eenvoudige Java-applicatie op een cluster met behulp van Eclipse JKube. Met behulp van de Kubernetes Maven Plugin kunnen we implementatieparameters instellen zonder dat we een configuratie hoeven te schrijven.
Als voorbeeldapplicatie gebruiken wij , die JSON-uitvoer produceert op het /random eindpunt:
~/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"
}
Stap 1. Download de Kubernetes Maven-plug-in
De Kubernetes Maven-plug-in bevindt zich in de repository . Om Eclipse JKube te gebruiken, moet u de Kubernetes Maven Plugin als afhankelijkheid aan uw pom.xml toevoegen:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>kubernetes-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Als OpenShift wordt gebruikt in plaats van pure Kubernetes, wordt pom.xml als volgt gewijzigd:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>openshift-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Stap 2. Bouw de docker-image
Het JAR-bestand van de applicatie kan worden gebouwd met de opdracht mvn package, en vervolgens kan de mvn-doeltaak k8s:build worden gebruikt om een docker-image van de applicatie te bouwen. Houd er rekening mee dat we de standaardafbeeldingsnaam met deze eigenschap hebben overschreven:
<jkube.generator.name>docker.io/rohankanojia/random-generator:${project.version}</jkube.generator.name>
Voordat u de image bouwt, moet u ervoor zorgen dat de docker-daemon correct wordt weergegeven. Dit kan gedaan worden met het volgende commando:
$ eval $(minikube docker-env)
Vervolgens voeren we de opdracht mvn k8s:build in, en dit is wat we op het scherm zullen zien wanneer we de docker-image bouwen met behulp van de Eclipse JKube build-taak:
~/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 : $
Stap 3. Upload de afbeelding naar het docker-register
Nadat we de docker-image hebben gebouwd met het push-register geconfigureerd (in ons geval is dit docker.io), kunnen we deze image naar het register sturen. Dit is wat er zal worden weergegeven nadat we Eclipse JKube hebben gevraagd om de mvn k8s:push push-taak uit te voeren:
~/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 : $
Nadat u de afbeelding heeft verzonden, moet u controleren of deze in het register is opgenomen. In ons geval zien we het eenvoudigweg in Docker Hub, zoals weergegeven in Fig. 4.
Rijst. 4. De afbeelding die naar het register werd verzonden, verscheen in Docker Hub.
Stap 4. Genereer Kubernetes-resourcemanifesten voor de applicatie
We hebben dus de applicatie-image verzameld, nu moeten we Kubernetes-manifesten schrijven. Om dit te doen heeft Eclipse JKube een taak die rigide bronmanifesten genereert op basis van het onderliggende Java-framework (, , Vert.x of een ander). U kunt het manifest ook aanpassen door een XML-configuratiebestand te gebruiken en onbewerkte fragmenten (fragmenten van het vereiste bronmanifest) in de toepassingsmap src/main/jkube te plaatsen. In dit geval wordt uw configuratie geüpload naar de gegenereerde manifesten.
In ons voorbeeld laten we alles zoals het is, en daarom genereert Eclipse JKube een manifest voor de standaardimplementatie en voor de service met type ClusterIP. En alleen dan passen we het servicemanifest aan om het servicetype te wijzigen in NodePort. U kunt het standaardgedrag overschrijven met behulp van de volgende eigenschap:
<jkube.enricher.jkube-service.type>NodePort</jkube.enricher.jkube-service.type>
Zo ziet de schermuitvoer eruit nadat we Eclipse JKube hebben gevraagd om de mvn k8s:resource resource-taak uit te voeren.
~/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 : $
Stap 5. Implementeer de applicatie in het Kubernetes-cluster
Nu zijn we er helemaal klaar voor om de applicatie te implementeren: we hebben de afbeelding gegenereerd en vervolgens automatisch bronmanifesten gegenereerd. Nu rest ons alleen nog om dit allemaal toe te passen op het Kubernetes-cluster. Om de applicatie te implementeren, kunt u uiteraard het kubectl apply -f commando gebruiken, maar de plug-in kan dit voor ons doen. Dit is wat er op het scherm zal verschijnen nadat we Eclipse JKube hebben gevraagd om de mvn k8s:apply apply taak uit te voeren:
~/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"
}
Stap 6. Maak de implementatie van applicaties uit het Kubernetes-cluster ongedaan
Om dit te doen wordt de undeploy-taak gebruikt, die eenvoudigweg alle bronnen verwijdert die in de vorige stap zijn toegepast, dat wil zeggen wanneer de apply-taak wordt uitgevoerd. Dit is wat we op het scherm zullen zien nadat we Eclipse JKube hebben gevraagd om de mvn k8s: undeploy undeploy-taak uit te voeren:
~/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 : $
Wat kun je nog meer doen met Eclipse JKube
We hebben dus gekeken naar de belangrijkste doeltaken van Eclipse JKube en Kubernetes Maven Plugin, die de ontwikkeling van Java-applicaties voor het Kubernetes-platform vergemakkelijken. Als u deze taken niet voortdurend via het toetsenbord wilt invoeren, kunt u ze bijvoorbeeld als volgt in de plug-inconfiguratie schrijven:
<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>
Het moet gezegd worden dat we in dit artikel niet alle doeltaken hebben overwogen die zich in de Eclipse JKube en Kubernetes Maven Plugin bevinden, dus geven we in Tabel 2 een lijst met aanvullende taken die ook voor u nuttig kunnen zijn.
Tafel 2. Aanvullende Eclipse JKube-doeltaken.
Taak
Stadium
beschrijving
BEVESTIG
Logboeken ontvangen van een applicatie die op Kubernetes draait.
PAKKET
Open een debug-poort zodat u rechtstreeks vanuit de IDE fouten kunt opsporen in uw toepassing die op Kubernetes draait.
INSTALL
Het maken van een vork voor de installatietaak en het toepassen van de gegenereerde manifesten op het Kubernetes-cluster op dezelfde manier als in het geval van de toepassingstaak.
PAKKET
Automatische hot-implementatie van een applicatie door de naamruimte ervan te volgen.
Java-applicaties implementeren op Red Hat OpenShift met behulp van de OpenShift Maven-plug-in
Om de applicatie uit ons voorbeeld op het Red Hat OpenShift platform te implementeren, gebruiken we de plugin . Het enige verschil is dat het taakvoorvoegsel verandert van k8s in oc. Standaard doet de Kubernetes Maven-plug-in dat -assemblies, en de OpenShift Maven-plug-in - assemblies . We brengen geen wijzigingen aan in ons project, behalve het verwijderen van de eigenschap jkube.generator.name, omdat deze niet vereist is bij het pushen naar het register (OpenShift plaatst de afbeelding in het interne register tijdens de bouwfase). En dit is wat er op het scherm zal verschijnen als we ons voorbeeld uitvoeren, waarin we trouwens doeltaken niet één voor één uitvoeren, maar allemaal tegelijk:
~/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 : $
Videoles
Voor meer informatie over hoe u de ontwikkeling van Kubernetes eenvoudiger kunt maken met Eclipse JKube, bekijkt u deze video-tutorial over hoe u snel een eenvoudige Spring Boot-applicatie op Minikube kunt implementeren:
Conclusie
In dit artikel hebben we laten zien hoe Eclipse JKube het leven van een Java-ontwikkelaar gemakkelijker maakt als hij met Kubernetes werkt. Meer informatie over Eclipse JKube is te vinden op en .
Bron: www.habr.com