25 lat temu Java weszła w szerokie kręgi programistów, aby ostatecznie stać się jednym z tych filarów, wokół których budowane są stosy aplikacji. Jednak dziś wiele osób i organizacji, które przez długie lata były wierne Javie, przechodzi lub rozważa przejście na platformę lub jej pochodne, takie jak lub .
Niestety, Kubernetes ma strome krzywe uczenia się i wprowadza jeszcze jeden poziom operacyjny w znany programistom Java proces tworzenia. Dziś opowiemy, jak używać , aby uprościć te dodatkowe operacje związane z Kubernetes i kontenerami, a także zapewnić bezbolesną migrację na platformę chmurową z zachowaniem znanego ekosystemu Java. Co więcej, pokażemy, jak wdrażać aplikacje Java na platformie OpenShift za pomocą wtyczki OpenShift Maven.
Tradycyjny proces rozwoju Java
Tradycyjny proces tworzenia (Rys.1) zakłada, że programista pisze kod, następnie tworzy jednostki wdrożeniowe w postaci plików JAR lub WAR, a następnie wdraża i uruchamia te pliki na serwerze WWW lub serwerze aplikacji. W tym celu najczęściej używa się Maven z linii poleceń lub korzysta się z IDE, takich jak IntelliJ lub Eclipse, aby kodować i pakować aplikacje. Programiści są przyzwyczajeni do wprowadzania zmian w kodzie i dokładnego testowania wszystkiego, zanim zablokują kod i prześlą go do systemu zarządzania wersjami.
Rys. 1. Tradycyjny proces rozwoju Java.
Proces rozwoju Java dla chmury
Przechodząc do aplikacji chmurowych, do opisanego powyżej schematu dodawane są Kubernetes i . Dlatego teraz programista musi spakować aplikacje Java w i stworzyć manifesty Kubernetes, które opisują te obrazy. Następnie te manifesty są stosowane na serwerze produkcyjnym, na którym działa Kubernetes. Z kolei Kubernetes pobiera te obrazy z rejestru i wdraża aplikacje zgodnie z tymi konfiguracjami, które określiliśmy w manifestach, które zazwyczaj są plikami YAML.
Metamorfoza tradycyjnego procesu rozwoju Java przy przejściu do chmury przedstawiona jest na Rys. 2.
Rys. 2. Proces rozwoju Java dla chmury.
Eclipse JKube
Przejście na Kubernetes dodaje kolejny poziom operacyjny w procesie rozwoju, co niepokoi wielu programistów, ponieważ wolą zajmować się swoją główną pracą – logiką aplikacji, a nie sposobem ich wdrażania. I tu wkracza , co pozwala programistom korzystać z ich bibliotek i wtyczek ( wraz z lub ), aby bez zbędnego wysiłku wykonywać operacje związane z kontenerami i Kubernetes, stosując schemat na Rys. 2.
W pozostałej części tego artykułu pokażemy, jak uprościć proces programowania w Javie w środowisku Kubernetes, korzystając z Eclipse JKube z wtyczką Kubernetes Maven Plugin.
Proces rozwoju dla chmury z użyciem Eclipse JKube
Rozważmy lekko zmodyfikowaną schematę programowania w Javie dla chmury z Rys. 2, wprowadzając do niej Eclipse JKube i Kubernetes Maven Plugin, jak pokazano na Rys. 3.
Rys. 3. Proces programowania w Javie dla chmury z użyciem Eclipse JKube.
Jak widać, wszystkie operacje interakcji z Kubernetes i kontenerami (w schemacie zaznaczone na czerwono) zastępowane są domyślnymi zadaniami Eclipse JKube, które wymienione są w Tab. 1.
Tabl. 1. Domyślne zadania Eclipse JKube.
Zadanie
Etap
Opis
PRE_INTEGRATION_TEST
Budowanie obrazów Docker
INSTALL
Wysyłanie obrazów Docker do rejestru
PROCESS_RESOURCES
Generowanie manifestów K8s
COMPILE
Zastosowanie wygenerowanych manifestów do K8s
UNDEPLOY
Usuwanie zasobów K8s, które zostały wdrożone za pomocą k8s:apply i k8s:deploy
Uwaga: Jeśli nie chcesz, aby zadania używały tych sztywnych domyślnych ustawień (opinionated defaults), możesz ręcznie skonfigurować Eclipse JKube według własnych potrzeb, ponieważ wspiera on konfigurację przez i .
Teraz przyjrzyjmy się przykładom użycia Eclipse JKube i Kubernetes Maven Plugin przy pracy z aplikacjami.
Wdróż aplikację Java w Kubernetes za pomocą Eclipse JKube
W tym przykładzie wdrożymy prostą aplikację Java w klastrze za pomocą Eclipse JKube. Używając Kubernetes Maven Plugin, możemy ustawić parametry wdrożenia bez konieczności pisania jakiejkolwiek konfiguracji.
Jako przykład aplikacji użyjemy , który zwraca JSON-output na endpoint’cie /random:
~ /work/repos/eclipse-jkube-demo-project : $ curl localhost:8080/random | jq .
% Całkowity % Odebrane % Przesłane Średnia Szybkość Czas Czas Czas Bieżący
Pobrano Wysłano Całkowity Spędzony Pozostały Szybkość
100 45 0 45 0 0 818 0 --:--:-- --:--:-- --:--:-- 818
{
"id": "e80a4d10-c79b-4b9a-aaac-7c286cb37f3c"
}
Krok 1. Ładujemy Kubernetes Maven Plugin
Kubernetes Maven Plugin znajduje się w repozytorium . Aby korzystać z Eclipse JKube, należy dodać Kubernetes Maven Plugin do swojego pom.xml jako zależność:
org.eclipse.jkube
kubernetes-maven-plugin
${jkube.version}
Jeśli zamiast czystego Kubernetes używany jest OpenShift, to pom.xml modyfikuje się w następujący sposób:
org.eclipse.jkube
openshift-maven-plugin
${jkube.version}
Krok 2. Budujemy obraz dockera
Plik JAR aplikacji można zbudować poleceniem mvn package, a następnie można użyć celu mvn k8s:build, aby zbudować obraz dockera tej aplikacji. Zauważ, że nadpisaliśmy domyślną nazwę obrazu za pomocą tej właściwości:
docker.io/rohankanojia/random-generator:${project.version}
Przed zbudowaniem obrazu należy upewnić się, że demon dockera jest poprawnie eksponowany. Można to zrobić następującym poleceniem:
$ eval $(minikube docker-env)
Następnie wpisujemy polecenie mvn k8s:build i oto, co zobaczymy na ekranie podczas budowy obrazu dockera za pomocą celu build Eclipse JKube:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:build
[INFO] Skanning projektów...
[INFO]
[INFO] ---------------------------------------------
[INFO] Budowanie random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] k8s: Uruchamianie w trybie Kubernetes
[INFO] k8s: Budowanie obrazu Docker w trybie Kubernetes
[INFO] k8s: Uruchamianie generatora spring-boot
[INFO] k8s: spring-boot: Używanie obrazu Dockera quay.io/jkube/jkube-java-binary-s2i:0.0.7 jako bazy / buildera
[INFO] k8s: [docker.io/rohankanojia/random-generator:0.0.1] "spring-boot": Utworzono docker-build.tar w 251 milisekund
[INFO] k8s: [docker.io/rohankanojia/random-generator:0.0.1] "spring-boot": Zbudowano obraz sha256:a20e5
[INFO] ------------------------------------------------------------------------
[INFO] BUDOWA SUKCES
[INFO] ------------------------------------------------------------------------
[INFO] Łączny czas: 5.053 s
[INFO] Zakończono o: 2020-08-10T11:28:23+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $
Krok 3. Wysyłamy obraz do rejestru dockera
Po zbudowaniu obrazu dockera przy skonfigurowanym rejestrze push (w naszym przypadku docker.io), można wysłać ten obraz do rejestru. Oto co zostanie wyświetlone na ekranie po tym, jak poprosimy Eclipse JKube o wykonanie zadania push mvn k8s:push:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:push
[INFO] Skanowanie projektów...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Budowanie random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:push (default-cli) @ random-generator ---
[INFO] k8s: Uruchamianie w trybie Kubernetes
[INFO] k8s: Budowanie obrazu Docker w trybie Kubernetes
[INFO] k8s: Uruchamianie generatora spring-boot
[INFO] k8s: spring-boot: Używanie obrazu Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 jako bazowy \/ builder
[INFO] k8s: Wysłanie odnosi się do repozytorium [docker.io\/rohankanojia\/random-generator]
5dcd9556710f: Warstwa już istnieje
b7139ad07aa8: Warstwa już istnieje
b6f081e4b2b6: Warstwa już istnieje
d8e1f35641ac: Warstwa już istnieje
[INFO] k8s: 0.0.1: digest: sha256:9f9eda2a13b8cab1d2c9e474248500145fc09e2922fe3735692f9bda4c76002d rozmiar: 1162
[INFO] k8s: Wysłano docker.io\/rohankanojia\/random-generator:0.0.1 w 7 sekund
[INFO] ------------------------------------------------------------------------
[INFO] BUDOWA UDANA
[INFO] ------------------------------------------------------------------------
[INFO] Całkowity czas: 11.222 s
[INFO] Zakończono o: 2020-08-10T11:35:37+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $
Po wysłaniu obrazu należy sprawdzić, czy trafił on do rejestru. W naszym przypadku pojawia się on po prostu w Docker Hub, jak pokazano na Rys. 4.
Rys. 4. Wysłany do rejestru obraz pojawił się w Docker Hub.
Krok 4. Generujemy manifesty zasobów Kubernetes dla aplikacji
Zatem, zbudowaliśmy obraz aplikacji, teraz musimy napisać manifesty Kubernetes. W tym celu w Eclipse JKube znajduje się zadanie, które generuje sztywne manifesty zasobów, opierając się na podległym frameworku Java (, , Vert.x lub innym). Można również skonfigurować manifest, używając pliku konfiguracyjnego XML i umieszczając surowe fragmenty (fragmenty wymaganych manifestów zasobów) w folderze aplikacji src\/main\/jkube. W takim przypadku Twoja konfiguracja zostanie załadowana do generowanych manifestów.
W naszym przykładzie zostawiamy wszystko jak jest, więc Eclipse JKube generuje manifest dla domyślnego wdrożenia i dla serwisu typu ClusterIP. A następnie modyfikujemy manifest serwisu, aby zmienić typ serwisu na NodePort. Można nadpisać domyślne zachowanie za pomocą następującej właściwości:
<jkube.enricher.jkube-service.type>NodePort<\/jkube.enricher.jkube-service.type>
Oto jak wygląda wyjście ekranowe po tym, jak poprosimy Eclipse JKube o wykonanie zadania resource mvn k8s:resource.
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:resource
[INFO] Skanowanie projektów...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Budowanie random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:resource (default-cli) @ random-generator ---
[INFO] k8s: Uruchamianie generatora spring-boot
[INFO] k8s: spring-boot: Używanie obrazu Docker quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 jako podstawy \/ budowniczego
[INFO] k8s: jkube-controller: Dodawanie domyślnego wdrożenia
[INFO] k8s: jkube-service: Dodawanie domyślnej usługi 'random-generator' z portami [8080]
[INFO] k8s: jkube-healthcheck-spring-boot: Dodawanie testu gotowości na porcie 8080, ścieżka='\/actuator\/health', schemat='HTTP', z początkowym opóźnieniem 10 sekund
[INFO] k8s: jkube-healthcheck-spring-boot: Dodawanie testu żywotności na porcie 8080, ścieżka='\/actuator\/health', schemat='HTTP', z początkowym opóźnieniem 180 sekund
[INFO] k8s: jkube-revision-history: Dodawanie limitu historii rewizji do 2
[INFO] ------------------------------------------------------------------------
[INFO] BUDOWA SUKCES
[INFO] ------------------------------------------------------------------------
[INFO] Czas całkowity: 3.344 s
[INFO] Zakończono o: 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 : $
Krok 5. Wdrażanie aplikacji w klastrze Kubernetes
Zatem jesteśmy gotowi, aby przeprowadzić wdrożenie aplikacji: wygenerowaliśmy jej obraz, a następnie automatycznie wygenerowaliśmy manifesty zasobów. Teraz wystarczy tylko zastosować to w klastrze Kubernetes. Można oczywiście użyć polecenia kubectl apply -f do wdrożenia aplikacji, ale wtyczka może zrobić to za nas. Oto, co wyświetli się na ekranie po tym, jak poprosimy Eclipse JKube o wykonanie zadania apply mvn k8s:apply:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn k8s:apply
[INFO] Skanowanie projektów...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Budowanie random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- kubernetes-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] k8s: Używanie Kubernetes na https:\/\/192.168.39.145:8443\/ w namespace default z manifestem \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/classes\/META-INF\/jkube\/kubernetes.yml
[INFO] k8s: Używanie namespace: default
[INFO] k8s: Tworzenie usługi z kubernetes.yml namespace default nazwa random-generator
[INFO] k8s: Utworzono usługę: target\/jkube\/applyJson\/default\/service-random-generator.json
[INFO] k8s: Tworzenie wdrożenia z kubernetes.yml namespace default nazwa random-generator
[INFO] k8s: Utworzono wdrożenie: target\/jkube\/applyJson\/default\/deployment-random-generator.json
[INFO] k8s: WSKAZÓWKA: Użyj komendy `kubectl get pods -w`, aby obserwować proces uruchamiania podów
[INFO] ------------------------------------------------------------------------
[INFO] BUDOWA ZAKOŃCZONA SUKCESEM
[INFO] ------------------------------------------------------------------------
[INFO] Całkowity czas: 7.306 s
[INFO] Zakończono o: 2020-08-10T11:40:57+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get pods -w
NAZWA GOTOWE STATUS RESTARTY WIEK
random-generator-58b7847d7f-9m9df 0\/1 Uruchomiony 0 7s
random-generator-58b7847d7f-9m9df 1\/1 Uruchomiony 0 17s
^C~\/work\/repos\/eclipse-jkube-demo-project : $ kubectl get svc
NAZWA TYP CLUSTER-IP EXTERNAL-IP PORT(Y) WIEK
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 .
% Całkowity % Otrzymano % Xferd Średnia Prędkość Czas Czas Czas Bieżący
Dload Upload Całkowity Spędzony Pozostały Prędkość
100 45 0 45 0 0 1800 0 --:--:-- --:--:-- --:--:-- 1875
{
"id": "42e5571f-a20f-44b3-8184-370356581d10"
}
Krok 6. Usuwamy aplikację z klastra Kubernetes
Używana jest tutaj zadanie undeploy, które po prostu usuwa wszystkie zasoby, które zostały zastosowane w poprzednim kroku, czyli podczas wykonywania zadania apply. Oto, co zobaczymy na ekranie po tym, jak poprosimy Eclipse JKube o wykonanie zadania undeploy 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 : $
Co jeszcze można zrobić z Eclipse JKube
Omówiliśmy główne zadania (goals) Eclipse JKube oraz Kubernetes Maven Plugin, które ułatwiają rozwój aplikacji Java na platformie Kubernetes. Jeśli nie chcesz za każdym razem wprowadzać tych zadań z klawiatury, możesz je zapisać w konfiguracji pluginu, na przykład tak:
org.eclipse.jkube
kubernetes-maven-plugin
${project.version}
build
resource
apply
Muszę powiedzieć, że w tym artykule omówiliśmy zaledwie niektóre zadania (goals) dostępne w Eclipse JKube i Kubernetes Maven Plugin, dlatego przedstawiamy w Tabeli 2 listę dodatkowych zadań, które mogą być pomocne.
Tabela 2. Dodatkowe zadania (goals) Eclipse JKube.
Zadanie
Etap
Opis
WERYFIKACJA
Pobieranie logów z aplikacji działającej na Kubernetes.
PAKOWANIE
Otwarcie portu debugowania, aby móc debugować aplikację działającą na Kubernetes bezpośrednio z IDE.
INSTALL
Stworzenie forka dla zadania Install i zastosowanie wygenerowanych manifestów w klastrze Kubernetes w taki sam sposób, jak w przypadku zadania apply.
PAKOWANIE
Automatyczne gorące wdrażanie aplikacji dzięki monitorowaniu jej przestrzeni nazw.
Wdrażanie aplikacji Java na platformie Red Hat OpenShift za pomocą OpenShift Maven Plugin
Aby wdrożyć aplikację z naszego przykładu na platformie Red Hat OpenShift, zastosujemy plugin . Jedyna różnica będzie taka, że prefiks zadań zmieni się z k8s na oc. Domyślnie plugin Kubernetes Maven wykonuje -zbiory, a plugin OpenShift Maven – zbiory . Nie wprowadzamy żadnych zmian w naszym projekcie, z wyjątkiem usunięcia właściwości jkube.generator.name, ponieważ nie jest ona wymagana podczas przesyłania do rejestru (na etapie budowania OpenShift umieszcza obraz w swoim wewnętrznym rejestrze). A oto co pojawi się na ekranie, gdy uruchomimy nasz przykład, w którym zresztą wykonujemy zadania goal nie po jednej, a wszystkie naraz:
~\/work\/repos\/eclipse-jkube-demo-project : $ mvn oc:build oc:resource oc:apply
[INFO] Skanowanie projektów...
[INFO]
[INFO] ----------------------< meetup:random-generator >-----------------------
[INFO] Budowanie random-generator 0.0.1
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:build (default-cli) @ random-generator ---
[INFO] oc: Używanie budowy OpenShift z strategią S2I
[INFO] oc: Praca w trybie OpenShift
[INFO] oc: Uruchamianie generatora spring-boot
[INFO] oc: spring-boot: Używanie obrazu Dockera quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 jako bazy \/ budowniczego
[INFO] oc: [random-generator:0.0.1] "spring-boot": Utworzono tar źródłowy dockera \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/docker\/random-generator\/0.0.1\/tmp\/docker-build.tar
[INFO] oc: Dodawanie do Secret pullsecret-jkube
[INFO] oc: Używanie Secret pullsecret-jkube
[INFO] oc: Tworzenie BuildServiceConfig random-generator-s2i dla budowy źródłowej
[INFO] oc: Tworzenie ImageStream random-generator
[INFO] oc: Rozpoczynanie budowy random-generator-s2i
[INFO] oc: Oczekiwanie na zakończenie budowy random-generator-s2i-1...
[INFO] oc: Caching blobs under "\/var\/cache\/blobs".
[INFO] oc: Uzyskiwanie podpisów źródła obrazu
[INFO] oc: Kopiowanie bloba sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Kopiowanie bloba sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Kopiowanie bloba sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Kopiowanie konfiguracji sha256:52d6788fcfdd39595264d34a3959464a5dabc1d4ef0ae188802b20fc2d6a857b
[INFO] oc: Zapis manifestu do lokalizacji obrazu
[INFO] oc: Przechowywanie podpisów
[INFO] oc: Generowanie dockerfile z obrazem budowniczym quay.io\/jkube\/jkube-java-binary-s2i:0.0.7
[INFO] oc: KROK 1: Z OBRAZU quay.io\/jkube\/jkube-java-binary-s2i:0.0.7
[INFO] oc: KROK 2: ETYKIETA "io.openshift.build.source-location"="\/tmp\/build\/inputs" "io.openshift.build.image"="quay.io\/jkube\/jkube-java-binary-s2i:0.0.7"
[INFO] oc: KROK 3: ENV JAVA_APP_DIR="\/deployments" OPENSHIFT_BUILD_NAME="random-generator-s2i-1" OPENSHIFT_BUILD_NAMESPACE="default"
[INFO] oc: KROK 4: UŻYTKOWNIK root
[INFO] oc: KROK 5: KOPIUJ upload\/src \/tmp\/src
[INFO] oc: KROK 6: WYKONAJ chown -R 1000:0 \/tmp\/src
[INFO] oc: KROK 7: UŻYTKOWNIK 1000
[INFO] oc: KROK 8: WYKONAJ \/usr\/local\/s2i\/assemble
[INFO] oc: INFO S2I wykryto budowę źródłową z prostymi binariami
[INFO] oc: INFO S2I wykryto budowę binarną z fabric8-maven-plugin
[INFO] oc: INFO Kopiowanie binariów z \/tmp\/src\/deployments do \/deployments ...
[INFO] oc: random-generator-0.0.1.jar
[INFO] oc: INFO Kopiowanie wdrożeń z deployments do \/deployments...
[INFO] oc: '\/tmp\/src\/deployments\/random-generator-0.0.1.jar' -> '\/deployments\/random-generator-0.0.1.jar'
[INFO] oc: KROK 9: CMD \/usr\/local\/s2i\/run
[INFO] oc: KROK 10: ZOBOWIĄZANIE temp.builder.openshift.io\/default\/random-generator-s2i-1:48795e41
[INFO] oc: czas="2020-08-10T06:37:49Z" poziom=info msg="Niespójność systemu operacyjnego obrazu: obraz używa "", oczekuje "linux""
[INFO] oc: czas="2020-08-10T06:37:49Z" poziom=info msg="Niespójność architektury obrazu: obraz używa "", oczekuje "amd64""
[INFO] oc: Uzyskiwanie podpisów źródła obrazu
[INFO] oc: Kopiowanie bloba sha256:d8e1f35641acb80b562f70cf49911341dfbe8c86f4d522b18efbf3732aa74223
[INFO] oc: Kopiowanie bloba sha256:b6f081e4b2b6de8be4b1dec132043d14c121e968384dd624fb69c2c07b482edb
[INFO] oc: Kopiowanie bloba sha256:b7139ad07aa8ce4ed5a132f7c5cc9f1de0f5099b5e155027a23d57f7fbe78b16
[INFO] oc: Kopiowanie bloba sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Kopiowanie konfiguracji sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Zapis manifestu do lokalizacji obrazu
[INFO] oc: Przechowywanie podpisów
[INFO] oc: --> 27aaadaf28e
[INFO] oc: 27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Uzyskiwanie podpisów źródła obrazu
[INFO] oc:
[INFO] oc: Wypychanie obrazu image-registry.openshift-image-registry.svc:5000\/default\/random-generator:0.0.1 ...
[INFO] oc: Kopiowanie bloba sha256:f320f94d91a064281f5127d5f49954b481062c7d56cce3b09910e471cf849050
[INFO] oc: Kopiowanie bloba sha256:cf0f3ebe9f536c782ab3835049cfbd9a663761ded9370791ef6ea3965c823aad
[INFO] oc: Kopiowanie bloba sha256:57de4da701b511cba33bbdc424757f7f3b408bea741ca714ace265da9b59191a
[INFO] oc: Kopiowanie bloba sha256:98972fc90a1108315cc5b05b2c691a0849a149727a7b81e76bc847ac2c6d9714
[INFO] oc: Kopiowanie konfiguracji sha256:27aaadaf28e24856a66db962b88118b8222b61d79163dceeeed869f7289bc230
[INFO] oc: Zapis manifestu do lokalizacji obrazu
[INFO] oc: Przechowywanie podpisów
[INFO] oc: Pomyślnie wypchnięto image-registry.openshift-image-registry.svc:5000\/default\/random-generator@sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: Wypychanie udane
[INFO] oc: Budowa random-generator-s2i-1 w statusie Zakończona
[INFO] oc: Znaleziono znaczek na ImageStream random-generator tag: sha256:aa9e1a380c04ef9174ba56459c13d44420ebe653ebf32884d60fe4306b17306d
[INFO] oc: ImageStream random-generator zapisano do \/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: Używanie nazwy obrazu dockera w namespace: default
[INFO] oc: Uruchamianie generatora spring-boot
[INFO] oc: spring-boot: Używanie obrazu Dockera quay.io\/jkube\/jkube-java-binary-s2i:0.0.7 jako bazy \/ budowniczego
[INFO] oc: jkube-controller: Dodawanie domyślnej DeploymentConfig
[INFO] oc: jkube-service: Dodawanie domyślnej usługi 'random-generator' z portami [8080]
[INFO] oc: jkube-healthcheck-spring-boot: Dodawanie kontroli gotowości na porcie 8080, ścieżka='\/actuator\/health', schemat='HTTP', początkowe opóźnienie 10 sekund
[INFO] oc: jkube-healthcheck-spring-boot: Dodawanie kontroli żywotności na porcie 8080, ścieżka='\/actuator\/health', schemat='HTTP', początkowe opóźnienie 180 sekund
[INFO] oc: jkube-revision-history: Dodawanie limitu historii rewizji do 2
[INFO]
[INFO] --- openshift-maven-plugin:1.0.0-rc-1:apply (default-cli) @ random-generator ---
[INFO] oc: Używanie OpenShift na https:\/\/api.crc.testing:6443\/ w namespace default z manifestem \/home\/rohaan\/work\/repos\/eclipse-jkube-demo-project\/target\/classes\/META-INF\/jkube\/openshift.yml
[INFO] oc: Wykryto platformę OpenShift
[INFO] oc: Używanie projektu: default
[INFO] oc: Tworzenie usługi z openshift.yml namespace default nazwa random-generator
[INFO] oc: Utworzono usługę: target\/jkube\/applyJson\/default\/service-random-generator.json
[INFO] oc: Tworzenie DeploymentConfig z openshift.yml namespace default nazwa random-generator
[INFO] oc: Utworzono DeploymentConfig: target\/jkube\/applyJson\/default\/deploymentconfig-random-generator.json
[INFO] oc: Tworzenie trasy default:random-generator host: null
[INFO] oc: WSKAZÓWKA: Użyj polecenia `oc get pods -w`, aby obserwować uruchamianie swoich podów
[INFO] ------------------------------------------------------------------------
[INFO] BUDOWA UDANA
[INFO] ------------------------------------------------------------------------
[INFO] Łączny czas: 01:07 min
[INFO] Zakończono o: 2020-08-10T12:08:00+05:30
[INFO] ------------------------------------------------------------------------
~\/work\/repos\/eclipse-jkube-demo-project : $ oc get pods -w
Nazwa Gotowe STATUS RESTARTY WIEK
random-generator-1-deploy 1\/1 Działający 0 14s
random-generator-1-vnrm9 0\/1 Działający 0 11s
random-generator-s2i-1-build 0\/1 Zakończone 0 1m
random-generator-1-vnrm9 1\/1 Działający 0 24s
random-generator-1-deploy 0\/1 Zakończone 0 28s
~\/work\/repos\/eclipse-jkube-demo-project : $ oc get routes
NAZWA HOST\/PORT ŚCIEŻKA USŁUGI PORT TERMINACJA WILDKARD
random-generator random-generator-default.apps-crc.testing random-generator 8080 Brak
~\/work\/repos\/eclipse-jkube-demo-project : $ curl random-generator-default.apps-crc.testing\/random
% Całkowity % Otrzymane % Transferowany Średnia Prędkość Czas Czas Czas Obecny
Dload Upload Całkowity Spędzony Pozostały Prędkość
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 uprościć rozwój Kubernetes za pomocą Eclipse JKube, obejrzyj lekcję wideo na temat szybkiego wdrażania prostej aplikacji Spring Boot na Minikube:
Podsumowanie
W tym artykule pokazaliśmy, jak Eclipse JKube ułatwia życie programistom Java podczas pracy z Kubernetes. Dodatkowe informacje na temat Eclipse JKube można znaleźć na i na .
Źródło: habr.com
