Men-deploy aplikasi Micronaut dalam container dengan Jib ke Google Kubernetes Engine

Men-deploy aplikasi Micronaut dalam container dengan Jib ke Google Kubernetes Engine

Tentang codelab ini

Terakhir diperbarui Okt 7, 2020

Ditulis oleh Googler

1. Ringkasan

Tentang Micronaut

Micronaut adalah framework full stack modern berbasis JVM untuk membangun aplikasi serverless dan microservice modular yang mudah diuji. Micronaut bertujuan untuk memberikan waktu startup yang luar biasa, throughput yang cepat, dengan footprint memori minimal. Developer dapat mengembangkan aplikasi dengan Micronaut di Java, Groovy, atau Kotlin.

Micronaut menyediakan:

• Waktu startup yang cepat & konsumsi memori rendah — Framework IoC berbasis refleksi memuat dan meng-cache data refleksi untuk setiap kolom, metode, dan konstruktor dalam kode Anda, sedangkan dengan Micronaut, waktu startup aplikasi dan konsumsi memori tidak terikat dengan ukuran codebase Anda.
• Klien HTTP deklaratif, reaktif, dan waktu kompilasi — Buat klien HTTP reaktif secara deklaratif, yang diimplementasikan pada waktu kompilasi, sehingga mengurangi konsumsi memori.
• Server HTTP non-pemblokir yang dibangun di Netty — Dengan kurva pembelajaran yang lancar, server HTTP Micronaut mempermudah mengekspos API yang dapat digunakan oleh klien HTTP.
• Pengujian yang cepat dan mudah — Jalankan server dan klien dengan mudah di pengujian unit Anda, dan jalankan secara instan.
• Injeksi dependensi waktu kompilasi dan AOP yang efisien — Micronaut menyediakan API pemrograman berorientasi aspek waktu kompilasi sederhana yang tidak menggunakan refleksi.
• Membangun aplikasi yang sepenuhnya reaktif dan tidak memblokir — Micronaut mendukung framework apa pun yang menerapkan Aliran Reaktif, termasuk RxJava dan Reactor.

Untuk informasi selengkapnya, kunjungi situs Micronaut.

Tentang Kubernetes

Kubernetes adalah project open source yang dapat berjalan di berbagai lingkungan, dari laptop hingga cluster multinode dengan ketersediaan tinggi, dari cloud publik hingga deployment lokal, dari virtual machine hingga server khusus (bare metal).

Di lab ini, Anda akan men-deploy microservice Micronaut sederhana berbasis Groovy ke Kubernetes yang berjalan di Kubernetes Engine.

Tujuan codelab ini adalah agar Anda dapat menjalankan microservice sebagai layanan replika yang berjalan di Kubernetes. Anda mengambil kode yang telah dikembangkan di mesin, mengubahnya menjadi image container Docker, lalu menjalankan image tersebut di Kubernetes Engine.

Berikut adalah diagram berbagai bagian yang berfungsi dalam codelab ini untuk membantu Anda memahami cara kerja berbagai bagian. Gunakan ini sebagai referensi saat Anda melanjutkan codelab; semuanya sudah masuk akal pada saat Anda sampai ke akhir (tapi untuk saat ini Anda jangan ragu untuk mengabaikannya).

Untuk tujuan codelab ini, penggunaan lingkungan terkelola seperti Kubernetes Engine (versi Kubernetes yang dihosting Google dan berjalan di Compute Engine) memungkinkan Anda untuk lebih berfokus pada pengalaman menggunakan Kubernetes daripada menyiapkan infrastruktur yang mendasarinya.

Jika tertarik untuk menjalankan Kubernetes di komputer lokal, seperti laptop pengembangan, Anda mungkin perlu mempelajari Minikube. Fungsi ini menawarkan penyiapan sederhana dari cluster kubernetes node tunggal untuk tujuan pengembangan dan pengujian. Anda dapat menggunakan Minikube untuk membuka codelab ini jika mau.

Tentang Jib

Jib adalah alat open source yang memungkinkan Anda membangun image Docker dan OCI untuk aplikasi Java. Library ini tersedia sebagai plugin untuk Maven dan Gradle, serta sebagai library Java.

Jib bertujuan untuk:

