Belajar Linux - Containerization & Virtualization (Docker, LXC & KVM)

#Pendahuluan

Setelah di episode 26 sebelumnya kita membahas strategi backup & restore — prinsip 3-2-1, rsync, tar, restic, hingga drill restore yang terukur — kalian sekarang punya fondasi pemulihan data yang kokoh. Namun ada satu pertanyaan mendasar yang belum kita jawab: bagaimana cara terbaik menjalankan layanan di atas satu server Linux? Apakah harus satu aplikasi satu server fisik? Haruskah setiap layanan punya OS sendiri? Atau ada cara yang lebih ringan?

Di episode 27 ini kita masuk ke salah satu tema paling berpengaruh dalam cara kerja infrastruktur modern: containerization & virtualization. Kalian akan mempelajari tiga level isolasi yang berbeda — Docker untuk application containers, LXD untuk system containers, dan KVM untuk virtual machines penuh — serta memahami kapan harus memakai yang mana. Setelah episode ini, konsep yang sudah kita bangun selama 26 episode (kernel, systemd, networking, storage, hardening) akan terlihat bersatu dalam satu arsitektur layanan yang utuh.

#Pembahasan Utama

#Konsep Container: Mengapa Isolasi Itu Penting

Bayangkan satu rumah kost dengan banyak penghuni. Jika semua penghuni berbagi dapur, kamar mandi, dan listrik tanpa pembatas, satu penghuni yang berisik atau boros bisa mengganggu semua orang. Sekarang bayangkan setiap kamar punya pintu sendiri, meteran listrik sendiri, dan fasilitas lengkap di dalamnya — masing-masing penghuni bisa mengatur cara hidupnya tanpa mengganggu yang lain.

Itulah esensi isolasi. Sebelum era container, untuk menjalankan dua versi aplikasi yang membutuhkan pustaka (library) berbeda, kalian harus memisahkan ke dua mesin — pemborosan besar. Container memecahkan masalah ini dengan mengisolasi aplikasi dan dependensinya di dalam satu kernel yang sama. Setiap container punya filesystem, proses, dan network namespace sendiri, tetapi berbagi kernel host.

Perbandingan antara container dan virtual machine adalah konsep paling penting yang harus kalian pahami:

#Docker: Application Containers

Docker adalah platform container yang paling populer dan sering menjadi pintu masuk orang ke dunia containerization. Konsep inti yang harus kalian kuasai ada lima: image, container, volume, network, dan registry.

• Image — template hanya-baca yang berisi aplikasi + dependensinya. Seperti blueprint atau cetakan kue: satu cetakan bisa menghasilkan banyak kue yang identik.
• Container — instance yang berjalan dari sebuah image. Setiap container adalah kue yang sudah jadi, siap disajikan.
• Volume — penyimpanan persisten yang terpisah dari siklus hidup container. Tanpa volume, data di dalam container hilang begitu container dihapus.
• Network — jaringan virtual yang menghubungkan container satu sama lain dan dengan dunia luar, dengan isolasi antar network.
• Registry — tempat menyimpan dan mendistribusikan image (seperti GitHub untuk image container). Docker Hub adalah registry publik paling terkenal.

Kita mulai dengan menjalankan container nginx pertama:

docker run -d --name web-nginx -p 8080:80 nginx:1.27

Mari kita bedah perintahnya baris demi baris:

• -d — jalankan di background (detached).
• --name web-nginx — beri nama agar mudah direferensikan.
• -p 8080:80 — port mapping: port 8080 di host diteruskan ke port 80 di dalam container.
• nginx:1.27 — nama image dan tag versinya. Docker akan mengunduh image ini dari registry jika belum ada di lokal.

Verifikasi hasilnya dengan perintah berikut:

docker ps
curl http://localhost:8080

CONTAINER ID   IMAGE         COMMAND                  PORTS                  NAMES
a1b2c3d4e5f6   nginx:1.27    "/docker-entrypoint.…"   0.0.0.0:8080->80/tcp   web-nginx

Agar bisa dipakai berulang kali tanpa mengetik perintah panjang, kita definisikan layanan dalam file compose.yaml. Docker Compose memungkinkan kita mendeskripsikan multi-container — termasuk volume dan network — sebagai deklaratif yang bisa di-commit ke Git:

services:
  web:
    image: nginx:1.27
    ports:
      - "8080:80"
    volumes:
      - webdata:/usr/share/nginx/html
 
volumes:
  webdata:

docker compose up -d
docker compose ps

NAME                IMAGE         COMMAND                  STATUS          PORTS
learn-linux-web-1   nginx:1.27    "/docker-entrypoint.…"   Up 2 seconds    0.0.0.0:8080->80/tcp

#LXC/LXD: System Containers

Docker mengisolasi satu aplikasi. LXC (Linux Containers) dan pengelola modernnya LXD mengisolasi seluruh sistem operasi — kalian menjalankan "container" yang berisi distro Linux lengkap (Ubuntu, Debian, Arch, bahkan CentOS) dengan init/systemd, user, dan prosesnya sendiri. Karena berbagi kernel host, LXD jauh lebih ringan daripada VM — tetapi dari dalam, rasanya seperti punya server Linux sendiri yang penuh.

Analogi paling tepat: Docker adalah bedeng pembantu — hanya tempat peralatan; LXD adalah rumah prefabrikasi — siap huni dengan semua ruangan, tapi tetap berdiri di atas lahan yang sama.

Setelah menginstall lxd dan melakukan lxd init (atau lxc init untuk versi lama), kalian bisa meluncurkan container Ubuntu hanya dalam hitungan detik:

