Pendahuluan
Banyak developer memulai dengan satu server fisik untuk menjalankan aplikasi, database, dan berbagai layanan lainnya. Namun seiring bertambahnya pengguna, satu server sering kali tidak lagi cukup.
Masalahnya, tidak semua orang menggunakan layanan cloud yang dapat menambah server secara otomatis. Jika menggunakan server fisik di rumah atau di kantor, penambahan kapasitas tetap memerlukan tindakan manual seperti membeli perangkat baru, menghubungkannya ke jaringan, dan menyalakannya.
Kabar baiknya, proses tersebut dapat dibuat menjadi semi otomatis menggunakan K3s. Setelah server baru dinyalakan dan bergabung ke cluster, distribusi aplikasi dan load balancing dapat berjalan secara otomatis tanpa perlu mengubah konfigurasi satu per satu.
Artikel ini membahas konsep horizontal scaling semi otomatis menggunakan K3s dengan bahasa sederhana.
Apa Itu Horizontal Scaling?
Horizontal scaling adalah proses menambah jumlah server untuk menangani beban yang lebih besar.
Misalnya awalnya hanya ada satu server:
Internet
|
Load Balancer
|
Server 1
Ketika trafik meningkat, ditambahkan server kedua:
Internet
|
Load Balancer
|
+---------+
| Server 1|
| Server 2|
+---------+
Dengan cara ini beban kerja tidak lagi ditangani oleh satu mesin saja.
Mengapa Tidak Menggunakan Vertical Scaling?
Vertical scaling berarti meningkatkan spesifikasi server yang sudah ada.
Contoh:
- RAM 16 GB menjadi 32 GB
- CPU 8 Core menjadi 16 Core
Metode ini sederhana, tetapi memiliki batas.
Pada akhirnya akan ada titik di mana server tidak bisa ditingkatkan lagi atau biaya upgrade menjadi terlalu mahal.
Karena itu banyak sistem modern menggunakan horizontal scaling.
Apa Itu K3s?
K3s adalah distribusi Kubernetes yang ringan dan mudah digunakan.
Kubernetes sendiri adalah platform untuk mengelola container dalam jumlah besar. Namun Kubernetes standar cukup kompleks.
K3s dibuat agar lebih ringan sehingga cocok untuk:
- Homelab
- Server rumahan
- Mini PC
- Edge Computing
- Server kecil hingga menengah
Dengan K3s, beberapa server fisik dapat digabung menjadi satu cluster.
Arsitektur yang Direkomendasikan
Misalnya memiliki dua server fisik.
Internet
|
Traefik Load Balancer
|
+------------+
| K3s Cluster|
+------------+
|
+---------+ +---------+
| Node 1 | | Node 2 |
+---------+ +---------+
Node 1 dan Node 2 bekerja sebagai satu kesatuan.
Aplikasi dapat berjalan di salah satu node atau keduanya sekaligus.
Bagaimana Load Balancer Bekerja?
Load balancer bertugas membagi trafik ke beberapa instance aplikasi.
Misalnya ada empat instance aplikasi:
API-1
API-2
API-3
API-4
K3s dapat menempatkannya seperti berikut:
Node 1
API-1
API-2
Node 2
API-3
API-4
Ketika pengguna mengakses aplikasi:
Request 1 -> API-1
Request 2 -> API-2
Request 3 -> API-3
Request 4 -> API-4
Beban kerja tersebar secara merata.
Mengapa Disebut Semi Otomatis?
Karena penambahan server fisik masih dilakukan secara manual.
Langkah yang tetap harus dilakukan:
- Membeli server baru.
- Menghubungkan ke jaringan.
- Menyalakan perangkat.
Namun setelah server bergabung ke cluster, proses selanjutnya berjalan otomatis.
Kubernetes akan:
- Mengenali node baru.
- Menempatkan workload ke node baru.
- Membagi trafik secara otomatis.
- Menjaga jumlah replica aplikasi.
Inilah alasan disebut horizontal scaling semi otomatis.
Instalasi K3s pada Node Pertama
Misalnya server pertama memiliki IP:
192.168.1.10
Jalankan perintah berikut:
curl -sfL https://get.k3s.io | sh -
Setelah selesai, periksa node:
sudo kubectl get nodes
Hasilnya kurang lebih:
NAME STATUS
node-1 Ready
Node pertama sekarang berperan sebagai server utama cluster.
Mengambil Token Cluster
Token diperlukan agar node lain dapat bergabung.
Lihat token dengan:
sudo cat /var/lib/rancher/k3s/server/node-token
Simpan nilai token tersebut.
Menambahkan Node Kedua
Misalnya node kedua memiliki IP:
192.168.1.20
Pada node kedua jalankan:
curl -sfL https://get.k3s.io | K3S_URL=https://192.168.1.10:6443 K3S_TOKEN=TOKEN_ANDA sh -
Ganti TOKEN_ANDA dengan token yang diperoleh sebelumnya.
Periksa kembali dari node utama:
kubectl get nodes
Hasil:
NAME STATUS
node-1 Ready
node-2 Ready
Cluster sekarang memiliki dua node.
Deploy Aplikasi dengan Replica
Contoh deployment sederhana:
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-api
spec:
replicas: 4
selector:
matchLabels:
app: my-api
template:
metadata:
labels:
app: my-api
spec:
containers:
- name: my-api
image: my-api:latest
Perhatikan bagian:
replicas: 4
Artinya Kubernetes harus menjaga agar selalu ada empat instance aplikasi.
Distribusi Otomatis ke Beberapa Node
Misalnya tersedia dua node.
Kubernetes dapat menyebarkan pod seperti ini:
Node 1
Pod A
Pod B
Node 2
Pod C
Pod D
Jika salah satu node penuh, workload baru dapat ditempatkan ke node lainnya.
Apa yang Terjadi Saat Menambah Server Ketiga?
Misalnya beberapa bulan kemudian kapasitas mulai habis.
Anda membeli server baru dan menghubungkannya ke cluster.
Struktur berubah menjadi:
Node 1
Node 2
Node 3
Setelah node ketiga bergabung:
Node 1
Pod A
Node 2
Pod B
Node 3
Pod C
Pod D
Kubernetes mulai memanfaatkan kapasitas baru tersebut tanpa perlu mengubah konfigurasi load balancer secara manual.
Failover Sederhana
Misalnya Node 2 mati.
Sebelumnya:
Node 1
Pod A
Pod B
Node 2
Pod C
Pod D
Ketika Node 2 tidak tersedia:
Node 1
Pod A
Pod B
Pod C
Pod D
Kubernetes akan berusaha membuat ulang pod yang hilang selama kapasitas masih tersedia.
Ini membantu meningkatkan ketersediaan layanan.
Kapan Arsitektur Ini Cocok Digunakan?
Arsitektur K3s dengan horizontal scaling semi otomatis cocok untuk:
- Homelab.
- Startup kecil.
- Server rumahan.
- Internal company tools.
- API backend.
- Sistem berbasis container.
Pendekatan ini memberikan banyak manfaat Kubernetes tanpa kompleksitas cloud berskala besar.
Kesimpulan
Jika menggunakan server fisik sendiri, autoscaling penuh seperti layanan cloud tidak selalu memungkinkan karena perangkat baru tetap harus ditambahkan secara manual.
Namun dengan K3s, proses tersebut dapat dibuat semi otomatis. Setelah server baru bergabung ke cluster, Kubernetes akan mengelola distribusi aplikasi, replica, dan load balancing secara otomatis.
Hasilnya adalah sistem yang lebih mudah dikembangkan, lebih tahan terhadap peningkatan trafik, dan lebih siap untuk bertumbuh tanpa harus melakukan konfigurasi ulang setiap kali menambah server baru.