Clever Geek Handbook

Mengembangkan Aplikasi Java untuk Kubernetes Menggunakan Eclipse JKube

25 tahun yang lalu Java memasuki programmer utama yang pada akhirnya menjadi salah satu pilar di mana tumpukan aplikasi dibangun. Namun, saat ini banyak orang dan organisasi yang setia pada Java selama bertahun-tahun sibuk bermigrasi atau mempertimbangkan migrasi ke Kubernetes atau turunannya seperti Red Hat OpenShift atau Amazon EKS .







Sayangnya, Kubernetes memiliki kurva pembelajaran yang curam dan memperkenalkan lapisan operasional lain ke dalam proses pengembangan Java. Hari ini kami akan menunjukkan cara menggunakan Eclipse JKubeuntuk menyederhanakan operasi tambahan yang terkait dengan Kubernetes dan container ini, dan menyediakan migrasi yang tidak merepotkan ke platform cloud sambil mempertahankan ekosistem Java yang sudah dikenal. Selain itu, kami akan menunjukkan kepada Anda cara menerapkan aplikasi Java pada platform OpenShift menggunakan plugin OpenShift Maven.



Proses pengembangan Java tradisional



Proses pengembangan Java tradisional (Gambar 1) berarti bahwa pengembang menulis kode, kemudian membuat unit penerapan sebagai file JAR atau WAR, lalu menyebarkan dan menjalankan file tersebut di web atau server aplikasi. Kebanyakan mereka menggunakan Maven dari baris perintah atau menggunakan IDE seperti IntelliJ atau Eclipse untuk membuat kode dan memaketkan aplikasi. Pengembang terbiasa membuat perubahan pada kode dan menguji semuanya secara menyeluruh sebelum memasukkan kode dan mengirimkannya ke kontrol sumber.







Angka: 1. Proses pembangunan Jawa tradisional.



Proses pengembangan Java untuk cloud



Pindah ke aplikasi cloud menambahkan Kubernetes dan container ke skema di atas . Oleh karena itu, developer sekarang perlu mengemas aplikasi Java ke dalam gambar container dan membuat manifes Kubernetes yang mendeskripsikan gambar tersebut. Manifes ini kemudian diterapkan ke server produksi tempat Kubernetes dijalankan. Pada gilirannya, Kubernetes mengambil gambar-gambar ini dari registri dan menerapkan aplikasi sesuai dengan konfigurasi yang telah kami tulis di manifes, yang biasanya berupa file YAML.



Metamorfosis perkembangan Jawa tradisional dalam transisi ke awan ditunjukkan pada Gambar. 2.







Angka: 2. Proses pengembangan Java untuk cloud.



Eclipse JKube



Pindah ke Kubernetes menambahkan lapisan operasional lain ke proses pengembangan, dan ini menakutkan bagi banyak pengembang karena mereka ingin melakukan tugas utama mereka - logika aplikasi - bukan bagaimana menerapkannya. Di sinilah Eclipse JKube berperan , yang memungkinkan pengembang untuk menggunakan pustaka dan plugin mereka ( Kit JKube bersama dengan Plugin Kubernetes Maven atau Plugin OpenShift Maven ) untuk dengan mudah melakukan operasi terkait container dan Kubernetes mengikuti diagram pada Gambar. 2.



Di sisa artikel ini, kami akan menunjukkan kepada Anda cara menyederhanakan proses pengembangan Java di Kubernetes menggunakan Eclipse JKube dengan Plugin Kubernetes Maven.



Proses pengembangan cloud menggunakan Eclipse JKube



Mari kita lihat framework pengembangan Java yang sedikit dimodifikasi untuk cloud dari Gambar 2, yang memperkenalkan Plugin Eclipse JKube dan Kubernetes Maven, seperti yang ditunjukkan pada Gambar 2. 3.







Angka: 3. Proses pengembangan Java untuk cloud menggunakan Eclipse JKube.



Seperti yang bisa kita lihat, di sini semua operasi untuk berinteraksi dengan Kubernetes dan container (disorot dengan warna merah di diagram) diganti dengan tugas tujuan Eclipse JKube default, yang tercantum dalam Tabel. 1.



Tab. 1. Gerhana tugas default JKube.



