Kubernetes untuk Pemula — Panduan Lengkap Container Orchestration

Pengenalan: Container Orchestration di Era Cloud-Native

Kubernetes telah menjadi standar de-facto untuk orchestration aplikasi yang dikontainerisasi di lingkungan produksi. Dengan pertumbuhan eksplosif arsitektur microservices dan pengembangan cloud-native, pemahaman tentang Kubernetes bukan lagi keterampilan opsional, melainkan kebutuhan bagi setiap engineer infrastruktur dan profesional DevOps.

Kubernetes menyederhanakan deployment, scaling, dan pengelolaan aplikasi yang dikontainerisasi di cluster server. Platform ini menangani tugas-tugas kompleks seperti load balancing, scaling otomatis, rolling updates, self-healing, dan pengelolaan sumber daya — sehingga tim dapat fokus pada logika bisnis dibanding pengelolaan infrastruktur. Dalam panduan lengkap ini, kita akan menjelajahi Kubernetes dari konsep-konsep fundamental hingga deployment yang siap untuk production.

Daftar Isi

• Kubernetes Architecture
• Core Concepts: Pods, Deployments, Services
• StatefulSets dan DaemonSets
• ConfigMaps dan Secrets
• Storage dan Persistence
• Networking dan Ingress
• Resource Management dan Limits
• Health Checks dan Auto-Healing
• Scaling dan Auto-Scaling
• Security Best Practices
• Monitoring dan Logging
• Kesimpulan

Kubernetes Architecture

Kubernetes menggunakan arsitektur Master-Worker atau Control Plane-Worker. Memahami komponen-komponen ini sangat penting untuk deployment dan troubleshooting.

Control Plane Components

┌─────────────────────────────────────────┐
│         CONTROL PLANE (MASTER)          │
├─────────────────────────────────────────┤
│ API Server     - REST API untuk K8s     │
│ Scheduler      - Assign pods ke nodes   │
│ Controller Mgr - Jalankan controllers   │
│ etcd           - Key-value datastore    │
│ Cloud Ctrl Mgr - Integrasi cloud API    │
└─────────────────────────────────────────┘
              ↓
┌──────────────────────────────────────────────────┐
│            WORKER NODES (MULTIPLE)               │
├──────────────────────────────────────────────────┤
│ Node 1: Kubelet + Container Runtime + kube-proxy │
│ Node 2: Kubelet + Container Runtime + kube-proxy │
│ Node 3: Kubelet + Container Runtime + kube-proxy │
└──────────────────────────────────────────────────┘

API Server: Titik masuk untuk semua operasi Kubernetes. Menerima permintaan REST dan memperbarui etcd.

Scheduler: Menentukan node mana yang akan menjalankan pod berdasarkan kebutuhan sumber daya dan limit.

Controller Manager: Menjalankan loop controller yang mengelola sumber daya (Deployment Controller, StatefulSet Controller, dll).

etcd: Penyimpanan key-value terdistribusi yang menyimpan semua status cluster dan konfigurasi.

Core Concepts: Pods, Deployments, Services

Tiga konsep fundamental ini membentuk blok bangunan aplikasi Kubernetes.

Pods

Pod adalah unit terkecil yang dapat di-deploy di Kubernetes — minimal satu kontainer, biasanya satu kontainer per pod.

# pod.yaml - Minimal Pod definition
apiVersion: v1
kind: Pod
metadata:
  name: simple-pod
  namespace: default
  labels:
    app: web
spec:
  containers:
  - name: nginx
    image: nginx:1.21
    ports:
    - containerPort: 80
  restartPolicy: Always

# Deploy pod
kubectl apply -f pod.yaml

# Check pod status
kubectl get pods
kubectl describe pod simple-pod
kubectl logs simple-pod

# Execute command inside pod
kubectl exec -it simple-pod -- /bin/bash

# Delete pod
kubectl delete pod simple-pod

Deployments