Menjalankan system container dengan LXD

lxc launch ubuntu:24.04 web-srv
lxc list
lxc exec web-srv -- apt update
lxc exec web-srv -- apt install -y nginx

+---------+---------+---------------------+------+-----------+-----------+
|  NAME   |  STATE  |        IPV4         | TYPE| SNAPSHOTS | LOCATION  |
+---------+---------+---------------------+------+-----------+-----------+
| web-srv | RUNNING | 10.59.176.56 (eth0) | CONTAINER | 0 | (none)   |
+---------+---------+---------------------+------+-----------+-----------+

Perhatikan bahwa lxc exec web-srv -- apt ... menjalankan perintah di dalam container — seperti ssh ke server, tapi tanpa jaringan. Container ini adalah distro Ubuntu lengkap, punya systemd, dan bisa diakses dari jaringan dengan IP sendiri. Itulah kenapa LXD sering disebut sebagai pengganti virtualisasi ringan: densitas container per host bisa mencapai puluhan bahkan ratusan.

#KVM/QEMU: Virtualisasi Penuh

Ketika kalian butuh kernel sendiri, OS yang berbeda dari host, atau isolasi keamanan yang paling ketat, tidak ada pengganti virtual machine. KVM (Kernel-based Virtual Machine) memanfaatkan hardware virtualization (VT-x/AMD-V) sehingga setiap VM menjalankan kernel tamunya sendiri secara nyata — bukan simulasi. QEMU adalah emulator yang menjadi front-end user-space untuk KVM.

Beda paling fundamental dengan container: VM tidak berbagi apa pun dengan host selain hardware-nya. Kalian bisa menjalankan Windows, FreeBSD, atau distro Linux lama di atas host Ubuntu — sesuatu yang tidak mungkin dilakukan container karena semua container harus memakai kernel yang sama dengan host.

Membuat VM dari CLI dengan virt-install:

virt-install \
  --name vm-app1 \
  --vcpus 2 \
  --memory 2048 \
  --disk size=20 \
  --os-variant ubuntu24.04 \
  --network network=default \
  --cdrom /mnt/iso/ubuntu-24.04.iso

Setelah VM dibuat, manajemen harian dilakukan dengan virsh:

virsh list --all
virsh start vm-app1
virsh console vm-app1
virsh shutdown vm-app1
virsh destroy vm-app1

 Id   Name      State
-------------------------------
 3    vm-app1   running
 -    vm-backup off

Untuk pengguna yang lebih suka antarmuka grafis, virt-manager menyediakan GUI lengkap untuk membuat dan mengelola VM — sangat berguna untuk inspeksi visual, snapshot, dan pengaturan hardware. Di lingkungan server tanpa GUI, kombinasi virt-install + virsh + file XML definisi VM adalah workflow utamanya.

#Praktik: Menjalankan nginx di Docker dan System Container LXD

Saatnya membandingkan kedua pendekatan secara langsung di satu mesin. Kita akan menjalankan nginx yang sama dua kali: sekali sebagai application container Docker, sekali sebagai system container LXD.

Langkah 1 — Pastikan kedua tool tersedia:

docker --version
lxc --version

Langkah 2 — Jalankan nginx di Docker:

docker run -d --name web-nginx -p 8080:80 nginx:1.27
curl -s http://localhost:8080 | head -3

Langkah 3 — Jalankan nginx di LXD:

nginx sebagai system container

lxc launch ubuntu:24.04 web-srv
lxc exec web-srv -- apt-get update
lxc exec web-srv -- apt-get install -y nginx
lxc exec web-srv -- systemctl enable --now nginx
curl -s http://10.59.176.56/ | head -3

Langkah 4 — Bandingkan resource yang terpakai:

docker stats --no-stream web-nginx
lxc exec web-srv -- free -m

#Common Pitfalls

Berdasarkan pengalaman lapangan, berikut pola kesalahan yang paling sering terjadi saat orang mulai bermain dengan container dan virtualisasi:

Satu kasus yang menarik adalah user di group docker. Menambahkan user ke group docker setara dengan memberikan akses root ke mesin — karena siapa pun yang bisa menjalankan docker run -v /:/host ... bisa membaca dan menulis seluruh filesystem host. Ini kenyamanan yang harus dibayar dengan kepercayaan besar:

docker run hello-world    # ERROR: permission denied
sudo usermod -aG docker $USER
newgrp docker            # aktifkan keanggotaan group tanpa logout
docker run hello-world   # sukses

#Penutup

Di episode ini kita telah memetakan tiga lapis isolasi yang tersedia di Linux. Docker mengisolasi aplikasi dengan ringan dan efisien — pilihan utama untuk microservice dan workload stateless. LXD mengisolasi seluruh sistem operasi dengan overhead rendah — ideal untuk menggantikan VM yang ramping dengan distro lengkap. KVM/QEMU memberi virtualisasi penuh dengan kernel tamu sendiri — tak tergantikan untuk keamanan maksimal, OS heterogen, dan workload legacy. Kalian juga sudah mempraktikkan cara menjalankan nginx di Docker dan LXD, serta memahami kesalahan umum yang merugikan.

Dengan kemampuan mengisolasi dan menjalankan banyak layanan di atas satu server, kalian memasuki babak baru administrasi Linux. Namun banyaknya server dan user juga memunculkan masalah baru: bagaimana mengelola identitas user di banyak mesin sekaligus? Di episode 28 berikutnya kita akan membahas LDAP & centralized authentication — membangun satu sumber kebenaran untuk otentikasi sehingga satu akun bisa masuk ke puluhan server. Sampai jumpa di episode 28!