Tugas Tahap Deskripsi
k8s: build PRE_INTEGRATION_TEST Membangun gambar buruh pelabuhan
k8s: dorong INSTALL Mengupload gambar buruh pelabuhan ke registri
k8s: sumber daya PROCESS_RESOURCES Menghasilkan manifes K8
k8s: terapkan MENYUSUN Menerapkan Manifes yang Dihasilkan ke K8s
k8s: batalkan penerapan UNDEPLOY Menghapus aset K8 yang di-deploy dengan k8s: apply dan k8s: deploy


Catatan: Jika Anda tidak ingin tugas menggunakan default beropini ini, Anda dapat menyesuaikan Eclipse JKube secara manual untuk Anda sendiri, karena mendukung konfigurasi melalui XML dan sumber daya .



Sekarang mari kita lihat contoh penggunaan Plugin Eclipse JKube dan Kubernetes Maven saat bekerja dengan aplikasi.



Deploy aplikasi Java ke Kubernetes menggunakan Eclipse JKube



Dalam contoh ini, kami akan menerapkan aplikasi Java sederhana ke cluster Minikube menggunakan Eclipse JKube. Dengan menggunakan Plugin Kubernetes Maven, kita dapat mengatur opsi penerapan tanpa harus menulis konfigurasi apa pun.



Sebagai contoh aplikasi, kami menggunakan generator nomor acak sederhana yang menghasilkan keluaran JSON di / titik akhir acak: 



~/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"
}


Langkah 1. Unduh Plugin



Kubernetes Maven Plugin Kubernetes Maven terletak di Repositori Pusat Maven . Untuk menggunakan Eclipse JKube, Anda perlu menambahkan Plugin Kubernetes Maven ke pom.xml Anda sebagai dependensi: 



<plugin>
     <groupId>org.eclipse.jkube</groupId>
     <artifactId>kubernetes-maven-plugin</artifactId>
     <version>${jkube.version}</version>
 </plugin>


Jika OpenShift digunakan sebagai pengganti Kubernetes murni, maka pom.xml diubah sebagai berikut: 



<plugin>
     <groupId>org.eclipse.jkube</groupId>
     <artifactId>openshift-maven-plugin</artifactId>
     <version>${jkube.version}</version>
 </plugin>


Langkah 2. Membangun citra buruh pelabuhan



File JAR aplikasi dapat dibangun dengan perintah mvn package, dan kemudian Anda dapat menggunakan tugas mvn k8s: membangun tujuan untuk membangun citra buruh pelabuhan dari aplikasi ini. Perhatikan bahwa kami telah mengganti nama gambar default dengan properti ini: 



<jkube.generator.name>docker.io/rohankanojia/random-generator:${project.version}</jkube.generator.name>


Sebelum membangun image, Anda perlu memastikan bahwa daemon buruh pelabuhan terbuka dengan benar. Ini dapat dilakukan dengan perintah berikut: 



$ eval $(minikube docker-env)


Kemudian kita memasukkan perintah mvn k8s: build, dan inilah yang kita lihat di layar saat membangun image buruh pelabuhan menggunakan tugas 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 : $


Langkah 3. Mengupload image ke registry docker



Setelah kita membangun image buruh pelabuhan dengan push registry yang dikonfigurasi (dalam kasus kita, ini adalah docker.io), kita dapat mendorong image ini ke registry. Inilah yang ditampilkan setelah kami meminta Eclipse JKube untuk menjalankan tugas 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 : $


Setelah mengirim gambar, Anda perlu memeriksa bahwa itu ada di registri. Dalam kasus kami, kami hanya melihatnya di Docker Hub, seperti yang ditunjukkan pada Gambar. 4.







Angka: 4. Gambar yang diunggah ke registri muncul di Docker Hub.



Langkah 4. Membuat sumber daya Kubernetes untuk aplikasi



Jadi, kita telah mengumpulkan gambar aplikasi, sekarang kita perlu menulis manifest Kubernetes. Untuk melakukan ini, Eclipse JKube memiliki tugas yang menghasilkan manifes sumber daya keras berdasarkan kerangka kerja Java yang mendasari ( Spring Boot , Quarkus , Vert.x, atau lainnya). Anda juga dapat menyesuaikan manifes dengan menggunakan file XML konfigurasi dan meletakkan fragmen mentah (fragmen dari manifes sumber daya yang diperlukan) di folder aplikasi src / main / jkube. Dalam kasus ini, konfigurasi Anda akan diupload ke manifes yang dibuat.



