Setup Rootless Kubernetes K0s di VPS: Panduan Lengkap Tanpa Root Access

Bayangin lo bangun pagi, buka Slack, langsung ada notif incident. Cluster Kubernetes lo kena exploit privilege escalation. Attacker berhasil kabur dari container, dapet akses root ke host. Seram kan?

Ini bukan cerita horor aja—risiko nyata kalau kita masih jalanin Kubernetes pakai full root privileges. Makanya setup rootless Kubernetes sekarang makin banyak dipakai, apalagi buat tim yang peduli sama security.

Kita bakal bahas cara setup K0s cluster yang jalan sebagai user biasa (non-root) di VPS Linux. Lebih aman, tetap praktis, cocok buat production.

Kenapa Harus Rootless?

Hampir semua instalasi Kubernetes default masih butuh root access. Kubelet, containerd, semua komponen inti jalan dengan privilege tinggi. Masalahnya kalau ada bug di container runtime atau kernel, attacker bisa langsung escalate ke root host.

Attack surface-nya gede banget. Vulnerability seperti CVE-2019-5736 di runc atau dirty pipe kernel exploit bisa dimanfaatkan kalau runtime jalan sebagai root. Belum lagi kalau lo hosting banyak tenant—satu tenant kena compromise, semua workload lain di node yang sama bisa kena impact.

K0s atau K3s?

Kenapa pilih K0s? Lebih modular dan fleksibel. K3s memang ringan, tapi karena komponen-komponennya tightly integrated, konfigurasi rootless jadi lebih ribet. K0s lebih gampang dipisah-pisah kontrolnya, built-in containerd-nya juga lebih straightforward buat di-tweak.

K0s juga unggul di compliance requirement. Kalau perusahaan lo enforce policy "no root daemon", K0s bisa meet requirement itu dengan konfigurasi yang proper.

Setup K0s Rootless

VPS lo harus support user namespaces dan cgroup v2. Kebanyakan distro modern (Ubuntu 22.04+, Debian 11+, Fedora 33+) udah enable ini by default. Cek dulu:

# Cek user namespace support
cat /proc/sys/kernel/unprivileged_userns_clone
# Output harus 1

# Cek cgroup v2
stat -fc %T /sys/fs/cgroup
# Output harus cgroup2fs

Kalau belum enable, lo perlu reboot dengan kernel parameter baru atau upgrade distro.

Install Dependencies

Install tools yang dibutuhin:

sudo apt update
sudo apt install -y uidmap slirp4netns fuse-overlayfs

# Install rootlesskit
curl -sSL https://github.com/rootless-containers/rootlesskit/releases/download/v1.1.1/rootlesskit-x86_64.tar.gz | tar Cxzv /usr/local/bin

Slirp4netns penting buat networking. Karena kita nggak punya privilege buat bind ke interface fisik atau manipulasi iptables, slirp4netns bikin user-mode network stack. Fuse-overlayfs buat storage layer karena unprivileged user nggak bisa pake overlay2 driver bawaan.

Konfigurasi Containerd Rootless

Setup containerd yang jalan sebagai user biasa:

# Install containerd rootless
curl -sSL https://github.com/containerd/nerdctl/releases/download/v1.7.0/nerdctl-full-1.7.0-linux-amd64.tar.gz | tar Cxzv $HOME/.local

# Setup systemd user service
containerd-rootless-setuptool.sh install

# Cek service aktif
systemctl --user status containerd

Edit config containerd di ~/.config/containerd/config.toml:

[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options]
  SystemdCgroup = false

[plugins."io.containerd.snapshotter.v1.overlayfs"]
  root = "/home/youruser/.local/share/containerd/snapshotter/overlayfs"

Restart containerd user service setelah edit config.

Bootstrap K0s Cluster

Download dan install K0s sebagai user biasa:

curl -sSLf https://get.k0s.sh | sh
sudo install -o $USER -g $USER -m 0755 k0s /usr/local/bin/k0s

# Generate config untuk rootless mode
k0s config create > k0s.yaml

Edit k0s.yaml buat enable rootless settings:

spec:
  api:
    address: 127.0.0.1
    port: 6443
  storage:
    type: kine
  network:
    provider: calico
    calico:
      mode: vxlan
      vxlanPort: 4789
      mtu: 1450
  extensions:
    storage:
      type: external_storage

Start controller dengan rootlesskit wrapper:

