Objectives

• Belajar apa itu klaster Kubernetes.
• Belajar apa itu Minikube.
• Memulai klaster Kubernetes menggunakan terminal _online_.

Klaster Kubernetes

Kubernetes mengoordinasikan klaster komputer ketersediaan tinggi (_highly available_) yang saling terhubung sebagai unit tunggal. Abstraksi pada Kubernetes mengizinkan kamu untuk men-_deploy_ aplikasi terkemas (_containerized_) ke sebuah klaster tanpa perlu membalutnya secara spesifik pada setiap mesin. Untuk menggunakan model baru _deployment_ ini, aplikasi perlu dikemas dengan cara memisahkan mereka dari hos individu: mereka perlu dikemas. Aplikasi terkemas lebih fleksibel dan tersedia dibanding model _deployment_ lama, dimana aplikasi dipasang secara langsung didalam mesin spesifik sebagai paket yang sangat terintegrasi dengan hos. Kubernetes mengotomasisasikan distribusi dan penjadwalan kontainer aplikasi sebuah klaster secara menyeluruh dengan cara yang lebih efisien. Kubernetes merupakan platform _open-source_ dan siap produksi.

Klaster Kubernetes terdiri dari 2 tipe sumber daya:

• Master mengoordinasikan klaster
• Node adalah pekerja (_worker_) yang menjalankan aplikasi

Diagram Klaster

Master mempunyai kewajiban untuk mengelola klaster. Master mengoordinasikan semua aktifitas di klaster kamu, seperti penjadwalan aplikasi, pemeliharaan keadaan (_state_) aplikasi yang diinginkan, _scaling_ aplikasi, dan _roll-out_ pembaharuan.

Node merupakan VM atau komputer fisik yang berfungsi sebagai mesin pekerja dalam klaster Kubernetes. Setiap node mempunyai Kubelet, sebuah agen untuk mengatur Node dan komunikasi dengan Kubernetes master. Node juga harus mempunyai alat untuk menangani operasi kontainer, seperti Docker atau rkt. Sebuah klaster Kubernetes yang menangani trafik produksi harus mempunyai minimal 3 Node.

Ketika kamu men-_deploy_ aplikasi pada Kubernetes, kamu memberitahu master untuk memulai kontainer aplikasi. Master melakukan penjadwalan kontainer untuk berjalan diatas klaster Node. Node berkomunikasi dengan master menggunakan Kubernetes API, yang disediakan oleh master. Pengguna akhir juga dapat menggunakan Kubernetes API secara langsung untuk berinteraksi dengan klaster.

Klaster Kubernetes dapat di-_deploy_ ke mesik fisik maupun virtual. Untuk memulai pengembangan Kubernetes, kamu dapat menggunakan Minikube. Minikube merupakan implementasi Kubernetes ringan yang membuat VM padi mesin lokal kamu dan men-_deploy_ klaster sederhanya yang terdiri atas 1 Node. Minikube tersedia untuk Linux, macOS, dan sistem Windows. Minikube CLI menyediakan operasi _bootstraping_ dasar untuk bekerja dengan klaster kamu. Namun untuk tutorial ini, kamu akan menggunakan online terminal yang sudah disediakan dengan Minikube yang sudah diinstall sebelumnya.

Sekarang kamu telah mengetahui apa itu Kubernetes, mari kita pergi ke tutorial online dan memulai klaster pertama kita!

Tujuan

• Belajar tentang menyebarkan (deploy) aplikasi.
• Menyebarkan aplikasi pertama kamu di Kubernetes dengan kubectl.

Deployment Kubernetes

Ketika klaster Kubernetes kamu sudah berjalan, kamu dapat menyebarkan aplikasi terkontainerisasi di atasnya. Untuk melakukannya, kamu perlu membuat konfigurasi Deployment. Deployment menginstruksikan Kubernetes tentang bagaimana cara membuat dan memperbarui instance aplikasi kamu. Ketika kamu selesai membuat Deployment, Kubernetes control plane melakukan penjadwalan instance aplikasi yang terlibat dalam Deployment untuk berjalan di Node individu pada klaster.

Setelah instance aplikasi telah dibuat, Kubernetes Deployment Controller akan melakukan monitoring instance tersebut secara kontinu. Jika instance pada hos Node mati atau terhapus, Deployment Controller akan mengganti instance tersebut dengan instance Node lain dalam klaster. Ia menyediakan mekanisme penyembuhan diri (self-healing) untuk mengatasi kegagalan mesin atau pemeliharaan (maintenance)

Pada masa pra-orkestrasi, instalasi script sering digunakan untuk memulai aplikasi, namun cara ini tidak memberikan mekanisme pemulihan ketika terjadi kegagalan mesin. Dengan kemampuan membuat instance aplikasi dan menjaganya tetap berjalan pada Node, Deployment Kubernetes menyediakan manajemen aplikasi dengan pendekatan fundamental yang berbeda.

