From f9ef26b8d200c1872948e4dbb15cdbcc45ba7b0f Mon Sep 17 00:00:00 2001 From: Giri Kuncoro Date: Sun, 12 Apr 2020 15:49:37 +0700 Subject: [PATCH] Translate scheduler performance tuning into bahasa indonesia --- .../scheduling/scheduler-perf-tuning.md | 160 ++++++++++++++++++ 1 file changed, 160 insertions(+) create mode 100644 content/id/docs/concepts/scheduling/scheduler-perf-tuning.md diff --git a/content/id/docs/concepts/scheduling/scheduler-perf-tuning.md b/content/id/docs/concepts/scheduling/scheduler-perf-tuning.md new file mode 100644 index 0000000000..11f9a23077 --- /dev/null +++ b/content/id/docs/concepts/scheduling/scheduler-perf-tuning.md @@ -0,0 +1,160 @@ +--- +title: Penyetelan Kinerja Penjadwal +content_template: templates/concept +weight: 70 +--- + +{{% capture overview %}} + +{{< feature-state for_k8s_version="v1.14" state="beta" >}} + +[kube-scheduler](/docs/concepts/scheduling/kube-scheduler/#kube-scheduler) +merupakan penjadwal (_scheduler_) Kubernetes bawaan yang bertanggung jawab +terhadap penempatan Pod-Pod pada seluruh Node di dalam sebuah klaster. + +Node-Node di dalam klaster yang sesuai dengan syarat-syarat penjadwalan dari +sebuah Pod disebut sebagai Node-Node layak (_feasible_). Penjadwal mencari Node-Node +layak untuk sebuah Pod dan kemudian menjalankan fungsi-fungsi untuk menskor Node-Node tersebut, memilih sebuah Node dengan skor tertinggi di antara +Node-Node layak lainnya, di mana Pod akan dijalankan. Penjadwal kemudian memberitahu +API server soal keputusan ini melalui sebuah proses yang disebut _Binding_. + +Laman ini menjelaskan optimasi penyetelan (_tuning_) kinerja yang relevan +untuk klaster Kubernetes berskala besar. + +{{% /capture %}} + +{{% capture body %}} + +Pada klaster berskala besar, kamu bisa menyetel perilaku penjadwal +untuk menyeimbangkan hasil akhir penjadwalan antara latensi (seberapa cepat Pod-Pod baru ditempatkan) +dan akurasi (seberapa akurat penjadwal membuat keputusan penjadwalan yang tepat). + +Kamu bisa mengonfigurasi setelan ini melalui pengaturan `percentageOfNodesToScore` pada kube-scheduler. +Pengaturan KubeSchedulerConfiguration ini menentukan sebuah ambang batas untuk +penjadwalan Node-Node di dalam klaster kamu. + +### Pengaturan Ambang Batas + +Opsi `percentageOfNodesToScore` menerima semua angka numerik antara 0 dan 100. +Angka 0 adalah angka khusus yang menandakan bahwa kube-scheduler harus menggunakan +nilai bawaan. +Jika kamu mengatur `percentageOfNodesToScore` dengan angka di atas 100, kube-scheduler +akan membulatkan ke bawah menjadi 100. + +Untuk mengubah angkanya, sunting berkas konfigurasi kube-scheduler (biasanya `/etc/kubernetes/config/kube-scheduler.yaml`), +lalu _ulang kembali_ kube-scheduler. + +Setelah kamu selesai menyunting, jalankan perintah +```bash +kubectl get componentstatuses +``` +untuk memverifikasi komponen kube-scheduler berjalan dengan baik (_healthy_). Keluarannya kira-kira seperti ini: +``` +NAME STATUS MESSAGE ERROR +controller-manager Healthy ok +scheduler Healthy ok +... +``` + +## Ambang Batas Penskoran Node {#persentase-penskoran-node} + +Untuk meningkatan kinerja penjadwalan, kube-scheduler dapat berhenti mencari +Node-Node yang layak saat sudah berhasil menemukannya. Pada klaster berskala besar, +hal ini menghemat waktu dibandingkan dengan pendekatan awam yang mengecek setiap Node. + +Kamu bisa mengatur ambang batas untuk menentukan berapa banyak jumlah Node minimal yang dibutuhkan, sebagai +persentase bagian dari seluruh Node di dalam klaster kamu. kube-scheduler akan mengubahnya menjadi +bilangan bulat berisi jumlah Node. Saat penjadwalan, jika kube-scheduler mengidentifikasi +cukup banyak Node-Node layak untuk melewati jumlah persentase yang diatur, maka kube-scheduler +akan berhenti mencari Node-Node layak dan lanjut ke [fase penskoran] (/docs/concepts/scheduling/kube-scheduler/#kube-scheduler-implementation). + +[Bagaimana penjadwal mengecek Node](#bagaimana-penjadwal-mengecek-node) menjelaskan proses ini secara detail. + +### Ambang Batas Bawaan + +Jika kamu tidak mengatur sebuah ambang batas, maka Kubernetes akan +menghitung sebuah nilai menggunakan pendekatan linier, yaitu 50% untuk klaster dengan 100 Node, +serta 10% untuk klaster dengan 5000 Node. + +Artinya, kube-scheduler selalu menskor paling tidak 5% dari klaster kamu, terlepas dari +seberapa besar klasternya, kecuali kamu secara eksplisit mengatur `percentageOfNodesToScore` +menjadi lebih kecil dari 5. + +Jika kamu ingin penjadwal untuk memasukkan seluruh Node di dalam klaster ke dalam penskoran, +maka aturlah `percentageOfNodesToScore` menjadi 100. + +## Contoh + +Contoh konfigurasi di bawah ini mengatur `percentageOfNodesToScore` menjadi 50%. + +```yaml +apiVersion: kubescheduler.config.k8s.io/v1alpha1 +kind: KubeSchedulerConfiguration +algorithmSource: + provider: DefaultProvider + +... + +percentageOfNodesToScore: 50 +``` + + +## Menyetel percentageOfNodesToScore + +`percentageOfNodesToScore` merupakan angka 1 sampai 100 dengan +nilai bawaan yang dihitung berdasarkan ukuran klaster. Di sini juga terdapat +batas bawah yang telah ditetapkan, yaitu 50 Node. + +{{< note >}}Pada klaster dengan kurang dari 50 Node layak, penjadwal masih +terus memeriksa seluruh Node karena Node-Node layak belum mencukupi supaya +penjadwal dapat menghentikan proses pencarian lebih awal. + +Pada klaster kecil, jika kamu mengatur `percentageOfNodesToScore` dengan angka kecil, +pengaturan ini hampir atau sama sekali tidak berpengaruh, karena alasan yang sama. + +Jika klaster kamu punya ratusan Node, gunakan angka bawaan untuk opsi konfigurasi ini. +Mengubah angkanya kemungkinan besar tidak akan mengubah kinerja penjadwal secara berarti. +{{< /note >}} + +Sebuah catatan penting yang perlu dipertimbangkan saat mengatur angka ini adalah +ketika klaster dengan jumlah Node sedikit diperiksa untuk kelayakan, beberapa Node +tidak dikirim untuk diskor bagi sebuah Pod. Hasilnya, sebuah Node yang mungkin memiliki +nilai lebih tinggi untuk menjalankan Pod tersebut bisa saja tidak diteruskan ke fase penskoran. +Hal ini berdampak pada penempatan Pod yang kurang ideal. + +Kamu sebaiknya menghindari pengaturan `percentageOfNodesToScore` menjadi sangat rendah, +agar kube-scheduler tidak seringkali membuat keputusan penempatan Pod yang buruk. +Hindari pengaturan persentase di bawah 10%, kecuali _throughput_ penjadwal sangat penting +untuk aplikasi kamu dan skor dari Node tidak begitu penting. Dalam kata lain, kamu +memilih untuk menjalankan Pod pada Node manapun selama Node tersebut layak. + +## Bagaimana Penjadwal Mengecek Node + +Bagian ini ditujukan untuk kamu yang ingin mengerti bagaimana fitur ini bekerja secara internal. + +Untuk memberikan semua Node di dalam klaster sebuah kesempatan yang adil untuk +dipertimbangkan dalam menjalankan Pod, penjadwal mengecek Node satu persatu +secara _round robin_. Kamu dapat membayangkan Node-Node ada di dalam sebuah array. +Penjadwal mulai dari indeks array pertama dan mengecek kelayakan dari Node sampai +jumlahnya telah mencukupi sesuai dengan `percentageOfNodesToScore`. Untuk Pod berikutnya, +penjadwal melanjutkan dari indeks array Node yang terhenti ketika memeriksa +kelayakan Node-Node untuk Pod sebelumnya. + +Jika Node-Node berada di beberapa zona, maka penjadwal akan mengecek Node satu persatu +pada seluruh zona untuk memastikan bahwa Node-Node dari zona berbeda masuk dalam pertimbangan +kelayakan. Sebagai contoh, ada 6 Node di dalam 2 zona: + +``` +Zona 1: Node 1, Node 2, Node 3, Node 4 +Zona 2: Node 5, Node 6 +``` + +Penjadwal mempertimbangkan kelayakan dari Node-Node tersebut dengan urutan berikut: + +``` +Node 1, Node 5, Node 2, Node 6, Node 3, Node 4 +``` + +Setelah semua Node telah dicek, penjadwal akan kembali pada Node 1. + +{{% /capture %}}