rootlesskit --net=slirp4netns --copy-up=/etc --copy-up=/run \
  --state-dir=$HOME/.local/share/rootlesskit-k0s \
  k0s controller --config=k0s.yaml --enable-worker

Setup systemd user service biar auto-start:

mkdir -p ~/.config/systemd/user
cat > ~/.config/systemd/user/k0s.service <

Deploy Sample Workload dengan Storage

Setup kubeconfig:

export KUBECONFIG=$HOME/.k0s/kubeconfig
kubectl get nodes

Deploy nginx dengan PVC rootless:

cat <

Perhatikan kita pake nginx-unprivileged yang listen di port 8080, bukan 80. User non-root nggak bisa bind port di bawah 1024.

Best Practice Production

Resource Limit dan Cgroup Delegation

Enable cgroup delegation buat user lo:

sudo mkdir -p /etc/systemd/system/user@.service.d
cat <

Set resource limit di deployment:

resources:
  limits:
    memory: "512Mi"
    cpu: "500m"
  requests:
    memory: "256Mi"
    cpu: "250m"

Setup Ingress Controller Traefik Rootless

Install Traefik yang support rootless:

helm repo add traefik https://traefik.github.io/charts
helm install traefik traefik/traefik \
  --set ports.web.exposedPort=8000 \
  --set ports.websecure.exposedPort=8443 \
  --set securityContext.runAsNonRoot=true \
  --set securityContext.runAsUser=65532

Traefik bakal listen di port 8000/8443. Kalau mau expose ke internet via standard port, pake reverse proxy eksternal (nginx/caddy di host) atau port forwarding iptables yang di-setup pakai sudo privilege terbatas.

Monitoring dengan Metrics Server

Deploy metrics-server dengan patch untuk rootless environment:

kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

kubectl patch deployment metrics-server -n kube-system --type=json -p='[
  {"op": "add", "path": "/spec/template/spec/containers/0/args/-", "value": "--kubelet-insecure-tls"},
  {"op": "add", "path": "/spec/template/spec/containers/0/args/-", "value": "--kubelet-preferred-address-types=InternalIP"}
]'

Troubleshooting

Permission denied errors: Cek file ownership dan pastikan semua files di $HOME/.local/share punya permission yang bener. Run loginctl enable-linger $USER biar systemd user service tetap jalan walau lo logout.

Port binding di bawah 1024: Jangan coba bind privileged ports. Pake port 1024 ke atas dan route traffic lewat reverse proxy atau port forwarding.

Network connectivity issues: Slirp4netns punya overhead performance. Kalau butuh throughput tinggi, pertimbangin pake pasta (pengganti modern) atau setup proper network namespace dengan veth pairs.

Backup dan Restore

Backup cluster state secara berkala:

k0s backup --save-path=$HOME/k0s-backup-$(date +%Y%m%d).tar.gz

Restore kalau dibutuhkan:

systemctl --user stop k0s
k0s restore $HOME/k0s-backup-20261104.tar.gz
systemctl --user start k0s

Trade-off yang Perlu Lo Tau

Rootless Kubernetes bukan solusi sempurna. Ada trade-off yang perlu dipahami. Performance-nya lebih rendah dibanding root mode—network throughput bisa turun 10-30% karena user-mode networking stack. Disk I/O juga lebih lambat dengan fuse-overlayfs.

Use case ideal buat rootless K8s adalah multi-tenant environment di mana isolation security lebih penting dari raw performance. Shared hosting, development platform, atau CI/CD runner yang handle untrusted code cocok banget pake approach ini.

Kalau workload lo cuma simple stateless apps tanpa butuh orchestration complexity, pertimbangin alternatif lebih ringan. Podman dengan pod support atau docker rootless mode mungkin lebih straightforward. Buildah buat CI/CD pipeline juga pilihan solid.

Roadmap adopsi di production? Mulai dari dev/staging environment dulu. Monitor performance metrics, test failure scenarios, train team buat troubleshooting. Kalau udah confident, gradually migrate non-critical workload ke rootless cluster. Keep monitoring dan iterate.

Kesimpulan

Setup rootless Kubernetes memang butuh effort lebih dibanding instalasi standard, tapi investment-nya worth it buat security jangka panjang. Lo dapat defense in depth yang proper tanpa bergantung cuma pada container isolation.

Mulai dengan single-node K0s di VPS development lo. Eksperimen dengan deployment patterns, test monitoring tools, break things dan pelajari cara fix-nya. Pengalaman hands-on jauh lebih berharga daripada baca teori doang.

Facebook X WhatsApp