Membangun Lingkungan Pengembangan Lokal Multi-Node Kubernetes dengan KubeVirt: Simulasi Cloud-Native Hybrid yang Realistis

1. Pendahuluan

Di era cloud-native saat ini, Kubernetes telah menjadi standar de facto untuk orkestrasi kontainer. Namun, realitanya banyak perusahaan masih memiliki aplikasi “legacy” yang berjalan di Virtual Machine (VM) dan tidak bisa langsung di-containerisasi. Tantangan muncul ketika kita perlu mengintegrasikan atau bahkan memigrasikan aplikasi VM ini ke dalam ekosistem Kubernetes, terutama saat mengembangkan dan mengujinya di lingkungan lokal. Bagaimana kita bisa mensimulasikan arsitektur hybrid cloud (VM + kontainer) di laptop kita? 🤔

Di sinilah KubeVirt datang sebagai penyelamat. KubeVirt adalah proyek open-source yang memungkinkan kita menjalankan Virtual Machine secara native di dalam klaster Kubernetes. Ini berarti VM bisa diatur, di-deploy, dan di-manage layaknya Pod atau Deployment biasa. Bagi developer Indonesia yang sering berhadapan dengan sistem kompleks dan modernisasi aplikasi, KubeVirt menawarkan jembatan unik antara dunia VM tradisional dan dunia kontainer modern.

Artikel ini akan memandu Anda langkah demi langkah untuk menyiapkan lingkungan pengembangan lokal Kubernetes dengan KubeVirt, memungkinkan Anda mensimulasikan skenario hybrid cloud yang realistis. Kita akan belajar cara menginstal KubeVirt, menjalankan VM pertama Anda, dan memahami bagaimana VM ini bisa berinteraksi dengan layanan kontainer Anda. Mari kita selami! 🚀

2. Apa Itu KubeVirt dan Mengapa Penting untuk Developer?

Bayangkan Anda memiliki sebuah aplikasi lawas yang sangat bergantung pada sistem operasi atau konfigurasi spesifik di dalam VM. Mengubahnya menjadi kontainer mungkin membutuhkan usaha besar atau bahkan tidak mungkin dalam waktu singkat. Di sisi lain, Anda juga membangun microservices baru dalam bentuk kontainer yang diorkestrasi oleh Kubernetes. Bagaimana kedua dunia ini bisa hidup berdampingan dan berkomunikasi secara efisien?

📌 KubeVirt adalah solusi yang menjembatani kesenjangan ini. Secara fundamental, KubeVirt adalah ekstensi Kubernetes yang menambahkan resource types baru seperti VirtualMachineInstance (VMI), VirtualMachine (VM), dan VirtualMachinePool. Ini memungkinkan Kubernetes untuk mengelola siklus hidup VM, termasuk provisioning, scaling, dan networking, sama seperti ia mengelola Pod.

Mengapa ini penting untuk developer?

Simulasi Hybrid Cloud Lokal: Anda bisa mereplikasi lingkungan produksi hybrid (VM + kontainer) langsung di mesin pengembangan Anda. Ini krusial untuk menguji integrasi, migrasi, atau pola desain arsitektur hybrid tanpa harus bergantung pada infrastruktur cloud yang mahal.
Modernisasi Bertahap: Memungkinkan Anda memindahkan aplikasi legacy ke Kubernetes selangkah demi selangkah. VM lama bisa berjalan di KubeVirt sambil Anda membangun ulang bagian-bagiannya menjadi kontainer, semua dalam satu orkestrasi.
Workload Spesifik: Beberapa workload memang lebih cocok berjalan di VM (misalnya, aplikasi yang membutuhkan kernel kustom, GPU passthrough, atau lisensi software yang terikat OS). KubeVirt memungkinkan Anda menjalankan workload ini di klaster Kubernetes tanpa mengorbankan konsistensi manajemen.
Developer Experience (DX) yang Konsisten: Dengan KubeVirt, Anda bisa menggunakan kubectl dan tooling Kubernetes lainnya untuk mengelola VM, menyederhanakan workflow Anda.