• Cepat — Deploy perubahan Anda dengan cepat. Jib memisahkan aplikasi Anda menjadi beberapa lapisan, dengan memisahkan dependensi dari class. Sekarang Anda tidak perlu menunggu Docker membangun ulang seluruh aplikasi Java Anda - cukup deploy lapisan yang telah berubah.
• Dapat direproduksi — Membangun ulang image container dengan konten yang sama akan selalu menghasilkan image yang sama. Jangan pernah memicu lagi pembaruan yang tidak perlu.
• Daemonless — Kurangi dependensi CLI Anda. Bangun image Docker dari dalam Maven atau Gradle, lalu kirim ke registry mana pun pilihan Anda. Tidak perlu lagi menulis Dockerfile dan memanggil build/push docker.

Anda dapat menemukan informasi selengkapnya tentang Jib di halaman project GitHub.

Tentang tutorial ini

Tutorial ini menggunakan kode contoh dari alat Jib untuk membangun container bagi aplikasi Java.

Contoh ini adalah layanan hello world sederhana, menggunakan framework Micronaut, dan bahasa pemrograman Apache Groovy.

Yang akan Anda pelajari

• Cara memaketkan aplikasi Java sederhana sebagai container Docker menggunakan Jib
• Cara membuat cluster Kubernetes di Kubernetes Engine.
• Cara men-deploy layanan Micronaut ke Kubernetes di Kubernetes Engine
• Cara meningkatkan skala layanan dan meluncurkan upgrade.
• Cara mengakses dasbor Grafis Kubernetes.

Yang Anda butuhkan

• Project Google Cloud Platform
• Browser, seperti Chrome atau Firefox
• Pemahaman tentang editor teks Linux standar seperti Vim, EMACs, atau Nano

Bagaimana Anda akan menggunakan tutorial ini?

Hanya membacanyaMembacanya dan menyelesaikan latihan

Bagaimana Anda menilai pengalaman Anda membuat aplikasi web HTML/CSS?

PemulaMenengahMahir

Bagaimana penilaian Anda terhadap pengalaman menggunakan layanan Google Cloud Platform?

PemulaMenengahMahir

2. Penyiapan dan Persyaratan

Penyiapan lingkungan mandiri

1. Login ke Cloud Console dan buat project baru atau gunakan kembali project yang sudah ada. (Jika belum memiliki akun Gmail atau G Suite, Anda harus membuatnya.)

Catatan: Anda dapat mengakses Cloud Console dengan mudah dengan mengingat URL-nya, yaitu console.cloud.google.com.

Ingat project ID, nama unik di semua project Google Cloud (maaf, nama di atas telah digunakan dan tidak akan berfungsi untuk Anda!) Project ID tersebut selanjutnya akan dirujuk di codelab ini sebagai PROJECT_ID.

Catatan: Jika menggunakan akun Gmail, Anda dapat menyetel lokasi default ke Tidak ada organisasi. Jika Anda menggunakan akun G Suite, pilih lokasi yang sesuai untuk organisasi Anda.

2. Selanjutnya, Anda harus mengaktifkan penagihan di Cloud Console untuk menggunakan resource Google Cloud.

Menjalankan operasi dalam codelab ini seharusnya tidak memerlukan banyak biaya, bahkan mungkin tidak sama sekali. Pastikan untuk mengikuti petunjuk yang ada di bagian "Membersihkan" yang memberi tahu Anda cara menonaktifkan resource sehingga tidak menimbulkan penagihan di luar tutorial ini. Pengguna baru Google Cloud memenuhi syarat untuk mengikuti program Uji Coba Gratis senilai $300 USD.

3. Mendapatkan kode sumber contoh Micronaut

Setelah Cloud Shell diluncurkan, Anda dapat menggunakan command line untuk meng-clone kode sumber contoh di direktori beranda, dan menjalankan cd ke direktori yang berisi layanan contoh kami:

$ git clone https://github.com/GoogleContainerTools/jib.git
$ cd jib/examples/micronaut/

Repositori project Jib juga berisi project contoh untuk framework lain, seperti Spring Boot atau Vert.x, jika Anda ingin menggunakan contoh lain juga.

4. Sekilas tentang kode

Layanan sederhana Micronaut kami terbuat dari pengontrol yang menghasilkan pesan Hello World yang terkenal:

