Kamu sudah paham cara membungkus aplikasi ke dalam container dengan Docker? Sekarang saatnya naik level: bagaimana jika kamu harus mengelola puluhan—bahkan ratusan—container sekaligus, memastikan semuanya tetap berjalan saat trafik melonjak atau saat salah satu server mati? Jawabannya adalah Kubernetes. Di tutorial ini, kamu akan belajar konsep inti Kubernetes seperti Pod, Deployment, dan Service, lalu langsung mempraktikkannya dengan menjalankan cluster lokal menggunakan minikube dan kubectl. Tidak perlu pengalaman orkestrasi sebelumnya—cukup ikuti langkah demi langkah berikut.

Apa Itu Kubernetes dan Mengapa Kamu Membutuhkannya?

Kubernetes (sering disingkat k8s) adalah platform open source untuk mengotomatiskan deployment, scaling, dan pengelolaan aplikasi berbasis container. Awalnya dikembangkan oleh Google dan kini dikelola oleh Cloud Native Computing Foundation (CNCF), Kubernetes telah menjadi standar de facto untuk orkestrasi container di industri.

Bayangkan kamu punya aplikasi web yang harus online 24/7. Trafiknya tiba-tiba naik dua kali lipat, lalu salah satu server tempat aplikasi berjalan mati. Tanpa orkestrasi, kamu harus mengatasi semua itu secara manual. Kubernetes menangani pekerjaan berat ini untukmu: menjalankan ulang container yang gagal, menyeimbangkan beban trafik, menskalakan jumlah replika naik-turun sesuai kebutuhan, serta melakukan pembaruan aplikasi tanpa downtime.

Kubernetes vs Docker: apa bedanya? Docker berfokus pada membangun dan menjalankan satu container, sedangkan Kubernetes berfokus pada mengelola banyak container di banyak mesin (node). Keduanya saling melengkapi: Docker membuat container, Kubernetes yang mengaturnya.

Konsep Dasar Kubernetes yang Wajib Kamu Pahami

Sebelum menulis perintah pertama, kenali dulu beberapa istilah yang akan sering kamu temui. Jangan khawatir—kita akan mempraktikkan semuanya satu per satu di bagian selanjutnya.

  • Cluster: kumpulan mesin (node) yang menjalankan aplikasi container-mu.
  • Node: satu mesin—fisik maupun virtual—di dalam cluster.
  • Pod: unit terkecil di Kubernetes, biasanya berisi satu container utama.
  • Deployment: mendeklarasikan berapa banyak replika Pod yang diinginkan dan cara memperbaruinya.
  • Service: alamat stabil untuk mengakses sekumpulan Pod, lengkap dengan load balancing.

Aktifkan autocomplete kubectl agar lebih cepat mengetik perintah: jalankan kubectl completion bash >> ~/.bashrc lalu muat ulang shell. Ini sangat membantu saat kamu sering bolak-balik mengetik perintah kubectl.

Persiapan: Install kubectl dan minikube

Sebelum mulai, pastikan kamu sudah punya Docker di mesinmu—minikube akan memanfaatkannya sebagai driver untuk menjalankan cluster. Jika belum, baca dulu tutorial Docker untuk pemula. Setelah itu, install dua alat utama: kubectl (client untuk berkomunikasi dengan cluster) dan minikube (alat untuk menjalankan cluster Kubernetes satu-node di lokal).

bash
# Install kubectl (Linux/macOS)
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
chmod +x kubectl
sudo mv kubectl /usr/local/bin/

# Install minikube (Linux/macOS)
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

# Verifikasi instalasi
kubectl version --client
minikube version

Menjalankan Cluster Lokal dengan minikube

Setelah semuanya terpasang, jalankan cluster lokal pertamamu. Perintah minikube start akan menyiapkan cluster Kubernetes satu-node di mesinmu—proses ini bisa memakan waktu beberapa menit pada kali pertama karena minikube perlu mengunduh image.

bash
# Mulai cluster lokal
minikube start

# Cek status cluster
minikube status
kubectl cluster-info

# Lihat node yang tersedia
kubectl get nodes

Membuat Deployment Pertamamu

Untuk menjalankan aplikasi di Kubernetes, kamu tidak membuat container secara langsung—kamu mendeklarasikan sebuah Deployment. Deployment berisi spesifikasi Pod yang ingin dijalankan, termasuk image container dan jumlah replika. Buat file bernama deployment.yaml berisi konfigurasi berikut. Di sini kita menjalankan dua replika web server Nginx.

other
apiVersion: apps/v1
kind: Deployment
metadata:
  name: aplikasi-pertama
spec:
  replicas: 2
  selector:
    matchLabels:
      app: aplikasi-pertama
  template:
    metadata:
      labels:
        app: aplikasi-pertama
    spec:
      containers:
        - name: nginx
          image: nginx:1.25
          ports:
            - containerPort: 80
bash
# Terapkan deployment ke cluster
kubectl apply -f deployment.yaml

# Lihat Pod yang berjalan
kubectl get pods -o wide

# Lihat Deployment
kubectl get deployments

Perhatikan bahwa kita cukup mendeklarasikan keadaan yang diinginkan (2 replika, image nginx:1.25) di file YAML, lalu kubectl apply yang mewujudkannya. Inilah inti pendekatan deklaratif Kubernetes—kamu menyatakan tujuan akhir, bukan langkah-langkahnya.

Mengekspos Aplikasi dengan Service

