Cheatsheet Docker & Kubernetes: Command Line, YAML, dan Best Practices

# Buat custom bridge network
docker network create mynet

# List semua network
docker network ls

# Hubungkan container ke network
docker network connect mynet container_id

# Putuskan container dari network
docker network disconnect mynet container_id

# Inspect network
docker network inspect mynet

# Hapus network
docker network rm mynet

# Jalankan container di custom network
docker run -d --name app --network mynet myapp:v1

# Container di network yang sama bisa saling reach via nama
# Contoh: dari container 'app' bisa ping 'db' jika satu network
docker exec app ping db

# Buat named volume
docker volume create mydata

# List semua volume
docker volume ls

# Inspect volume
docker volume inspect mydata

# Hapus volume
docker volume rm mydata

# Hapus semua volume tidak terpakai
docker volume prune

# Contoh penggunaan dengan container
docker run -d --name db \
  -v pgdata:/var/lib/postgresql/data \
  -e POSTGRES_PASSWORD=secret \
  postgres:16

# Bind mount untuk development
docker run -d --name dev \
  -v $(pwd)/src:/app/src \
  -p 3000:3000 \
  node:20 npm run dev

# Stage 1: Build
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
RUN npm run build

# Stage 2: Production
FROM node:20-alpine
WORKDIR /app
RUN addgroup -g 1001 appgroup && adduser -u 1001 -G appgroup -s /bin/sh -D appuser
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package.json ./
USER appuser
EXPOSE 3000
HEALTHCHECK --interval=30s --timeout=3s CMD wget -qO- http://localhost:3000/health || exit 1
CMD ["node", "dist/server.js"]

version: "3.9"

services:
  web:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - DB_HOST=db
      - DB_PORT=5432
    depends_on:
      db:
        condition: service_healthy
    networks:
      - appnet
    restart: unless-stopped

  db:
    image: postgres:16-alpine
    volumes:
      - pgdata:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U admin"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - appnet

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redisdata:/data
    networks:
      - appnet

volumes:
  pgdata:
  redisdata:

networks:
  appnet:
    driver: bridge

# Lihat context saat ini
kubectl config current-context

# Ganti context
kubectl config use-context my-cluster

# List semua context
kubectl config get-contexts

# Set namespace default
kubectl config set-context --current --namespace=my-ns

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
  namespace: default
  labels:
    app: web
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: web
          image: myapp:v1.2.0
          ports:
            - containerPort: 3000
          env:
            - name: NODE_ENV
              value: "production"
            - name: DB_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: db-secret
                  key: password
          resources:
            requests:
              cpu: "100m"
              memory: "128Mi"
            limits:
              cpu: "500m"
              memory: "256Mi"
          livenessProbe:
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 15
            periodSeconds: 10
          readinessProbe:
            httpGet:
              path: /ready
              port: 3000
            initialDelaySeconds: 5
            periodSeconds: 5

apiVersion: v1
kind: Service
metadata:
  name: web-service
  namespace: default
spec:
  selector:
    app: web
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 80
      targetPort: 3000
---
# Service type LoadBalancer (expose ke internet)
apiVersion: v1
kind: Service
metadata:
  name: web-lb
spec:
  selector:
    app: web
  type: LoadBalancer
  ports:
    - protocol: TCP
      port: 80
      targetPort: 3000

# Update image deployment
kubectl set image deploy/web web=myapp:v1.3.0

# Cek status rollout
kubectl rollout status deploy/web

# Lihat history revisi
kubectl rollout history deploy/web

# Lihat detail revisi tertentu
kubectl rollout history deploy/web --revision=2

# Rollback ke revisi sebelumnya
kubectl rollout undo deploy/web

# Rollback ke revisi tertentu
kubectl rollout undo deploy/web --to-revision=3

# Pause rollout (untuk multi-update sekaligus)
kubectl rollout pause deploy/web

# Resume rollout
kubectl rollout resume deploy/web

# Contoh resource spec di Deployment
resources:
  requests:
    cpu: "250m"       # Minimum yang dijamin
    memory: "256Mi"
  limits:
    cpu: "1000m"      # Maksimum yang diizinkan
    memory: "512Mi"

# Jika melebihi limit:
# - CPU: di-throttle (diperlambat)
# - Memory: OOMKilled (pod di-kill)

apiVersion: v1
kind: ResourceQuota
metadata:
  name: dev-quota
  namespace: dev
spec:
  hard:
    requests.cpu: "4"
    requests.memory: "8Gi"
    limits.cpu: "8"
    limits.memory: "16Gi"
    pods: "20"

# Buat ConfigMap dari literal
kubectl create configmap app-config \
  --from-literal=DB_HOST=postgres \
  --from-literal=DB_PORT=5432 \
  --from-literal=CACHE_TTL=300

# Buat ConfigMap dari file
kubectl create configmap nginx-conf \
  --from-file=nginx.conf

# YAML ConfigMap
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  DB_HOST: "postgres"
  DB_PORT: "5432"
  CACHE_TTL: "300"
  nginx.conf: |
    server {
      listen 80;
      location / {
        proxy_pass http://web:3000;
      }
    }

# Buat Secret dari literal
kubectl create secret generic db-secret \
  --from-literal=username=admin \
  --from-literal=password=s3cretP@ss

# Buat Secret dari file
kubectl create secret generic tls-secret \
  --from-file=tls.crt=server.crt \
  --from-file=tls.key=server.key

# YAML Secret (nilai harus base64 encoded)
apiVersion: v1
kind: Secret
metadata:
  name: db-secret
type: Opaque
data:
  username: YWRtaW4=        # echo -n 'admin' | base64
  password: czNjcmV0UEBzcw==  # echo -n 's3cretP@ss' | base64

# Sebagai environment variable
env:
  - name: DB_HOST
    valueFrom:
      configMapKeyRef:
        name: app-config
        key: DB_HOST
  - name: DB_PASSWORD
    valueFrom:
      secretKeyRef:
        name: db-secret
        key: password

# Sebagai volume mount
volumes:
  - name: config-vol
    configMap:
      name: nginx-conf
containers:
  - name: nginx
    volumeMounts:
      - name: config-vol
        mountPath: /etc/nginx/conf.d