@Controller("/hello")
class HelloController {
    @Get("/")
    String index() {
        "Hello World"
    }
}

Pengontrol HelloController merespons permintaan pada jalur /hello, dan metode index() menerima permintaan GET HTTP.

Class pengujian Spock juga tersedia untuk memeriksa apakah pesan yang benar diberikan dalam output.

class HelloControllerSpec extends Specification {
    @Shared
    @AutoCleanup
    EmbeddedServer embeddedServer = ApplicationContext.run(EmbeddedServer)

    @Shared
    @AutoCleanup
    RxHttpClient client = embeddedServer.applicationContext.createBean(RxHttpClient, embeddedServer.getURL()) 

    void "test hello world response"() {
        when:
        HttpRequest request = HttpRequest.GET('/hello')
        String rsp  = client.toBlocking().retrieve(request)

        then:
        rsp == "Hello World"
    }
}

Lebih dari sekadar pengujian unit sederhana, pengujian ini sebenarnya menjalankan stack server Micronaut yang sama (berdasarkan framework Netty) yang dijalankan dalam produksi. Jadi, perilaku kode Anda akan sama di produk seperti dalam pengujian Anda.

Untuk menjalankan pengujian, Anda dapat menjalankan perintah berikut untuk memastikan semuanya berjalan lancar:

./gradlew test

5. Menjalankan Aplikasi Secara Lokal

Anda dapat memulai layanan Micronaut secara normal dengan perintah Gradle berikut:

$ ./gradlew run

Setelah aplikasi dimulai, Anda dapat membuka instance Cloud Shell tambahan berkat ikon + kecil, lalu memeriksa dengan curl bahwa Anda mendapatkan output yang diharapkan:

$ curl localhost:8080/hello

Anda akan melihat halaman "Hello World" (Halo Dunia) muncul.

6. Mengemas aplikasi sebagai container Docker dengan Jib

Selanjutnya, siapkan aplikasi Anda untuk berjalan di Kubernetes. Untuk tujuan tersebut, kita akan memanfaatkan Jib untuk melakukan kerja keras bagi kita, karena kita tidak perlu menyentuh Dockerfile sendiri.

Mari jalankan perintah untuk membangun container kita:

$ ./gradlew jibDockerBuild

Berikut output yang akan Anda lihat:

Tagging image with generated image reference micronaut-jib:0.1. If you'd like to specify a different tag, you can set the jib.to.image parameter in your build.gradle, or use the --im
age=<MY IMAGE> commandline flag.

Containerizing application to Docker daemon as micronaut-jib:0.1...
warning: Base image 'gcr.io/distroless/java' does not use a specific image digest - build may not be reproducible
Getting base image gcr.io/distroless/java...
Building dependencies layer...
Building resources layer...
Building classes layer...
Finalizing...