Sekarang aplikasimu berjalan di dalam Pod, tapi belum bisa diakses dari luar. Pod bersifat sementara—ketika dihapus atau diganti, alamat IP-nya ikut berubah. Di sinilah Service berperan: ia memberi alamat stabil untuk sekumpulan Pod. Buat file service.yaml berikut.

other
apiVersion: v1
kind: Service
metadata:
  name: aplikasi-pertama
spec:
  type: NodePort
  selector:
    app: aplikasi-pertama
  ports:
    - port: 80
      targetPort: 80
      nodePort: 30080
bash
# Terapkan Service
kubectl apply -f service.yaml

# Lihat Service yang berjalan
kubectl get services

# Buka aplikasi di browser (minikube akan membukanya otomatis)
minikube service aplikasi-pertama

Menskalakan Aplikasi dalam Hitungan Detik

Salah satu keunggulan terbesar Kubernetes adalah scaling yang instan. Saat trafik naik, kamu cukup menambah jumlah replika dengan satu perintah—Kubernetes akan menjadwalkan Pod baru di node secara otomatis. Coba naikkan menjadi 4 replika.

bash
# Naikkan menjadi 4 replika
kubectl scale deployment aplikasi-pertama --replicas=4

# Pantau Pod baru bermunculan (tekan Ctrl+C untuk berhenti)
kubectl get pods -w

Update Tanpa Downtime dengan Rolling Update

Kubernetes juga membuat pembaruan aplikasi jauh lebih aman. Daripada mematikan aplikasi lalu menjalankan versi baru (yang menyebabkan downtime), kamu bisa melakukan rolling update: Kubernetes mengganti Pod satu per satu sehingga aplikasi tetap tersedia selama proses pembaruan.

bash
# Update image ke versi baru (rolling update)
kubectl set image deployment/aplikasi-pertama nginx=nginx:1.27

# Pantau status update
kubectl rollout status deployment/aplikasi-pertama

# Lihat riwayat pembaruan
kubectl rollout history deployment/aplikasi-pertama

# Jika terjadi masalah, rollback ke versi sebelumnya
kubectl rollout undo deployment/aplikasi-pertama

Inspeksi dan Debugging Pod

Saat sesuatu tidak berjalan sesuai harapan, kamu butuh alat untuk menyelidiki. kubectl menyediakan beberapa perintah penting untuk inspeksi dan debugging: describe untuk detail lengkap sebuah objek, logs untuk output log container, dan get events untuk melihat kejadian terbaru di cluster.

bash
# Detail lengkap sebuah Pod (status, event, error)
kubectl describe pod <nama-pod>

# Log dari container di dalam Pod
kubectl logs <nama-pod>

# Kejadian terbaru di cluster
kubectl get events --sort-by=.metadata.creationTimestamp

Membersihkan Resource

Setelah selesai bereksperimen, bersihkan resource yang sudah dibuat agar cluster lokal tetap rapi. Menghapus resource juga mudah karena kamu bisa memakai file YAML yang sama.

bash
# Hapus Deployment dan Service
kubectl delete -f deployment.yaml
kubectl delete -f service.yaml

# Atau hapus berdasarkan nama
kubectl delete deployment aplikasi-pertama
kubectl delete service aplikasi-pertama

# Hentikan dan hapus cluster lokal
minikube stop
minikube delete

Selamat! Kamu baru saja menjalankan aplikasi di cluster Kubernetes, menskalakannya, melakukan rolling update, dan membersihkan semuanya—dari nol. Ini adalah fondasi yang akan memudahkanmu mempelajari topik lanjutan seperti ConfigMap, Secret, Ingress, dan Persistent Volume. Jika ingin mengotomatiskan provisioning infrastruktur, lanjutkan ke tutorial Terraform untuk pemula. Untuk mengotomatiskan deployment ke cluster lewat pipeline, kamu juga bisa memadukannya dengan GitHub Actions.

Catatan untuk produksi: minikube dirancang untuk belajar dan pengembangan lokal, bukan untuk produksi. Di produksi, gunakan cluster terkelola seperti Google Kubernetes Engine (GKE), Amazon EKS, atau Azure AKS. Selalu tentukan resource limits pada container dan hindari tag image :latest agar deployment tetap bisa diprediksi.

Apa bedanya Kubernetes dengan Docker Compose?

Docker Compose mengelola beberapa container di satu mesin, sedangkan Kubernetes mengelola container di banyak mesin sekaligus dengan fitur lanjutan seperti scaling otomatis, self-healing, dan rolling update. Untuk proyek kecil di satu server, Compose sudah cukup; untuk aplikasi berskala besar dan multi-node, Kubernetes lebih tepat.

Selain minikube, ada alternatif lain untuk belajar Kubernetes secara lokal?

Ada beberapa: kind (Kubernetes in Docker) yang ringan dan cepat, k3s untuk cluster ringan di server kecil, serta Docker Desktop yang sudah menyertakan Kubernetes bawaan. minikube tetap pilihan populer karena dokumentasinya lengkap dan mudah dipakai pemula.

Kapan sebaiknya saya mulai menggunakan Kubernetes?

Mulailah ketika aplikasi sudah sulit dikelola secara manual—misalnya saat jumlah container makin banyak, butuh scaling otomatis, atau butuh ketersediaan tinggi (high availability). Untuk proyek kecil dengan satu aplikasi, menjalankan Kubernetes justru bisa menambah kompleksitas yang tidak perlu.