Menyebarkan aplikasi pertama kamu dalam Kubernetes

Kamu dapat membuat dan mengatur Deployment dengan menggunakan antar muka baris perintah (CLI) Kubernetes, Kubectl. Kubectl menggunakan Kubernetes API untuk berinteraksi dengan klaster. Pada modul ini, kamu akan belajar perintah-perintah yang sering digunakan Kubectl untuk membuat Deployment untuk menjalankan aplikasi kamu pada klaster Kubernetes.

Ketika kamu membuat Deployment, kamu perlu mendefinisikan Container image untuk aplikasi kamu dan jumlah replika yang kamu inginkan. Kamu dapat mengganti informasi tersebut nanti dengan melakukan pembaharuan Deployment kamu; Modul 5 dan 6 pada bootcamp ini mendiskusikan bagaimana cara melakukan perluasan (scale) dan pembaruan Deployment kamu.

Pada Deployment pertama kamu, kamu akan menggunakan aplikasi Node.js yang terkemas dalam Container Docker. (Jika kamu belum pernah mencoba membuat aplikasi Node.js dan menyebarkannya dengan Container, kamu dapat melakukannya dengan mengikuti instruksi pada tutorial Hello Minikube).

Sekarang kamu tahu apa itu Deployment, mari kita ke tutorial online dan menyebarkan aplikasi pertama kita!

Tujuan

• Belajar tentang Pod Kubernetes.
• Belajar tentang Node Kubernetes.
• Mengatasi masalah pada aplikasi-aplikasi yang digelar.

Pod Kubernetes

Ketika kamu membuat sebuah Deployment pada Modul 2, Kubernetes membuatkan sebuah Pod untuk menempatkan instans aplikasimu. Pod merupakan sebuah abstraksi Kubernetes yang merepresentasikan sebuah grup yang terdiri dari satu atau lebih kontainer (seperti Docker), dan beberapa sumber daya bersama untuk kontainer-kontainer itu. Sumber daya tersebut termasuk:

• Penyimpanan bersama, disebut Volume
• Jaringan, sebagai satu alamat IP klaster unik
• Informasi tentang bagaimana mejalankan tiap kontainer, seperti versi image atau porta spesifik yang digunakan oleh kontainer

Pod memodelkan sebuah "logical host" spesifik aplikasi dan dapat berisi beberapa kontainer aplikasi berbeda yang relatif terkait erat. Contohnya, sebuah Pod mungkin terdiri atas kontainer aplikasi Node.js dan juga kontainer berbeda yang bertugas menyediakan data untuk dipublikasikan ke server web Node.js. Kontainer-kontainer dalam sebuah Pod berbagi satu alamat IP dan ruang porta, selalu terletak bersama dan terjadwal bersama, dan berjalankan dalam satu konteks bersama (shared context) pada Node yang sama.

Pod merupakan unit terkecil dalam platform Kubernetes. Ketika kita membuat sebuat Deployment, Deployment tersebut membuat Pod dengan kontainer-kontainer di dalamnya (bukannya dengan membuat kontainer secara langsung). Tiap Pod terikat langsung dengan Node di mana dia dijadwalkan dan tetap di sana sampai diterminasi (berdasarkan restart policy) atau penghapusan. Jika terjadi kegagalan pada sebuah Node, Pod indentik akan dijadwalkan di Node lain dalam klaster.

Ikhtisar Pod

Node

Sebuah Pod selalu berjalan dalam sebuah Node. Node merupakan sebuah mesin pekerja (worker) di Kubernetes dan mungkin merupakan mesin virtual ataupun fisik, tergantung dari klaster. Tiap Node dikelola oleh control plane. Satu Node dapat memiliki beberapa Pod, dan control plane Kubernetes yang otomatis menangani penjadwalan pod seluruh Node-Node dalam klaster. Penjadwalan otomatis oleh control plane memperhitungkan tersedianya sumber daya tiap Node.

Tiap Node Kubernetes menjalankan setidaknya:

• Kubelet, satu proses yang bertanggung jawab untuk berkomunikasi antara control plane Kubernetes dan Node; ini juga mengelola Pod-Pod dan kontainer-kontainer yang berjalan di sebuah mesin.
• Satu container runtime, seperti Docker, bertanggung jawab untuk menarik image kontainer dari register, membuka kontainer, dan menjalankan aplikasi.

Ikhtisar Node

Mengatasi masalah dengan kubectl