3. Prasyarat dan Persiapan Lingkungan Lokal

Sebelum kita mulai, pastikan Anda memiliki prasyarat berikut di mesin pengembangan Anda:

Docker Desktop atau Minikube: Kita akan menggunakan Minikube sebagai klaster Kubernetes lokal kita karena relatif mudah diatur dan mendukung fitur-fitur yang dibutuhkan KubeVirt. Jika Anda belum punya, instal Minikube.
- Pastikan Minikube dikonfigurasi dengan driver yang mendukung virtualisasi (misalnya kvm2 di Linux, hyperkit di macOS, atau hyperv di Windows). Driver docker (container-based) mungkin tidak ideal untuk KubeVirt karena KubeVirt membutuhkan akses ke fitur virtualisasi kernel.
- Untuk memulai Minikube dengan driver yang tepat:
```
minikube start --driver=kvm2 --memory=8192mb --cpus=4 --disk-size=50g # Contoh untuk Linux
# Atau
minikube start --driver=hyperkit --memory=8192mb --cpus=4 --disk-size=50g # Contoh untuk macOS
```
- Pastikan alokasi memori dan CPU cukup, KubeVirt dan VM membutuhkan resource yang lumayan.
kubectl: Command-line tool untuk berinterinteraksi dengan klaster Kubernetes Anda.
virtctl: Command-line tool khusus untuk KubeVirt. Kita akan menginstalnya nanti.

✅ Verifikasi Minikube: Pastikan Minikube Anda berjalan dengan baik:

minikube status
kubectl get nodes

Anda seharusnya melihat satu node Minikube yang berstatus Ready.

4. Instalasi KubeVirt di Klaster Lokal Anda

Setelah Minikube siap, langkah selanjutnya adalah menginstal KubeVirt. Ini cukup mudah dilakukan dengan kubectl.

4.1. Mendapatkan `virtctl` CLI

virtctl adalah utilitas baris perintah untuk mengelola VM yang diorkestrasi KubeVirt.

# Untuk Linux
os=$(uname -s)
arch=$(uname -m)
release_url="https://github.com/kubevirt/kubevirt/releases"
version=$(curl -s $release_url/latest | grep -oP '(?<=tag/v)[0-9]+\.[0-9]+\.[0-9]+')
wget $release_url/download/v${version}/virtctl-v${version}-${os}-${arch}
chmod +x virtctl-v${version}-${os}-${arch}
sudo mv virtctl-v${version}-${os}-${arch} /usr/local/bin/virtctl

# Untuk macOS (gunakan brew atau sesuaikan perintah di atas)
# brew install virtctl

⚠️ Pastikan virtctl terinstal dan dapat diakses di PATH Anda.

4.2. Instalasi KubeVirt Operator

KubeVirt di-deploy sebagai operator Kubernetes. Operator ini akan mengelola semua komponen KubeVirt secara otomatis.

Deploy KubeVirt Custom Resource Definitions (CRDs) dan Komponen Inti: Kita akan menginstal versi terbaru KubeVirt. Anda bisa menemukan rilis terbaru di halaman rilis KubeVirt GitHub.