Deployments mengelola replika pod dengan kemampuan rollout dan rollback otomatis. Ini adalah cara utama untuk mengelola aplikasi stateless.

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3  # 3 pod instances
  selector:
    matchLabels:
      app: nginx
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1        # 1 pod lebih dari desired
      maxUnavailable: 0  # 0 pod unavailable
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.21
        ports:
        - containerPort: 80
        resources:
          requests:
            memory: "64Mi"
            cpu: "100m"
          limits:
            memory: "128Mi"
            cpu: "200m"

# Deploy
kubectl apply -f deployment.yaml

# Check rollout status
kubectl rollout status deployment/nginx-deployment

# Update image (trigger rolling update)
kubectl set image deployment/nginx-deployment \
  nginx=nginx:1.22 --record

# View rollout history
kubectl rollout history deployment/nginx-deployment

# Rollback ke version sebelumnya
kubectl rollout undo deployment/nginx-deployment

Services

Service adalah abstraksi yang mengekspos aplikasi yang berjalan di pods dengan IP statis dan nama DNS. Service membuat jaringan yang stabil untuk aplikasi.

# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  type: LoadBalancer  # atau ClusterIP, NodePort
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
    nodePort: 30000  # hanya untuk NodePort

Service Types:

• ClusterIP: Internal service, accessible hanya dari dalam cluster
• NodePort: Expose service pada port node, accessible externally
• LoadBalancer: Cloud provider load balancer yang distribute traffic
• ExternalName: Map service ke external DNS name

# Create service
kubectl apply -f service.yaml

# Get service info
kubectl get service
kubectl describe service nginx-service

# Port forward untuk local testing
kubectl port-forward service/nginx-service 8080:80
# Sekarang accessible di http://localhost:8080

StatefulSets dan DaemonSets

Selain Deployments, ada jenis workload khusus untuk use case tertentu.

StatefulSets

StatefulSets mengelola aplikasi stateful dengan identitas jaringan statis dan penyimpanan persisten.

# statefulset.yaml
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mysql
spec:
  serviceName: mysql  # Headless service
  replicas: 3
  selector:
    matchLabels:
      app: mysql
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - name: mysql
        image: mysql:8.0
        ports:
        - containerPort: 3306
        volumeMounts:
        - name: data
          mountPath: /var/lib/mysql
  volumeClaimTemplates:
  - metadata:
      name: data
    spec:
      accessModes: [ "ReadWriteOnce" ]
      storageClassName: fast-ssd
      resources:
        requests:
          storage: 10Gi

Pods akan dinamai sebagai: mysql-0, mysql-1, mysql-2 (identitas tetap).

DaemonSets

DaemonSet memastikan setiap node menjalankan salinan pod (untuk logging, monitoring, dll).

# daemonset.yaml
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: fluentd
  namespace: kube-system
spec:
  selector:
    matchLabels:
      name: fluentd
  template:
    metadata:
      labels:
        name: fluentd
    spec:
      containers:
      - name: fluentd
        image: fluent/fluentd:v1.14
        volumeMounts:
        - name: varlog
          mountPath: /var/log
      volumes:
      - name: varlog
        hostPath:
          path: /var/log

ConfigMaps dan Secrets

ConfigMaps

ConfigMaps berfungsi untuk menyimpan data konfigurasi umum atau non-sensitif.

# configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  APP_ENV: production
  LOG_LEVEL: info
  config.yaml: |
    database:
      host: db.example.com
      port: 5432

# Menggunakan ConfigMap di pod
apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
  - name: app
    image: myapp:1.0
    env:
    - name: APP_ENV
      valueFrom:
        configMapKeyRef:
          name: app-config
          key: APP_ENV
    volumeMounts:
    - name: config
      mountPath: /etc/config
  volumes:
  - name: config
    configMap:
      name: app-config

Secrets

Secrets berfungsi untuk menyimpan data sensitif seperti kata sandi, API key, kredensial.

# secret.yaml
apiVersion: v1
kind: Secret
metadata:
  name: db-credentials
type: Opaque
stringData:
  username: admin
  password: secretpassword123
  # Atau base64 encoded:
  # data:
  #   username: YWRtaW4=
  #   password: c2VjcmV0cGFzc3dvcmQxMjM=