Dalam Modul 2, kamu menggunakan antarmuka baris perintah kubectl. Kamu akan lanjut menggunakannya pada modul 3 untuk mendapatkan informasi tentang aplikasi-aplikasi yang digelar dan lingkungannya. Operasi yang paling umum dapat dilakukan dengan perintah kubectl berikut:

• kubectl get - melihat daftar sumber daya
• kubectl describe - menampilkan detil informasi tentang suatu sumber daya
• kubectl logs - mencetak log-log dari satu kontainer dalam sebuah Pod
• kubectl exec - eksekusi sebuah perintah pada satu kontainer dalam sebuah Pod

Kamu dapat menggunakan perintah ini kapan aplikasi-aplikasi digelar, apa status mereka saat ini, di mana mereka berjalan, dan apa konfigurasi mereka.

Sekarang karena kita lebih mengetahui tentang klaster kita dan baris perintahnya, mari kita menjelajah aplikasi kita.

Tujuan

• Belajar tentang Service di Kubernetes
• Memahami bagaimana label dan objek LabelSelector berhubungan dengan sebuah Service
• Mengekspos sebuah aplikasi keluar klaster Kubernetes menggunakan sebuah Service

Ikhtisar Service Kubernetes

Pod-Pod Kubernetes itu fana. Pod pada kenyataannya punya siklus hidup. Ketika sebuah Node pekerja mati, Pod yang berjalan dalam Node itu juga hilang. ReplicaSet mungkin kemudian secara dinamis mendorong klaster kembali ke keadaan yang diinginkan melalui penciptaan Pod baru untuk memastikan aplikasimu berjalan. Contoh lainnya, katakanlah ada backend pengolahan citra dengan 3 replika. Replika tersebut dapat ditukar; sistem front-end seharusnya tidak peduli tentang replika backend atau bahkan jika Pod hilang dan dibuat ulang. Walaupun demikian, tiap Pod dalam sebuah klaster Kubernetes memiliki alamat IP unik, meskipun Pod-Pod itu berada dalam satu Node yang sama, sehingga seharusnya ada jalan untuk mencocokan perubahan antara Pod-Pod itu sehingga aplikasimu tetap berfungsi.

Service di Kubernetes merupakan abstraksi yang mendefinisikan satu set Pod secara logis dan aturan untuk mengakses mereka. Service memungkinkan keterkaitan renggang antara Pod-Pod. Sebuah Service didefinisikan menggunakan YAML (lebih disukai) atau JSON, sebagaimana semua objek Kubernetes. Kumpulan Pod yang ditargetkan oleh Service biasanya ditentukan oleh LabelSelector (lihat di bawah mengapa kamu mungkin ingin Service tanpa selector dalam spec).

Meskipun tiap Pod memiliki alamat IP unik, IP tersebut tidak diekpos ke luar klaster tanpa sebuah Service. Service memperbolehkan aplikasimu untuk menerima kunjungan. Service dapat diekspos dengan cara yang berbeda menggunakan type di ServiceSpec:

• ClusterIP (bawaan) - Mengekspos Service dengan internal IP dalam klaster. Type ini membuat Service hanya bisa diakses dalam klaster.
• NodePort - Mengekspos Service dengan porta yang sama untuk tiap Node dalam klaster menggunakan NAT. Ini membuat Service dapat diakses dari luar dengan <NodeIP>:<NodePort>. Superset dari ClusterIP.
• LoadBalancer - Membuat load balancer eksternal di cloud saat ini (jika didukung) dan memberikan IP eksternal tetap kepada Service. Superset dari NodePort.
• ExternalName - Mengekpos Service menggunakan nama sesuai keinginan (ditentukan oleh externalName dalam spec) dengan mengembalikan catatan CNAME dengan nama tersebut. Tidak menggunakan proksi. Type ini membutuhkan kube-dns versi v1.7 atau lebih tinggi.

Informasi lebih tentang type Service berbeda dapat ditemukan di tutorial Menggunakan IP pengirim. Lihat juga Menghubungkan aplikasi dengan Service.

Selain itu, catat bahwa ada kasus penggunaan Service yang tidak mendefinisikan selector di spec. Sebuah Service yang dibuat tanpa selector juga tidak akan membuat objek Endpoint yang sesuai. Ini mengizinkan pengguna untuk memetakan Service secara manual ke endpoint spesifik. Kemungkinan lain kenapa dimungkinan tanpa selector adalah kamu dengan tegas menggunakan type: ExternalName.

Service dan Label

Service mengarahkan kunjungan melintasi sekumpulan Pod. Service merupakan abstraksi yang mengizinkan Pod-Pod untuk mati dan replikasi dalam Kubernetes tanpa memengaruhi aplikasimu. Menemukan dan routing antara Pod dependen (seperti komponen frontend dan backend) yang ditangani oleh Service Kubernetes.