# Ganti dengan versi terbaru yang stabil, contoh: v1.1.0
export KUBEVIRT_VERSION=$(curl -s https://api.github.com/repos/kubevirt/kubevirt/releases/latest | grep "tag_name" | cut -d '"' -f 4)
echo "Menginstal KubeVirt versi: $KUBEVIRT_VERSION"

kubectl create -f https://github.com/kubevirt/kubevirt/releases/download/${KUBEVIRT_VERSION}/kubevirt-operator.yaml
kubectl create -f https://github.com/kubevirt/kubevirt/releases/download/${KUBEVIRT_VERSION}/kubevirt-cr.yaml

Perintah pertama akan membuat namespace kubevirt dan menginstal KubeVirt Operator. Perintah kedua akan membuat KubeVirt Custom Resource (CR) yang memberi tahu operator untuk menginstal semua komponen KubeVirt (Controller, DaemonSet, dll.).

Verifikasi Instalasi: Dibutuhkan beberapa saat agar semua Pod KubeVirt berjalan. Anda bisa memantau progresnya:

kubectl get pods -n kubevirt

Anda akan melihat Pod seperti virt-operator, virt-controller, virt-api, dan virt-launcher (daemonset) yang semuanya harus berstatus Running.

✅ Pastikan semua Pod KubeVirt berjalan normal.

NAME                               READY   STATUS    RESTARTS   AGE
virt-api-xxxx                      1/1     Running   0          2m
virt-controller-xxxx               1/1     Running   0          2m
virt-operator-xxxx                 1/1     Running   0          3m
virt-handler-minikube              1/1     Running   0          2m

5. Menjalankan Virtual Machine Pertama Anda

Sekarang KubeVirt sudah siap, mari kita jalankan VM pertama kita! Kita akan menggunakan image cirros, sebuah distro Linux yang sangat ringan, cocok untuk pengujian.

5.1. Membuat DataVolume untuk Image VM

KubeVirt menggunakan DataVolume (dari proyek CDI - Containerized Data Importer) untuk mengimpor image VM ke dalam PersistentVolumeClaim (PVC).

Buat file cirros-datavolume.yaml:

apiVersion: cdi.kubevirt.io/v1beta1
kind: DataVolume
metadata:
  name: cirros-dv
spec:
  source:
    http:
      url: https://cloud.centos.org/centos/8/x86_64/images/CentOS-8-GenericCloud-8.5.2111-20220516.0.x86_64.qcow2
  pvc:
    accessModes:
      - ReadWriteOnce
    resources:
      requests:
        storage: 5Gi

💡 Tips: Anda bisa mengganti URL image dengan image OS lain (misalnya Ubuntu Cloud Image atau CentOS). Pastikan formatnya kompatibel (qcow2).

Terapkan DataVolume:

kubectl apply -f cirros-datavolume.yaml

Pantau status impor image:

kubectl get datavolume cirros-dv -w

Ini akan membutuhkan waktu tergantung kecepatan internet Anda. Statusnya akan berubah dari Pending atau Importing menjadi Succeeded.

5.2. Membuat VirtualMachine (VM)

Setelah DataVolume siap, kita bisa membuat definisi VirtualMachine yang akan menggunakan image tersebut.

Buat file cirros-vm.yaml:

apiVersion: kubevirt.io/v1
kind: VirtualMachine
metadata:
  labels:
    kubevirt.io/vm: cirros-vm
  name: cirros-vm
spec:
  running: false # Mulai dalam keadaan mati
  template:
    metadata:
      labels:
        kubevirt.io/vm: cirros-vm
    spec:
      domain:
        cpu:
          cores: 1
        devices:
          disks:
            - disk:
                bus: virtio
              name: rootdisk
          interfaces:
            - name: default
              masquerade: {} # Menggunakan NAT untuk koneksi jaringan
        machine:
          type: q35
        resources:
          requests:
            memory: 512Mi
      networks:
        - name: default
          pod: {}
      volumes:
        - name: rootdisk
          persistentVolumeClaim:
            claimName: cirros-dv # Menggunakan DataVolume yang kita buat

🎯 Penting: Kita set running: false agar VM tidak langsung berjalan. Ini memberi kita kontrol untuk memulainya secara manual.

Terapkan definisi VM:

kubectl apply -f cirros-vm.yaml

Verifikasi VM sudah terdaftar:

kubectl get vm cirros-vm

5.3. Menjalankan dan Mengakses VM

Sekarang, mari kita mulai VM kita dan coba akses konsolnya.

Mulai VM:

virtctl start cirros-vm

Pantau status VM:

kubectl get vmi cirros-vm -w # VMI (VirtualMachineInstance) adalah instance VM yang sedang berjalan

Anda akan melihat VMI berstatus Running.

Akses Konsol VM:
```
virtctl console cirros-vm
```
Anda akan melihat prompt login untuk VM Anda. Untuk image Cirros, username default adalah cirros dan passwordnya gocubsgo.

💡 Tips: Untuk keluar dari konsol virtctl, tekan Ctrl + ].
Hentikan VM:
```
virtctl stop cirros-vm
```
Ini akan menghentikan instance VM yang sedang berjalan.