# Menggunakan Secret
apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
  - name: app
    image: myapp:1.0
    env:
    - name: DB_USER
      valueFrom:
        secretKeyRef:
          name: db-credentials
          key: username
    - name: DB_PASS
      valueFrom:
        secretKeyRef:
          name: db-credentials
          key: password

Storage dan Persistence

Karena Pods bersifat ephemeral (berubah-ubah) dan stateless, maka untuk menyimpan data secara persisten, Kubernetes menyediakan PersistentVolumes (PV) dan PersistentVolumeClaims (PVC).

PersistentVolume (PV) dan PersistentVolumeClaim (PVC)

PV adalah representasi fisik penyimpanan (seperti disk lokal, NFS, cloud storage), sedangkan PVC adalah cara aplikasi untuk meminta penyimpanan tanpa mengetahui detail teknisnya.

# persistent-volume.yaml
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-local
spec:
  capacity:
    storage: 20Gi
  accessModes:
    - ReadWriteOnce
  storageClassName: local-storage
  hostPath:
    path: /mnt/data

---
# persistent-volume-claim.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-local
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: local-storage
  resources:
    requests:
      storage: 10Gi

---
# Pod menggunakan PVC
apiVersion: v1
kind: Pod
metadata:
  name: app-with-storage
spec:
  containers:
  - name: app
    image: myapp:1.0
    volumeMounts:
    - name: data
      mountPath: /data
  volumes:
  - name: data
    persistentVolumeClaim:
      claimName: pvc-local

Networking dan Ingress

Network Policies

Network Policies mengontrol lalu lintas jaringan antar pod untuk keamanan.

# network-policy.yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress

---
# Allow traffic from specific pods
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-to-backend
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: frontend
    ports:
    - protocol: TCP
      port: 8080

Ingress

Ingress mengelola akses HTTP(S) eksternal ke services dalam klaster.

# ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: app-ingress
  annotations:
    cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - app.example.com
    secretName: app-tls
  rules:
  - host: app.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: app-service
            port:
              number: 80
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: api-service
            port:
              number: 3000

Resource Management dan Limits

Limit dan request sumber daya membantu mengelola penggunaan CPU dan memori di cluster.

# resource-limits.yaml
apiVersion: v1
kind: Pod
metadata:
  name: resource-managed-pod
spec:
  containers:
  - name: app
    image: myapp:1.0
    resources:
      # Minimum resources yang dijamin
      requests:
        memory: "128Mi"
        cpu: "100m"
      # Maximum resources yang allowed
      limits:
        memory: "256Mi"
        cpu: "500m"

# namespace-quota.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: production

---
apiVersion: v1
kind: ResourceQuota
metadata:
  name: compute-quota
  namespace: production
spec:
  hard:
    requests.cpu: "10"
    requests.memory: 20Gi
    limits.cpu: "20"
    limits.memory: 40Gi
    pods: "100"

Health Checks dan Auto-Healing

Sebaiknya aplikasi di Kubernetes memiliki health checks untuk memastikan ketersediaan dan keandalan. Health checks meliputi:

• Liveness Probe: Memeriksa apakah aplikasi berjalan. Jika gagal, pod di-restart.
• Readiness Probe: Memeriksa apakah aplikasi siap menerima traffic. Jika gagal, pod dihapus dari service endpoints.
• Startup Probe: Memeriksa apakah aplikasi telah berhasil memulai

# health-checks.yaml
apiVersion: v1
kind: Pod
metadata:
  name: app-with-health-checks
spec:
  containers:
  - name: app
    image: myapp:1.0
    livenessProbe:
      httpGet:
        path: /health
        port: 8080
      initialDelaySeconds: 10
      periodSeconds: 10
      failureThreshold: 3
    readinessProbe:
      httpGet:
        path: /ready
        port: 8080
      initialDelaySeconds: 5
      periodSeconds: 5
    startupProbe:
      tcpSocket:
        port: 8080
      failureThreshold: 30
      periodSeconds: 10