Service mencocokan satu set Pod menggunakan label dan selektor, mengelompokan primitif yang mengizinkan operasi logika pada objek-objek dalam Kubernetes. Label adalah pasangan key/value yang melekat pada objek-objek dan dapat digunakan untuk beberapa tujuan:

• Menandai objek-objek untuk lingkungan development, test, dan production
• Melekatkan label versi
• Klasifikasi sebuah objek dengan label-label

Label-label dapat dilekatkan pada objek-objek pada waktu pembuatan ataupun setelahnya. Mereka dapat diubah kapanpun. Mari kita ekspos aplikasi kita sekarang dengan sebuah Service dan menerapkan beberapa label.

Tujuan

• Penyekalaan aplikasi menggunakan kubectl.

Penyekalaan sebuah Aplikasi

Di modul-modul sebelumnya kita telah membuat Deployment, dan mengeksposnya secara publik via Service. Deployment tersebut hanya membuat satu Pod untuk menjalankan aplikasi kita. Ketika kunjungan meningkat, kita perlu melakukan penyekalaan (scale) aplikasi kita untuk mengikuti tingkat permintaan pengguna.

Penyekalaan dapat dicapai dengan mengubah nilai replicas dalam Deployment

Ikhtisar Penyekalaan

Perluasan skala Deployment akan memastikan Pod baru dibuat dan dijadwalkan ke Node-Node dengan sumber daya yang tersedia. Penyekalaan akan meningkatkan jumlah Pod ke keadaan yang diinginkan. Kubernetes juga mendukung autoscaling Pod, tetapi itu di luar cakupan tutorial ini. Penyekalaan ke nol juga dimungkinkan, dan tindakan ini akan mengakhiri semua Pod pada Deployment tersebut.

Menjalankan beberapa instans dari aplikasi akan membutuhkan cara untuk mendistribusikan trafik ke semuanya. Service memiliki penyeimbang beban terintegrasi yang akan mendistribusikan trafik jaringan ke semua Pod dari sebuah Deployment yang diekspos. Service akan terus memonitor Pod-Pod yang berjalan menggunakan Endpoints, untuk memastikan trafik hanya dikirim ke Pod yang tersedia.

Sewaktu kamu memiliki multipel instans dari aplikasi yang berjalan, kamu akan bisa melakukan pembaruan bertahap tanpa henti. Kita akan akan membahas hal tersebut pada modul selanjutnya. Sekarang, mari kita pergi ke terminal daring dan melakukan penyekalaan terhadap aplikasi kita.

Tujuan

• Melakukan pembaruan bertahap (rolling update) menggunakan kubectl.

Memperbarui suatu aplikasi

Pengguna mengharapkan aplikasi tersedia sepanjang waktu dan pengembang bisa jadi diharapkan untuk men-deploy versi terbaru dari aplikasi tersebut beberapa kali dalam suatu waktu. Di Kubernetes hal ini dilakukan melalui pembaruan bertahap. Pembaruan bertahap memungkinkan pembaruan Deployment terjadi tanpa berhenti dengan memperbarui instans Pod secara bertahap dengan versi yang baru. Pod yang baru akan dijadwalkan pada Node dengan sumber daya yang tersedia.

Dalam modul sebelumnya kita telah melakukan penyekalaan aplikasi kita untuk menjalankan beberapa instans. Hal ini dibutuhkan untuk menjalankan pembaruan tanpa mempengaruhi ketersediaan aplikasi. Secara bawaan, jumlah maksimum dari Pod lama yang akan digantikan (menjadi tidak tersedia) selama pembaruan dan jumlah maksimum Pod baru yang dapat dibuat adalah satu. Kedua opsi ini dapat dikonfigurasi dengan angka atau persentase (dari Pod). Di Kubernetes, setiap pembaruan diberi versi masing-masing dan suatu pembaruan Deployment dapat dikembalikan ke versi sebelumnya (yang stabil).

Gambaran pembaruan bertahap

Seperti penyekalaan aplikasi, jika suatu Deployment terekspos secara publik, maka Service akan menyeimbangkan beban trafik hanya ke Pod yang tersedia saat pembaruan berlangsung. Pod yang tersedia adalah instans yang dapat diakses oleh pengguna aplikasi.

Pembaruan bertahap memungkinan dilakukannya aktivitas-aktivitas berikut:

• Mempromosikan suatu aplikasi dari satu environment yang ke environment yang lain (via pembaruan kontainer image)
• Kembali (rollback) ke versi-versi sebelumnya
• Continuous Integration dan Continuous Delivery (CI/CD) dari aplikasi tanpa henti

Pada tutorial interaktif berikut ini, kita akan mencoba untuk memperbarui aplikasi kita ke versi terbaru dan kemudian melakukan rollback.