Selamat! Anda telah berhasil menjalankan VM di dalam klaster Kubernetes lokal Anda. 🎉

6. Integrasi VM dengan Layanan Kubernetes

Salah satu kekuatan KubeVirt adalah kemampuan VM untuk berinteraksi dengan layanan kontainer dan sebaliknya.

Secara default, VM yang berjalan di KubeVirt akan mendapatkan IP di dalam jaringan Pod Kubernetes. Ini berarti VM dapat berkomunikasi dengan Pod lain di klaster Anda menggunakan IP internal atau nama layanan (jika ada Service yang mengarah ke Pod tersebut).

6.1. Contoh: VM Mengakses Service Kontainer

Misalkan Anda memiliki aplikasi kontainer Nginx yang diekspos melalui Service:

# nginx-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-app
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 1
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80
---
# nginx-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

Terapkan deployment dan service Nginx:

kubectl apply -f nginx-deployment.yaml
kubectl apply -f nginx-service.yaml

Setelah Nginx Pod dan Service berjalan, Anda bisa mendapatkan IP klaster dari Service Nginx:

kubectl get service nginx-service
# Output contoh:
# NAME            TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
# nginx-service   ClusterIP   10.100.200.10   <none>        80/TCP    1m

Dari dalam konsol VM cirros-vm Anda, Anda bisa mencoba ping atau curl ke CLUSTER-IP dari nginx-service.

# Di dalam konsol VM cirros-vm
ping 10.100.200.10
curl 10.100.200.10

Anda seharusnya akan melihat respons dari server Nginx. Ini menunjukkan bahwa VM dan kontainer Anda dapat berkomunikasi dalam klaster Kubernetes yang sama.

6.2. Pola Arsitektur Hybrid

Dengan kemampuan ini, Anda bisa mulai merancang pola arsitektur hybrid yang menarik:

Sidecar VM: VM lama Anda bisa berjalan sebagai “sidecar” untuk Pod kontainer yang baru, memungkinkan komunikasi lokal berkinerja tinggi.
API Gateway ke VM: Sebuah API Gateway (berjalan sebagai kontainer) bisa merutekan traffic ke VM yang menjalankan aplikasi legacy Anda.
Database VM: Database yang sulit di-containerisasi bisa tetap berjalan di VM KubeVirt, sementara aplikasi microservices Anda mengaksesnya sebagai Service Kubernetes.

Kesimpulan

KubeVirt adalah tool yang sangat powerful bagi developer yang bekerja di lingkungan hybrid atau sedang dalam proses modernisasi aplikasi. Dengan KubeVirt, kita bisa membawa kekuatan orkestrasi Kubernetes ke dunia Virtual Machine, menciptakan lingkungan pengembangan lokal yang lebih realistis dan efisien untuk mensimulasikan skenario cloud-native hybrid.

Anda telah belajar cara menginstal KubeVirt, menjalankan VM pertama Anda, dan memahami bagaimana VM dapat berkomunikasi dengan layanan kontainer. Ini membuka pintu untuk berbagai kemungkinan, mulai dari menguji migrasi aplikasi legacy hingga mengembangkan arsitektur baru yang menggabungkan kekuatan VM dan kontainer. Dengan lingkungan lokal yang solid ini, Anda bisa bereksperimen, menguji, dan membangun solusi yang lebih tangguh dan fleksibel untuk tantangan web development modern. Teruslah bereksperimen!