Kubernetes adalah perangkat lunak sumber terbuka yang mengotomatiskan penyebaran, manajemen, dan penskalaan aplikasi kontainer. Ini mengatur kluster mesin virtual, menjadwalkan kontainer, dan menyediakan pemulihan mandiri, penyeimbangan beban, dan portabilitas di seluruh lingkungan.
Kubernetes adalah perangkat lunak sumber terbuka yang digunakan DevOps untuk menyebarkan, mengelola, dan menskalakan kontainer di seluruh kluster. Docker—teknologi sumber terbuka lainnya—adalah format file kontainer default yang umumnya digunakan bersama dengan Kubernetes.
Kontainer mengemas aplikasi dengan dependensi dan konfigurasinya sehingga dapat berjalan secara konsisten di lingkungan yang berbeda. Seiring berkembangnya aplikasi, Anda mungkin menjalankan banyak kontainer di berbagai server—dan mengoordinasikan semua itu secara manual menjadi rumit. Kubernetes mengatasi kerumitan dengan API sumber terbuka dan sistem kontrol yang menentukan apa yang harus dijalankan di mana, lalu menjaganya tetap berjalan.
Kubernetes mengatur kluster mesin virtual dan menjadwalkan kontainer untuk dijalankan berdasarkan sumber daya komputasi yang tersedia dan kebutuhan sumber daya setiap kontainer.
Kubernetes mengelola penemuan layanan dan penyeimbangan beban sehingga lalu lintas dapat dirutekan ke Pod yang tepat, meskipun Pod berubah seiring waktu.
Kubernetes menskalakan beban kerja berdasarkan penggunaan komputasi dan status yang Anda tetapkan.
Kubernetes memeriksa kesehatan sumber daya dan dapat memulai ulang atau mereplikasi kontainer saat masalah terjadi. Ini memulai ulang atau mengganti kontainer yang gagal dan menahan lalu lintas hingga beban kerja siap.
Kubernetes mendukung pola penyebaran untuk menjalankan aplikasi, termasuk rollout dan rollback otomatis berdasarkan status yang Anda jelaskan.
Kubernetes menyediakan manajemen rahasia dan konfigurasi untuk informasi sensitif seperti kata sandi atau token.
Kubernetes dapat memasang sistem penyimpanan yang Anda pilih (misalnya, penyimpanan lokal atau opsi cloud publik), berdasarkan model orkestrasi penyimpanan Kubernetes.
Kubernetes dibuat di sekitar objek API—sumber daya yang Anda deklarasikan dan kelola. Berikut adalah beberapa:
Pod: Unit dasar yang menjalankan satu atau beberapa kontainer.
Layanan: Cara stabil untuk memaparkan aplikasi dan merutekan lalu lintas ke Pod yang berubah.
Penyebaran: Cara untuk menjelaskan status aplikasi yang diinginkan dan memperbaruinya seiring waktu (sering kali terkait dengan rollout dan rollback).
Node: Mesin di kluster tempat Pod berjalan.
Sarana kontrol: Komponen yang mengelola status kluster dan keputusan penjadwalan.
Anda mendeklarasikan status yang diinginkan untuk aplikasi Anda (apa yang harus berjalan, jumlah salinan, kebutuhan sumber daya).
Sarana kontrol mencatat dan menindaklanjuti permintaan tersebut melalui API Kubernetes dan penyimpanan pendukung.
Penjadwal menempatkan Pod di node yang memiliki sumber daya yang memadai.
Komponen node menjalankan beban kerja.
Pengontrol terus melakukan rekonsiliasi agar status aktual sesuai dengan status yang diinginkan—menskalakan, mengganti, dan memperbarui beban kerja sesuai kebutuhan.
Kluster Kubernetes biasanya dideskripsikan dalam dua bagian: sarana kontrol yang mengelola kluster, dan node pekerja yang menjalankan beban kerja Anda.
Komponen ini mengelola status kluster secara keseluruhan:
kube-apiserver: Memaparkan API HTTP Kubernetes (Front Door untuk permintaan).
etcd: Penyimpanan kunci-nilai dengan konsistensi dan ketersediaan tinggi untuk data kluster.
kube-scheduler: Menemukan Pod yang memerlukan penempatan dan menetapkannya ke node.
kube-controller-manager: Menjalankan pengontrol yang merekonsiliasi status aktual ke status yang diinginkan.
cloud-controller-manager (opsional): Menyambungkan Kubernetes ke logika kontrol khusus penyedia cloud.
Setiap node pekerja menjalankan perangkat lunak yang memelihara Pod dan aturan jaringan:
kubelet: Memastikan Pod berjalan di node, termasuk kontainernya.
kube-proxy (opsional): Mempertahankan aturan jaringan untuk mendukung layanan.
runtime kontainer: Menjalankan kontainer di node.
Kubernetes tidak menjadwalkan kontainer individu secara langsung dalam abstrak. Kubernetes mengelompokkan satu atau beberapa kontainer ke dalam Pod, yang menjadi unit operasional dasar. Pod kemudian diskalakan naik atau turun menuju status yang diinginkan yang Anda tentukan.
Secara praktik, ini berarti:
Anda menjelaskan aplikasi yang ingin Anda jalankan.
Kubernetes menjadwalkan Pod ke mesin yang memiliki komputasi yang tersedia.
Pengontrol menjaga kluster tetap bergerak menuju status yang Anda minta.
Pod dapat muncul dan menghilang, sehingga Kubernetes menyediakan primitif—blok pembangun dasar yang Anda gabungkan untuk mendeskripsikan dan menjalankan aplikasi di kluster—yang menawarkan cara stabil untuk menjangkau beban kerja.
Setiap Pod mendapat alamat IP unik di seluruh kluster, dan Pod dapat berkomunikasi lintas node tanpa terjemahan alamat jaringan (NAT) dalam model jaringan Kubernetes.
API Layanan menyediakan alamat IP yang stabil atau nama host untuk rangkaian Pod backend, bahkan saat Pod individu berubah seiring waktu.
Kubernetes memelihara objek potongan titik akhir untuk melacak Pod mana yang saat ini mendukung sebuah layanan.
Untuk mengekspos layanan ke klien di luar kluster, Kubernetes mendukung Gateway API (dan ingress sebagai pendahulunya).
Beberapa lingkungan dapat memaparkan layanan secara eksternal menggunakan tipe layanan LoadBalancer.
Kluster Kubernetes sering kali menyertakan add-on yang memperluas fungsionalitas di luar komponen inti. Contoh meliputi:
DNS untuk resolusi nama di seluruh kluster.
UI Web (dasbor) untuk manajemen kluster.
Pemantauan sumber daya kontainer untuk pengumpulan metrik.
Pengelogan tingkat kluster untuk mengumpulkan log secara terpusat.
Kubernetes menjalankan aplikasi kontainer di kluster mesin dan menyimpannya dalam status yang dideskripsikan. Hal ini dilakukan dengan menempatkan pekerjaan di mesin yang tepat, merutekan lalu lintas ke tempat yang tepat, serta mengawasi kegagalan dan perubahan.
Sebagian besar beban kerja Kubernetes dimulai dengan “status yang diinginkan” yang dideklarasikan (apa yang harus dijalankan, jumlah salinan, dan cara memaparkannya). Kubernetes dibangun mengikuti konfigurasi deklaratif dan otomatisasi.
Kubernetes menjadwalkan kontainer ke mesin di kluster berdasarkan sumber daya komputasi yang tersedia dan kebutuhan setiap kontainer. Kontainer berjalan di dalam Pod, yaitu unit yang ditempatkan Kubernetes di mesin.
Pengontrol mengawasi kluster dan bekerja untuk mendekatkan status saat ini ke status yang diinginkan, menggunakan server API untuk membuat perubahan.
Penjadwalan adalah “di mana hal ini harus dijalankan?” keputusan.
Kubernetes mengelompokkan kontainer ke dalam Pod, lalu menempatkan Pod tersebut di mesin.
Kube-scheduler mencari Pod yang belum ditetapkan dan memilih node untuknya.
Di setiap node, kubelet memastikan Pod berjalan (termasuk kontainernya).
Kontainer dan Pod dapat dibuat, dipindahkan, atau diganti, sehingga aplikasi memerlukan cara yang stabil untuk menemukan satu sama lain.
Kubernetes mengelola penemuan layanan dan menggunakan penyeimbangan beban sehingga lalu lintas dapat dirutekan, meskipun Pod berubah seiring waktu.
API Layanan menyediakan alamat IP yang stabil atau nama host untuk layanan yang didukung oleh satu atau beberapa Pod, dan Kubernetes melacak Pod pendukung melalui objek EndpointSlice.
Saat Pod di balik layanan berubah, perutean layanan beradaptasi sehingga lalu lintas terus mencapai backend saat ini.
Kubernetes dapat menskalakan beban kerja ke status yang Anda tetapkan, termasuk penskalaan berdasarkan pemanfaatan komputasi.
Ide penskalaan umum meliputi:
Lebih banyak replika (lebih banyak Pod) untuk menangani permintaan yang lebih tinggi.
Lebih sedikit replika saat permintaan turun.
Pelacakan sumber daya sehingga keputusan penempatan mencerminkan kebutuhan CPU dan memori.
Ini kembali ke model “status yang diinginkan”: Anda menentukan targetnya, dan pengontrol terus bekerja mencapai target tersebut.
Kubernetes mencakup perilaku pemulihan mandiri yang bertujuan untuk memelihara kesehatan dan ketersediaan beban kerja. Jenis ini meliputi:
Memulai ulang kontainer yang gagal (mulai ulang tingkat kontainer).
Mengganti Pod yang gagal untuk menyimpan jumlah replika yang diminta (penggantian replika).
Menjadwalkan ulang beban kerja saat node tidak tersedia.
Menghapus Pod yang gagal dari titik akhir layanan sehingga lalu lintas hanya menuju ke Pod yang sehat (penyeimbangan beban untuk layanan).
Pemulihan mandiri memeriksa kesehatan kontainer dan memulai ulang atau mereplikasinya saat masalah terjadi.
Indikator kinerja utama (KPI, atau metrik) digunakan untuk memahami kesehatan kluster dan perilaku beban kerja.
Komponen sistem Kubernetes mengeluarkan metrik (format Prometheus) yang berguna untuk dasbor dan peringatan.
Metrik biasanya tersedia di titik akhir HTTP komponen/metrik, termasuk komponen seperti kube-apiserver, kube-scheduler, kubelet, kube-proxy, dan kube-controller-manager.
Sinyal kesehatan kluster (metrik dan pola kesalahan tingkat komponen)
Stabilitas beban kerja (misalnya, mulai ulang atau penggantian yang sering)
Tekanan kapasitas (alokasi vs. permintaan sumber daya, terkait dengan keputusan penskalaan)
Pemantauan memberi tim pandangan yang lebih lengkap tentang sumber daya kluster, Kubernetes API, kontainer, dan log, sehingga memperpendek perulangan umpan balik antara masalah dan perbaikan.
Kubernetes sering dipilih ketika tim memerlukan cara yang konsisten untuk menjalankan banyak kontainer di berbagai mesin, dengan tetap membiarkan perutean lalu lintas, penskalaan, dan pemulihan ditangani oleh platform.
Kubernetes dapat menskalakan beban kerja, yaitu memperbesar atau memperkecil seiring permintaan berubah, terhadap status target dan dapat menskalakan berdasarkan pemanfaatan komputasi.
Aplikasi web dengan lalu lintas variabel (kampanye, puncak musiman): Sesuaikan replika seiring beban berubah.
Pemrosesan batch atau berbasis peristiwa: Tambahkan kapasitas saaat terjadi lonjakan, lalu skalakan turun kembali.
Layanan mikro: Skalakan layanan tertentu tanpa menskalakan seluruh aplikasi.
Kubernetes mendukung pengemasan bin otomatis, yang menempatkan kontainer di node berdasarkan CPU dan kebutuhan memori untuk memanfaatkan sumber daya yang tersedia dengan lebih baik. Aplikasi ini juga melacak alokasi sumber daya saat mengelola beban kerja.
Kluster bersama untuk beberapa tim: Kurangi kapasitas yang terbuang dengan menempatkan beban kerja di lokasi sumber daya tersedia.
Kluster beban kerja campuran (layanan plus pekerjaan): Jaga node tetap sibuk tanpa penempatan manual.
Kubernetes dapat memaparkan beban kerja menggunakan DNS atau alamat IP, dan dapat mendistribusikan lalu lintas jaringan agar penyebaran tetap stabil. Layanan ini juga mengelola penemuan layanan dan menggunakan penyeimbang beban saat beban kerja berubah.
Komunikasi layanan mikro: Layanan menemukan satu sama lain melalui nama yang stabil saat Pod berubah.
API internal di balik titik akhir yang stabil: Rutekan lalu lintas hanya ke backend saat ini.
Kubernetes dirancang untuk mengganti kontainer yang gagal, menjadwalkan ulang beban kerja saat node tidak tersedia, dan mempertahankan status yang diinginkan. Contohnya meliputi mulai ulang kontainer, penggantian replika, dan penghapusan Pod yang tidak sehat dari titik akhir layanan sehingga lalu lintas hanya menuju ke Pod yang sehat.
Layanan yang selalu aktif: Hidupkan ulang atau ganti instans yang gagal tanpa intervensi manual.
Kluster dengan churn node yang sering terjadi: Jadwalkan ulang beban kerja saat node mengalami gangguan.
Layanan di balik layanan: Hentikan perutean lalu lintas ke Pod yang tidak sehat.
Kubernetes mendukung rollout dan rollback otomatis. Anda menjelaskan status yang diinginkan dan Kubernetes akan memindahkan status aktual ke sana dengan laju dikontrol.
Pembaruan aplikasi yang sering dilakukan: Terapkan perubahan secara bertahap, lalu kembalikan jika diperlukan.
Tim yang mengirimkan beberapa layanan: Jaga mekanisme rilis tetap konsisten di seluruh aplikasi.
Aplikasi terkontainerisasi terpisah dari infrastruktur, dan Kubernetes membantu memindahkannya dari mesin lokal ke produksi di seluruh lingkungan lokal, tanpa server, cloud hibrid, dan multicloud sekaligus menjaga konsistensi di seluruh lingkungan.
Paritas dev/test/prod: Pertahankan model pengemasan dan penjadwalan yang sama di seluruh lingkungan.
Penerapan hibrid: Jalankan sebagian sistem di lokal dan sebagian di cloud dengan pendekatan orkestrasi yang sama.
Kubernetes menyediakan cara umum untuk menjalankan beban kerja terkontainerisasi dengan konfigurasi deklaratif dan otomatisasipembelajaran mesin, yang didukung oleh serangkaian alat serta dukungan komunitas yang besar dan berkembang.
Karena sistem build tim terdiri dari banyak layanan, beban kerja singkat, dan pembaruan yang sering dilakukan, Kubernetes tetap menjadi fondasi praktis karena berfokus pada operasi yang dapat diulang:
Operasi yang konsisten di seluruh lingkungan (kontainer yang dipaketkan dengan dependensi, dijalankan dengan cara yang sama di seluruh lingkungan).
Ekosistem yang luas dan aktif dengan layanan, dukungan, dan alat yang tersedia secara luas.
Ekstensibilitas melalui add-on, plugin, dan program kesesuaian yang dibuat komunitas yang menjaga API inti tetap konsisten di seluruh versi.
Jika Anda membuat atau menjalankan beban kerja, Azure Kubernetes Service (AKS) membantu Anda menyebarkan dan mengelola aplikasi yang terkontainerisasi, dengan Azure yang mengelola sarana kontrol.
Dapatkan aplikasi seluler Azure 
