25 lat temu Java weszła do głównego nurtu programowania i ostatecznie stała się jednym z podstawowych elementów, wokół których budowane są stosy aplikacji. Dziś jednak wiele osób i organizacji, które od wielu lat są lojalne wobec Javy, jest zajętych migracją lub rozważa migrację na platformę. lub jego pochodne, np lub .
Niestety Kubernetes wymaga stromej krzywej uczenia się i wprowadza kolejną warstwę operacyjną do procesu programowania, do której przyzwyczajeni są programiści Java. Dzisiaj powiemy Ci, jak korzystać , aby uprościć te dodatkowe operacje związane z Kubernetesem i kontenerami oraz zapewnić bezbolesną migrację na platformę chmurową przy jednoczesnym zachowaniu znanego ekosystemu Java. Ponadto pokażemy jak wdrożyć aplikacje Java na platformie OpenShift za pomocą wtyczki OpenShift Maven.
Tradycyjny proces programowania w języku Java
Tradycyjny proces rozwoju (Rysunek 1) polega na pisaniu przez programistę kodu, następnie tworzeniu jednostek wdrażania w postaci plików JAR lub WAR, a następnie wdrażaniu i uruchamianiu tych plików na serwerze internetowym lub aplikacji. Głównym sposobem na osiągnięcie tego jest użycie Mavena z wiersza poleceń lub użycie IDE, takiego jak IntelliJ lub Eclipse, do kodowania i pakowania aplikacji. Programiści są przyzwyczajeni do wprowadzania zmian w kodzie i dokładnego testowania wszystkiego przed zatwierdzeniem kodu i przesłaniem go do kontroli wersji.
Ryż. 1. Tradycyjny proces programowania w Javie.
Proces programowania Java dla chmury
W przypadku przejścia na aplikacje w chmurze Kubernetes i . Dlatego teraz programista musi spakować aplikacje Java w i utwórz manifesty Kubernetes opisujące te obrazy. Te manifesty są następnie stosowane na serwerze produkcyjnym, na którym działa Kubernetes. Z kolei Kubernetes pobiera te obrazy z rejestru i wdraża aplikacje zgodnie z konfiguracjami, które zapisaliśmy w manifestach, którymi są zazwyczaj pliki YAML.
Metamorfozę tradycyjnego procesu tworzenia Java w przejściu do chmury pokazano na rys. 2.
Ryż. 2. Proces tworzenia Java dla chmury.
Zaćmienie JKube
Migracja do Kubernetes dodaje kolejną warstwę operacyjną do procesu programowania i wielu programistów denerwuje się tym, ponieważ chcą skupić się na swojej podstawowej pracy — logice aplikacji — zamiast na sposobie ich wdrażania. I tu właśnie wchodzi to w grę. , który umożliwia programistom korzystanie z ich bibliotek i wtyczek ( razem z lub ), aby bez wysiłku wykonywać operacje związane z kontenerami i Kubernetesem, postępując zgodnie ze schematem na rysunku. 2.
W dalszej części tego artykułu pokażemy, jak uprościć proces programowania Java w środowisku Kubernetes, używając Eclipse JKube z wtyczką Kubernetes Maven.
Proces tworzenia chmury przy użyciu Eclipse JKube
Rozważmy nieco zmodyfikowany schemat rozwoju Java dla chmury z rys. 2, wprowadzając do niej Eclipse JKube i Kubernetes Maven Plugin, jak pokazano na rys. 3.
Ryż. 3. Proces programowania Java dla chmury z wykorzystaniem Eclipse JKube.
Jak widzimy, tutaj wszystkie operacje interakcji z Kubernetesem i kontenerami (zaznaczone na diagramie na czerwono) zostały zastąpione domyślnymi zadaniami docelowymi Eclipse JKube, które są wymienione w tabeli. 1.
Tabela 1. Domyślne zadania Eclipse JKube.
Zadanie
Etap
Opis
PRE_INTEGRATION_TEST
Tworzenie obrazów dokowanych
INSTALL
Przesyłanie obrazów dokerów do rejestru
PROCESS_RESOURCES
Generowanie manifestów K8
SKOMPILOWAĆ
Stosowanie wygenerowanych manifestów do K8
NIEWDROŻENIE
Usuwanie zasobów K8s, które zostały wdrożone przy użyciu k8s:apply i k8s:deploy
Uwaga: Jeśli nie chcesz, aby zadania korzystały z tych uznanych ustawień domyślnych, możesz ręcznie skonfigurować Eclipse JKube dla siebie, ponieważ obsługuje on konfigurację za pośrednictwem и .
Przyjrzyjmy się teraz przykładom wykorzystania Eclipse JKube i Kubernetes Maven Plugin podczas pracy z aplikacjami.
Wdrażanie aplikacji Java na Kubernetes przy użyciu Eclipse JKube
W tym przykładzie wdrożymy prostą aplikację Java w klastrze przy użyciu Eclipse JKube. Korzystając z wtyczki Kubernetes Maven możemy ustawić parametry wdrożenia bez konieczności pisania jakiejkolwiek konfiguracji.
Jako przykładową aplikację używamy , który generuje dane wyjściowe JSON w punkcie końcowym /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"
}
Krok 1. Pobierz wtyczkę Kubernetes Maven
Wtyczka Kubernetes Maven znajduje się w repozytorium . Aby używać Eclipse JKube, musisz dodać wtyczkę Kubernetes Maven do pliku pom.xml jako zależność:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>kubernetes-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Jeśli zamiast czystego Kubernetesa zostanie użyty OpenShift, plik pom.xml zostanie zmodyfikowany w następujący sposób:
<plugin>
<groupId>org.eclipse.jkube</groupId>
<artifactId>openshift-maven-plugin</artifactId>
<version>${jkube.version}</version>
</plugin>
Krok 2. Zbuduj obraz okna dokowanego
Plik JAR aplikacji można zbudować za pomocą polecenia mvn package, a następnie za pomocą zadania mvn goal k8s:build można zbudować obraz okna dokowanego aplikacji. Pamiętaj, że zastąpiliśmy domyślną nazwę obrazu tą właściwością:
<jkube.generator.name>docker.io/rohankanojia/random-generator:${project.version}</jkube.generator.name>
Przed zbudowaniem obrazu należy upewnić się, że demon dokujący jest prawidłowo odsłonięty. Można to zrobić za pomocą następującego polecenia:
$ eval $(minikube docker-env)
Następnie wpisujemy komendę mvn k8s:build i oto co zobaczymy na ekranie podczas budowania obrazu dokera za pomocą zadania build Eclipse JKube:
~/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 : $
Krok 3. Prześlij obraz do rejestru dokera
Po zbudowaniu obrazu dokera ze skonfigurowanym rejestrem push (w naszym przypadku jest to docker.io) możemy wysłać ten obraz do rejestru. Oto, co zostanie wyświetlone, gdy poprosimy Eclipse JKube o wykonanie zadania mvn k8s:push push:
~/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 : $
Po wysłaniu obrazu należy sprawdzić, czy znajduje się on w rejestrze. W naszym przypadku widzimy to po prostu w Docker Hub, jak pokazano na rys. 4.
Ryż. 4. Obraz przesłany do rejestru pojawił się w Docker Hub.
Krok 4. Wygeneruj manifesty zasobów Kubernetes dla aplikacji
Zebraliśmy więc obraz aplikacji, teraz musimy napisać manifesty Kubernetesa. Aby to zrobić, Eclipse JKube ma zadanie generujące sztywne manifesty zasobów w oparciu o podstawowy framework Java (, , Vert.x lub jakiś inny). Możesz także dostosować manifest, korzystając z pliku konfiguracyjnego XML i umieszczając surowe fragmenty (fragmenty wymaganego manifestu zasobu) w folderze aplikacji src/main/jkube. W takim przypadku Twoja konfiguracja zostanie przesłana do wygenerowanych manifestów.
W naszym przykładzie zostawiamy wszystko tak jak jest, dlatego Eclipse JKube generuje manifest dla domyślnego wdrożenia i dla usługi o typie ClusterIP. I dopiero wtedy modyfikujemy manifest usługi, aby zmienić typ usługi na NodePort. Domyślne zachowanie można zastąpić za pomocą następującej właściwości:
<jkube.enricher.jkube-service.type>NodePort</jkube.enricher.jkube-service.type>
Tak wygląda wynik ekranu po poproszeniu Eclipse JKube o wykonanie zadania mvn k8s:resource 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 : $
Krok 5. Wdróż aplikację w klastrze Kubernetes
Teraz jesteśmy gotowi do wdrożenia aplikacji: wygenerowaliśmy jej obraz, a następnie automatycznie wygenerowaliśmy manifesty zasobów. Teraz pozostaje tylko zastosować to wszystko do klastra Kubernetes. Aby wdrożyć aplikację, możesz oczywiście skorzystać z polecenia kubectl Apply -f, ale wtyczka może to zrobić za nas. Oto, co pojawi się na ekranie, gdy poprosimy Eclipse JKube o wykonanie zadania mvn k8s:apply Apply:
~/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"
}
Krok 6. Cofnij wdrażanie aplikacji z klastra Kubernetes
Aby to zrobić, używane jest zadanie undeploy, które po prostu usuwa wszystkie zasoby, które zostały zastosowane w poprzednim kroku, to znaczy podczas wykonywania zadania Apply. Oto, co zobaczymy na ekranie po tym, jak poprosimy Eclipse JKube o wykonanie zadania 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 : $
Co jeszcze możesz zrobić z Eclipse JKube
Przyjrzeliśmy się więc głównym celom zadań Eclipse JKube i Kubernetes Maven Plugin, które ułatwiają tworzenie aplikacji Java na platformę Kubernetes. Jeśli nie chcesz ciągle wpisywać tych zadań z klawiatury, możesz zapisać je w konfiguracji wtyczki, na przykład w ten sposób:
<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>
Trzeba powiedzieć, że w tym artykule nie uwzględniliśmy wszystkich zadań docelowych, które znajdują się w Eclipse JKube i wtyczce Kubernetes Maven, dlatego w tabeli 2 przedstawiamy listę dodatkowych zadań, które również mogą Ci się przydać.
Tabela 2. Dodatkowe zadania bramkowe Eclipse JKube.
Zadanie
Etap
Opis
UPRAWOMOCNIĆ
Odbieranie logów z aplikacji działającej na Kubernetesie.
PAKIET
Otwórz port debugowania, aby móc debugować aplikację działającą na platformie Kubernetes bezpośrednio z IDE.
INSTALL
Utworzenie forka dla zadania Instaluj i zastosowanie wygenerowanych manifestów do klastra Kubernetes w taki sam sposób, jak w przypadku zadania Apply.
PAKIET
Automatyczne wdrażanie aplikacji na gorąco poprzez śledzenie jej przestrzeni nazw.
Wdrażanie aplikacji Java w systemie Red Hat OpenShift przy użyciu wtyczki OpenShift Maven
Do wdrożenia aplikacji z naszego przykładu na platformie Red Hat OpenShift używamy wtyczki . Jedyną różnicą będzie zmiana prefiksu zadania z k8s na oc. Domyślnie robi to wtyczka Kubernetes Maven -assemblies i wtyczka OpenShift Maven - assemblies . Nie wprowadzamy żadnych zmian w naszym projekcie poza usunięciem właściwości jkube.generator.name, ponieważ nie jest ona wymagana podczas wypychania do rejestru (OpenShift umieszcza obraz w swoim wewnętrznym rejestrze podczas fazy kompilacji). A oto co wyświetli się na ekranie po uruchomieniu naszego przykładu, w którym notabene zadania celowe realizujemy nie pojedynczo, ale wszystkie na raz:
~/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 : $
Lekcja wideo
Aby dowiedzieć się więcej o tym, jak ułatwić programowanie Kubernetesa za pomocą Eclipse JKube, obejrzyj ten samouczek wideo na temat szybkiego wdrażania prostej aplikacji Spring Boot na Minikube:
wniosek
W tym artykule pokazaliśmy, jak Eclipse JKube ułatwia życie programiście Java podczas pracy z Kubernetesem. Więcej informacji na temat Eclipse JKube można znaleźć na stronie i .
Źródło: www.habr.com