Dalam contoh kami, kami membiarkan semuanya apa adanya, dan oleh karena itu Eclipse JKube menghasilkan manifes untuk penerapan default dan untuk layanan dengan tipe ClusterIP. Kemudian kami memodifikasi manifes layanan untuk mengubah jenis layanan ke NodePort. Anda dapat mengganti perilaku default menggunakan properti berikut: 



<jkube.enricher.jkube-service.type>NodePort</jkube.enricher.jkube-service.type>


Seperti inilah tampilan keluaran layar setelah kita meminta Eclipse JKube untuk menjalankan tugas 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: 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 : $


Langkah 5. Menerapkan aplikasi ke cluster Kubernetes



Jadi, kami siap untuk menerapkan aplikasi: kami membuat gambarnya dan kemudian secara otomatis membuat sumber daya. Sekarang yang tersisa hanyalah menerapkan semua ini ke cluster Kubernetes. Untuk menerapkan aplikasi, Anda tentu saja dapat menggunakan perintah kubectl apply -f, tetapi plugin dapat melakukannya untuk kita. Inilah yang muncul di layar setelah kami meminta Eclipse JKube untuk menjalankan mvn k8s: apply apply task: 



~/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"
}


Langkah 6. Kami membatalkan penerapan aplikasi dari cluster Kubernetes



Untuk ini, tugas undeploy digunakan, yang hanya menghapus semua resource yang diterapkan di langkah sebelumnya, yaitu saat tugas apply dijalankan. Inilah yang kita lihat di layar setelah kita meminta Eclipse JKube untuk menjalankan tugas 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 : $


Apa lagi yang dapat Anda lakukan dengan Eclipse JKube



Jadi, kami telah membahas tujuan utama Plugin Eclipse JKube dan Kubernetes Maven, yang membuatnya mudah untuk mengembangkan aplikasi Java untuk platform Kubernetes. Jika Anda tidak ingin terus-menerus memasukkan tugas ini dari keyboard, Anda dapat menulisnya di konfigurasi plugin, misalnya, seperti ini: 



<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>


Saya harus mengatakan bahwa dalam artikel ini kami telah mempertimbangkan jauh dari semua tugas-tujuan yang ada di Eclipse JKube dan Plugin Kubernetes Maven, oleh karena itu, kami menyajikan di Tabel 2 daftar tugas tambahan yang mungkin juga berguna bagi Anda.



Tab. 2. Tujuan Tambahan Eclipse JKube.



Tugas Tahap Deskripsi
k8s: log MENGESAHKAN Menerima log dari aplikasi yang berjalan di Kubernetes.
k8s: debug PAKET Membuka port debug untuk men-debug aplikasi Kubernetes Anda langsung dari IDE.
k8s: terapkan INSTALL Membagi tugas Instal dan menerapkan manifes yang dihasilkan ke kluster Kubernetes sama persis seperti dalam kasus tugas apply.
k8s: jam tangan PAKET Penerapan hot otomatis aplikasi dengan melacak namespace-nya.


Menerapkan Aplikasi Java ke Red Hat OpenShift Menggunakan Plugin OpenShift Maven



Untuk menerapkan aplikasi dari contoh kami ke platform Red Hat OpenShift, kami akan menggunakan plugin OpenShift Maven . Satu-satunya perbedaan adalah awalan tugas akan berubah dari k8s menjadi oc. Secara default plugin Kubernetes Maven membuat docker -sborki dan plug OpenShift Maven - assembly S2i . Kami tidak membuat perubahan apa pun pada proyek kami, kecuali untuk menghapus properti jkube.generator.name, karena tidak diperlukan saat mengirimkan ke registri (selama fase pembuatan, OpenShift menempatkan gambar di registri internalnya). Dan inilah yang akan muncul di layar saat kami menjalankan contoh kami, di mana, ngomong-ngomong, kami melakukan tugas tujuan tidak satu per satu, tetapi sekaligus: 



~/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 : $


Video tutorial



Untuk mempelajari lebih lanjut tentang cara menyederhanakan pengembangan Kubernetes dengan Eclipse JKube, tonton tutorial video tentang cara cepat menerapkan aplikasi Spring Boot sederhana di Minikube:





Kesimpulan



Di artikel ini, kami telah menunjukkan bagaimana Eclipse JKube membuat hidup lebih mudah bagi pengembang Java saat bekerja dengan Kubernetes. Informasi lebih lanjut tentang Eclipse JKube dapat ditemukan di situs proyek dan di GitHub .


More articles:


All Articles