Container entrypoint set to [java, -cp, /app/resources:/app/classes:/app/libs/*, example.micronaut.Application]
Loading to Docker daemon...

Built image to Docker daemon as micronaut-jib:0.1

Jib membangun image Docker dengan berbagai lapisan: untuk dependensi, resource, dan kode yang dikompilasi. Misalnya, jika Anda memodifikasi kode, hanya lapisan dengan class yang telah dikompilasi yang akan dimodifikasi, sehingga menghemat waktu build dengan menggunakan kembali lapisan sebelumnya yang tidak disentuh.

Setelah image dibangun, mari periksa apakah kita dapat melihat pesan halo yang ramah tersebut, dengan menjalankan image Docker di tab pertama Cloud Shell:

$ docker run -it -p 8080:8080 micronaut-jib:0.1
16:57:20.255 [main] INFO  i.m.context.env.DefaultEnvironment - Established active environments: [cloud, gcp]
16:57:23.203 [main] INFO  io.micronaut.runtime.Micronaut - Startup completed in 2926ms. Server Running: http://97b7d76ccf3f:8080

Layanan kami sudah berjalan. Kini perintah curl dapat diluncurkan di tab Cloud Shell kedua, untuk melihat apakah perintah tersebut berfungsi seperti yang diharapkan:

$ curl localhost:8080/hello
Hello World

Anda dapat menghentikan container dengan menekan Ctrl+C di Cloud Shell.

7. Mengirim layanan dalam container ke registry

Setelah image berfungsi sebagaimana mestinya, Anda dapat mengirimnya ke Google Container Registry, yakni repositori pribadi untuk image Docker yang dapat diakses dari setiap project Google Cloud (tetapi juga dari luar Google Cloud Platform).

Sebelum dapat mengirim ke registry, pastikan Container Registry diaktifkan untuk project kita dengan membuka Alat > dengan Container Registry. Jika tidak diaktifkan, Anda akan melihat dialog berikut, lalu klik "Enable Container Registry API" untuk mengaktifkannya:

Setelah registry siap, jalankan perintah berikut untuk mengirim image ke registry:

$ gcloud auth configure-docker
$ docker tag micronaut-jib:0.1 \
         gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.1
$ docker push gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.1

Perintah di atas memungkinkan gcloud SDK mengonfigurasi dan memberikan otorisasi kepada Docker untuk mengirim image ke instance Container Registry Anda, memberi tag pada image agar mengarah ke lokasinya dalam registry, lalu mengirimkannya ke registry.

Jika semuanya berjalan lancar dan setelah beberapa saat, Anda akan dapat melihat image container yang tercantum di konsol: Tools > dengan Container Registry. Pada tahap ini, Anda sekarang memiliki image Docker lingkup project yang tersedia dan dapat diakses dan diorkestrasi oleh Kubernetes seperti yang akan Anda lihat dalam beberapa menit.

Perlu diperhatikan bahwa meskipun di sini kita menggunakan domain generik untuk registry (gcr.io), Anda juga dapat lebih spesifik dalam memilih zona dan bucket yang akan digunakan. Detailnya didokumentasikan di sini: https://cloud.google.com/container-registry/docs/#pushing_to_the_registry

8. Membuat cluster

Baiklah. Anda sekarang siap untuk membuat cluster Kubernetes Engine. Namun, sebelum itu, buka bagian Google Kubernetes Engine pada konsol web dan tunggu hingga sistem melakukan inisialisasi (proses ini hanya memerlukan waktu beberapa detik).

Cluster terdiri atas server API master Kubernetes yang dikelola oleh Google dan sekumpulan node pekerja. Worker node adalah virtual machine Compute Engine. Mari kita gunakan CLI gcloud dari sesi CloudShell Anda untuk membuat cluster dengan dua node n1-standard-1 (proses ini perlu waktu beberapa menit):

$ gcloud container clusters create hello-cluster \
  --num-nodes 2 \
  --machine-type n1-standard-1 \
  --zone us-central1-c

Pada akhirnya, Anda akan melihat cluster yang dibuat.

Creating cluster hello-cluster in us-central1-c...done.
Created [https://container.googleapis.com/v1/projects/mn-gke-test/zones/us-central1-c/clusters/hello-cluster].
To inspect the contents of your cluster, go to: https://console.cloud.google.com/kubernetes/workload_/gcloud/us-central1-c/hello-cluster?project=mn-gke-test
kubeconfig entry generated for hello-cluster.
NAME           LOCATION       MASTER_VERSION  MASTER_IP       MACHINE_TYPE   NODE_VERSION  NUM_NODES  STATUS
hello-cluster  us-central1-c  1.9.7-gke.7     35.239.224.115  n1-standard-1  1.9.7-gke.7   2          RUNNING

Atau, Anda dapat membuat cluster ini melalui Konsol yang ditampilkan di atas: Compute > Kubernetes Engine > Cluster Container > Buat cluster container.

Anda dapat membuat cluster di Zona lain, tetapi sebaiknya simpan cluster tersebut di region yang sama dengan bucket penyimpanan yang digunakan oleh container registry (lihat langkah sebelumnya).

Sekarang Anda memiliki cluster Kubernetes yang berfungsi penuh dan didukung oleh Google Kubernetes Engine:

Sekarang saatnya men-deploy aplikasi dalam container Anda sendiri ke cluster Kubernetes. Mulai sekarang, Anda akan menggunakan command line kubectl (sudah disiapkan di lingkungan Cloud Shell Anda). Bagian lainnya dari codelab ini mengharuskan versi klien dan server Kubernetes 1.2 atau yang lebih baru. kubectl version akan menunjukkan versi perintah saat ini.

9. Men-deploy aplikasi Anda ke Kubernetes

Deployment Kubernetes dapat membuat, mengelola, dan menskalakan beberapa instance aplikasi menggunakan image container yang baru saja Anda buat. Mari kita buat deployment aplikasi Anda ke Kubernetes menggunakan perintah kubectl create deployment:

$ kubectl create deployment hello-micronaut \
  --image=gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.1

Untuk melihat deployment yang baru saja dibuat, cukup jalankan:

$ kubectl get deployments
NAME              DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-micronaut   1         1         1            1           5m

Untuk melihat instance aplikasi yang dibuat oleh deployment, jalankan perintah ini:

$ kubectl get pods
NAME                               READY     STATUS    RESTARTS   AGE
hello-micronaut-5647fb98c5-lh5h7   1/1       Running   0          5m

Pada tahap ini, container Anda seharusnya berjalan di bawah kendali Kubernetes, tetapi Anda masih harus membuatnya dapat diakses oleh dunia luar.

10. Izinkan traffic eksternal

Secara default, pod hanya dapat diakses oleh IP internalnya di dalam cluster. Agar container hello-micronaut dapat diakses dari luar jaringan virtual kubernetes, Anda harus mengekspos pod sebagai layanan kubernetes.

Dari Cloud Shell, Anda dapat mengekspos pod ke internet publik dengan perintah kubectl expose yang dikombinasikan dengan flag --type=LoadBalancer. Tanda ini diperlukan untuk pembuatan IP yang dapat diakses secara eksternal :

$ kubectl expose deployment hello-micronaut --type=LoadBalancer --port=8080

Tanda yang digunakan dalam perintah ini menentukan bahwa Anda akan menggunakan load balancer yang disediakan oleh infrastruktur dasar (dalam hal ini Load Balancer Compute Engine). Perhatikan bahwa Anda mengekspos deployment, bukan pod secara langsung. Hal ini akan menyebabkan layanan yang dihasilkan melakukan load balancing terhadap traffic di semua pod yang dikelola oleh deployment (dalam hal ini hanya 1 pod, tetapi Anda akan menambahkan lebih banyak replika nanti).

Master Kubernetes membuat load balancer dan aturan penerusan Compute Engine, kumpulan target, dan aturan firewall terkait agar layanan dapat diakses sepenuhnya dari luar Google Cloud Platform.

Untuk menemukan alamat IP layanan yang dapat diakses publik, cukup minta kubectl untuk mencantumkan semua layanan cluster:

$ kubectl get services
NAME              TYPE           CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
hello-micronaut   LoadBalancer   10.39.243.251   aaa.bbb.ccc.ddd 8080:30354/TCP   1m
kubernetes        ClusterIP      10.39.240.1     <none>          443/TCP          31m

Mungkin perlu waktu beberapa menit hingga EXTERNAL-IP tersedia dan terlihat. Jika EXTERNAL-IP tidak ada, tunggu beberapa menit dan coba lagi.

Perlu diperhatikan bahwa ada 2 alamat IP yang tercantum untuk layanan Anda, keduanya adalah port yang melayani 8080. Salah satunya adalah IP internal yang hanya terlihat di dalam jaringan virtual cloud Anda; satu lagi adalah IP eksternal dengan {i>load balanced<i}. Dalam contoh ini, alamat IP eksternalnya adalah aaa.bbb.ccc.ddd.

Sekarang Anda dapat menjangkau layanan dengan mengarahkan browser Anda ke alamat ini: http://<EXTERNAL_IP>:8080/hello

11. Meningkatkan skala layanan Anda

Salah satu fitur canggih yang ditawarkan oleh Kubernetes adalah kemudahan untuk menskalakan aplikasi Anda. Misalkan tiba-tiba Anda memerlukan lebih banyak kapasitas untuk aplikasi Anda; Anda cukup memberi tahu pengontrol replikasi untuk mengelola jumlah replika baru untuk instance aplikasi Anda:

$ kubectl scale deployment hello-micronaut --replicas=3
deployment.extensions "hello-micronaut" scaled

$ kubectl get deployment
NAME              DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-micronaut   3         3         3            3           16m

Perhatikan pendekatan deklaratif di sini — daripada memulai atau menghentikan instance baru, Anda harus mendeklarasikan berapa banyak instance yang harus berjalan sepanjang waktu. Loop rekonsiliasi Kubernetes hanya memastikan bahwa realitas sesuai dengan yang Anda minta dan mengambil tindakan jika diperlukan.

12. Meluncurkan upgrade ke layanan Anda

Pada titik tertentu, aplikasi yang telah Anda deploy ke produksi akan memerlukan perbaikan bug atau fitur tambahan. Kubernetes hadir untuk membantu Anda men-deploy versi baru ke produksi tanpa memengaruhi pengguna.

Pertama, mari kita ubah aplikasinya. Buka editor kode dari Cloud Shell.

Buka /jib/examples/micronaut/src/main/groovy/example/micronaut/HelloController.groovy, dan perbarui nilai respons:

@Controller("/hello")
class HelloController {
    @Get("/")
    String index() {
        "Hello Kubernetes World"
    }
}

Pada /jib/examples/micronaut/build.gradle, kami akan mengupgrade versi gambar dari 0.1 ke 0.2 dengan memperbarui baris ini:

version '0.2'

Kemudian, bangun ulang dan paketkan aplikasi dengan perubahan terbaru:

$ ./gradlew jibDockerBuild

Kemudian, beri tag dan kirim image ke dalam registry image container:

$ docker tag micronaut-jib:0.2 \
         gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.2
$ docker push gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.2

Membangun dan mengirim image yang diupdate ini akan berjalan lebih cepat karena kami memanfaatkan penyimpanan cache sepenuhnya.

Sekarang Anda siap untuk Kubernetes mengupdate pengontrol replikasi ke versi baru aplikasi dengan lancar. Agar dapat mengubah label gambar untuk container yang sedang berjalan, Anda harus mengedit hello-micronaut deployment yang ada dan mengubah gambar dari gcr.io/PROJECT_ID/micronaut-jib:0.1 menjadi gcr.io/PROJECT_ID/micronaut-jib:0.2.

Anda dapat menggunakan perintah kubectl set image untuk meminta Kubernetes men-deploy versi baru aplikasi Anda di seluruh cluster satu instance dalam satu waktu dengan update berkelanjutan:

$ kubectl set image deployment/hello-micronaut \
          micronaut-jib=gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.2

deployment.apps "hello-micronaut" image updated

Selama masalah ini terjadi, pengguna layanan mungkin akan mengalami gangguan. Namun, hal itu terjadi karena tidak ada health check yang dikonfigurasi. Ini adalah konfigurasi yang sedikit lebih canggih — kita tidak akan menambahkan health check di lab ini.

Periksa http://EXTERNAL_IP:8080 lagi untuk melihat apakah URL tersebut menampilkan respons baru.

13. Kembalikan

Ups — apakah Anda membuat kesalahan dengan versi aplikasi yang baru? Mungkin versi baru berisi error dan Anda perlu melakukan rollback dengan cepat. Dengan Kubernetes, Anda dapat melakukan roll back ke status sebelumnya dengan mudah. Mari kita rollback aplikasi dengan menjalankan:

$ kubectl rollout undo deployment/hello-micronaut

Jika Anda melihat output layanan ini, kita akan kembali ke "Hello World" (Halo Dunia) awal untuk membuat pesan email baru.

14. Ringkasan

Pada langkah ini, Anda menyiapkan layanan hello world Micronaut sederhana berbasis Apache Groovy dan menjalankannya langsung dari dalam Cloud Shell, memaketkannya sebagai container dengan Jib, dan men-deploy-nya ke Google Kubernetes Engine.

15. Selamat!

Anda telah mempelajari cara membangun dan men-deploy microservice berbasis web Apache Groovy / Micronaut baru ke Kubernetes di Google Kubernetes Engine.

Pelajari Lebih Lanjut

• Dokumentasi dan contoh Jib: https://github.com/GoogleContainerTools/jib/
• Situs Micronaut: http://micronaut.io/
• Java di Google Cloud Platform: https://cloud.google.com/java/
• Untuk contoh Java: https://cloud.google.com/java/samples
• Untuk tutorial Kubernetes yang lebih panjang dan lengkap, lihat bit.ly/k8s-lab untuk mempelajari cara men-deploy aplikasi full-stack.

Lisensi

Karya ini dilisensikan berdasarkan Lisensi Umum Creative Commons Attribution 2.0.