Scaling dan Auto-Scaling

Salah satu fitur utama Kubernetes adalah kemampuannya untuk menskalakan aplikasi berdasarkan kebutuhan. Kubernetes mendukung scaling manual dan otomatis melalui Horizontal Pod Autoscaler (HPA). Kedua metode ini membantu memastikan aplikasi tetap responsif di bawah beban yang bervariasi.

HPA memantau metrik seperti penggunaan CPU dan memori untuk menyesuaikan jumlah replika pod secara otomatis. Sehingga, aplikasi dapat menangani lonjakan lalu lintas tanpa intervensi manual. Tetapi jika diperlukan kontrol lebih besar, scaling manual juga tersedia.

Manual Scaling

Untuk menskalakan deployment secara manual, Kamu dapat menggunakan perintah kubectl scale. Misalnya, untuk mengubah jumlah replika dari 3 menjadi 5:

# Scale deployment ke 5 replicas
kubectl scale deployment nginx-deployment --replicas=5

Horizontal Pod Autoscaler (HPA)

Pada aplikasi tertentu, Kamu mungkin ingin mengotomatisasi proses scaling berdasarkan metrik kinerja. HPA memungkinkan Kamu untuk menetapkan target penggunaan sumber daya, dan Kubernetes akan menyesuaikan jumlah pod sesuai kebutuhan. Contohnya pada aplikasi ecommerce yang mengalami lonjakan traffic selama flash sale.

Contoh konfigurasi HPA yang menskalakan deployment myapp antara 2 hingga 10 replika berdasarkan penggunaan CPU dan memori:

# hpa.yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myapp
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80

Security Best Practices

Setiap aplikasi yang berjalan di Kubernetes harus mempertimbangkan aspek keamanan. Berikut adalah beberapa praktik terbaik untuk meningkatkan keamanan aplikasi Kamu:

# secure-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: secure-pod
spec:
  securityContext:
    runAsNonRoot: true
    runAsUser: 1000
  containers:
  - name: app
    image: myapp:1.0
    securityContext:
      allowPrivilegeEscalation: false
      readOnlyRootFilesystem: true
      capabilities:
        drop:
        - ALL
    volumeMounts:
    - name: tmp
      mountPath: /tmp
  volumes:
  - name: tmp
    emptyDir: {}

Monitoring dan Logging

Semakin kompleks aplikasi di Kubernetes, semakin penting untuk memiliki sistem monitoring dan logging yang efektif. Alat seperti Prometheus untuk monitoring dan Grafana untuk visualisasi data sangat populer di kalangan pengguna Kubernetes.

# monitoring setup dengan Prometheus
apiVersion: v1
kind: Service
metadata:
  name: prometheus
  labels:
    app: prometheus
spec:
  ports:
  - port: 9090
  selector:
    app: prometheus

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: prometheus
spec:
  replicas: 1
  selector:
    matchLabels:
      app: prometheus
  template:
    metadata:
      labels:
        app: prometheus
    spec:
      containers:
      - name: prometheus
        image: prom/prometheus:latest
        ports:
        - containerPort: 9090

Kesimpulan

Kubernetes adalah platform yang powerful untuk orchestration aplikasi yang dikontainerisasi di environment production. Dengan memahami konsep-konsep inti seperti Pods, Deployments, Services, StatefulSets, ConfigMaps, Secrets, dan networking, Kamu memiliki pondasi yang kuat untuk membangun aplikasi yang scalable dan tangguh.

Checklist untuk Production Kubernetes Deployment:

• ✓ Implementasikan resource requests dan limits
• ✓ Setup health checks (liveness, readiness, startup probes)
• ✓ Configure HPA untuk automatic scaling
• ✓ Implementasikan Network Policies untuk security
• ✓ Setup monitoring dengan Prometheus dan Grafana
• ✓ Configure logging dengan ELK atau Loki
• ✓ Backup etcd regularly
• ✓ Implement security policies dan RBAC
• ✓ Regular cluster updates dan patching
• ✓ Disaster recovery planning

Kubernetes adalah masa depan deployment cloud!