# 使用輕量基底映像
FROM node:18-alpine

WORKDIR /app

# 先複製 package.json（利用 Layer Cache 加速 build）
COPY package*.json ./
RUN npm ci --only=production

# 再複製程式碼（變動頻繁，放最後）
COPY . .

# 非 root 用戶執行（安全性）
USER node

EXPOSE 3000
CMD ["node", "server.js"]

# Stage 1：編譯
FROM golang:1.21 AS builder
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 go build -o server .

# Stage 2：只保留執行檔
FROM scratch
COPY --from=builder /app/server /server
ENTRYPOINT ["/server"]

docker build -t my-app:v1 .          # 建立映像
docker run -d -p 8080:3000 my-app:v1  # 後台執行
docker logs -f my-container           # 追蹤日誌
docker exec -it my-container sh        # 進入容器
docker ps                              # 列出運行中容器
docker images                          # 列出本地映像
docker system prune -af               # 清理未使用資源

version: '3.8'
services:
  app:
    build: .
    ports:
      - "8080:3000"
    environment:
      - DB_HOST=db
      - REDIS_HOST=redis
    depends_on:
      - db
      - redis

  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_PASSWORD: secret
    volumes:
      - db_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    command: redis-server --requirepass secret

volumes:
  db_data:

Cluster
├── Control Plane（主節點）
│   ├── API Server      ← 所有操作的入口
│   ├── etcd            ← 儲存叢集狀態（key-value）
│   ├── Scheduler       ← 決定 Pod 要跑在哪個 Node
│   └── Controller Manager ← 確保叢集狀態符合期望
└── Worker Node（工作節點）
    ├── kubelet         ← 管理此節點上的 Pod
    ├── kube-proxy      ← 處理網路規則
    └── Container Runtime (containerd)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  namespace: production
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1   # 更新時最多 1 個 Pod 不可用
      maxSurge: 1         # 更新時最多多建 1 個 Pod
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: my-app:v2
        ports:
        - containerPort: 3000
        resources:
          requests:
            cpu: "250m"
            memory: "128Mi"
          limits:
            cpu: "500m"
            memory: "256Mi"
        readinessProbe:        # 就緒探針：Pod 準備好接流量了嗎？
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 10
        livenessProbe:         # 存活探針：Pod 還活著嗎？不健康就重啟
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 15
          periodSeconds: 20

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: my-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-app
  minReplicas: 2
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 65
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 75

# 查看資源
kubectl get pods -n production
kubectl get deployments,services -n production
kubectl get all -n production

# 除錯
kubectl logs -f my-pod -n production --previous  # 上一次崩潰的日誌
kubectl describe pod my-pod -n production         # 詳細資訊與 Events
kubectl exec -it my-pod -n production -- sh       # 進入 Pod

# 部署操作
kubectl set image deployment/my-app my-app=my-app:v3 -n production
kubectl rollout status deployment/my-app -n production
kubectl rollout undo deployment/my-app -n production            # 回滾到上一版
kubectl rollout undo deployment/my-app --to-revision=2          # 回滾到指定版本
kubectl rollout history deployment/my-app -n production

# 擴縮
kubectl scale deployment/my-app --replicas=5 -n production

# 強制刪除卡住的 Pod
kubectl delete pod my-pod -n production --grace-period=0 --force

總 CPU    ≈ QPS × 每次請求的 CPU 消耗
總 Memory ≈ 基礎記憶體 + (並發數 × 每次請求的記憶體)

並發數 = QPS × 平均回應時間（秒）

並發數 = 500 × 0.2 = 100 個同時進行的請求

CPU per request    = 負載測試時總 CPU 使用量 / QPS
Memory per request ≈ (峰值記憶體 - 基礎記憶體) / 並發數

總 CPU    = QPS × CPU per request  × 安全係數（1.5～2）
總 Memory = (基礎記憶體 + 並發數 × Memory per request) × 安全係數（1.3～1.5）

resources:
  requests:
    cpu: "500m"
    memory: "64Mi"
  limits:
    cpu: "1000m"
    memory: "128Mi"

程式碼提交（PR）
  → Lint / Static Analysis（程式碼品質）
  → Unit Test（單元測試）
  → Build & Package（Docker Image）
  → Integration Test（整合測試）
  → Push to Registry（推送映像）
  → Deploy to Staging（部署測試環境）
  → Smoke Test / E2E Test（驗收測試）
  → 手動審核（Production Gate）
  → Deploy to Production（部署正式環境）
  → 監控觀察（告警、回滾機制）

name: CI/CD Pipeline

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '18'
          cache: 'npm'
      - run: npm ci
      - run: npm run lint
      - run: npm test -- --coverage

  build:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v4
      - name: Build and push Docker image
        env:
          IMAGE_TAG: ${{ github.sha }}
        run: |
          docker build -t my-app:$IMAGE_TAG .
          docker push my-app:$IMAGE_TAG

  deploy-staging:
    needs: build
    runs-on: ubuntu-latest
    environment: staging
    steps:
      - name: Deploy to Staging
        run: |
          kubectl set image deployment/my-app \
            my-app=my-app:${{ github.sha }} -n staging
          kubectl rollout status deployment/my-app -n staging

  deploy-prod:
    needs: deploy-staging
    runs-on: ubuntu-latest
    environment: production      # 需要手動審核
    steps:
      - name: Deploy to Production
        run: |
          kubectl set image deployment/my-app \
            my-app=my-app:${{ github.sha }} -n production

groups:
- name: app-alerts
  rules:
  - alert: HighErrorRate
    expr: |
      rate(http_requests_total{status=~"5.."}[5m])
      / rate(http_requests_total[5m]) > 0.05
    for: 2m
    labels:
      severity: critical
    annotations:
      summary: "HTTP 5xx 錯誤率超過 5%"
      runbook: "https://wiki.internal/runbooks/high-error-rate"

  - alert: HighP99Latency
    expr: |
      histogram_quantile(0.99,
        rate(http_request_duration_seconds_bucket[5m])) > 2
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "P99 延遲超過 2 秒"

  - alert: PodCrashLooping
    expr: rate(kube_pod_container_status_restarts_total[15m]) > 0
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "Pod {{ $labels.pod }} 持續重啟"

錯誤預算 = 100% - SLO

SLO = 99.9% 可用性
→ 每月允許停機時間 = 30天 × 24h × 60m × 0.1% ≈ 43 分鐘

偵測（Detection）
  → 告警觸發 or 用戶回報
  
分類（Triage）
  → 評估影響範圍和嚴重程度
  → 指定事故指揮官（Incident Commander）

緩解（Mitigation）— 先止血，再找根因
  → 回滾部署？擴容？切換流量？

根本原因分析（Root Cause Analysis）
  → 5 Whys 分析

事後檢討（Post-mortem）
  → 無責備文化（Blameless）
  → 記錄時間線、影響、根因、改善行動

瀏覽器輸入 www.example.com
  → 查本地 Cache（/etc/hosts、瀏覽器）
  → 查本地 DNS Resolver（通常是路由器或 ISP）
  → 查 Root Name Server（.）
  → 查 TLD Name Server（.com）
  → 查 Authoritative Name Server（example.com）
  → 取得 IP 位址，建立連線

外部流量
  → LoadBalancer Service / Ingress Controller
  → Service（ClusterIP，kube-proxy 做 DNAT）
  → Pod（每個 Pod 有獨立 IP）

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  tls:
  - hosts:
    - api.example.com
    secretName: tls-secret
  rules:
  - host: api.example.com
    http:
      paths:
      - path: /users
        pathType: Prefix
        backend:
          service:
            name: user-service
            port:
              number: 80
      - path: /orders
        pathType: Prefix
        backend:
          service:
            name: order-service
            port:
              number: 80

# 查看進程
ps aux | grep my-app          # 列出所有進程
top / htop                    # 動態查看系統資源使用
kill -9 <PID>                 # 強制終止進程
lsof -i :8080                 # 查看佔用 8080 端口的進程

# 系統資源
free -h                       # 記憶體使用
df -h                         # 磁碟使用
du -sh /var/log/*             # 目錄大小
vmstat 1                      # 系統虛擬記憶體統計

# CPU 和負載
uptime                        # 系統負載（load average）
nproc                         # CPU 核心數

# 連線測試
ping -c 4 google.com
curl -v https://api.example.com/health    # 測試 HTTP 請求
curl -o /dev/null -s -w "%{http_code}\n" https://example.com

# 網路資訊
netstat -tlnp                 # 查看監聽中的端口
ss -tlnp                      # 更快的 netstat 替代
ip addr                       # 查看網路介面和 IP
traceroute google.com         # 追蹤路由路徑
nslookup / dig example.com    # DNS 查詢

# 防火牆
iptables -L                   # 列出防火牆規則

# 查看日誌
tail -f /var/log/nginx/access.log      # 追蹤日誌
journalctl -u nginx -f                 # systemd 服務日誌
journalctl --since "2024-01-01 00:00"  # 指定時間範圍

# 搜尋
grep -r "ERROR" /var/log/ --include="*.log"
grep -c "500" access.log               # 計算出現次數
awk '{print $1}' access.log | sort | uniq -c | sort -rn  # 統計最多的 IP

# 文件操作
find / -name "*.log" -mtime +30 -delete    # 刪除 30 天前的日誌
tar -czf backup.tar.gz /etc/nginx/         # 壓縮備份

uptime 輸出：load average: 1.23, 0.95, 0.88
              最近1分鐘  最近5分鐘  最近15分鐘

規則：值 ≈ CPU 核心數 表示滿載；> 核心數 表示過載

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pvc
spec:
  accessModes:
    - ReadWriteOnce          # 只能被一個 Node 掛載
  storageClassName: standard
  resources:
    requests:
      storage: 10Gi

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mysql
spec:
  serviceName: mysql
  replicas: 3
  selector:
    matchLabels:
      app: mysql
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - name: mysql
        image: mysql:8.0
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysql-secret
              key: password
        volumeMounts:
        - name: data
          mountPath: /var/lib/mysql
  volumeClaimTemplates:         # 為每個 Pod 自動建立 PVC
  - metadata:
      name: data
    spec:
      accessModes: ["ReadWriteOnce"]
      resources:
        requests:
          storage: 20Gi

傳統 CI/CD（Push 模式）：
CI Pipeline → kubectl apply → Cluster
（CI 有 K8s 憑證，安全風險較高）

GitOps（Pull 模式）：
開發者 → Git Commit → Git Repo
                          ↑ 持續 diff
                       ArgoCD/Flux（在叢集內）→ 自動同步

# ArgoCD Application 定義
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/my-org/my-app-config
    targetRevision: main
    path: k8s/production           # Git repo 中 YAML 檔案的路徑
  destination:
    server: https://kubernetes.default.svc
    namespace: production
  syncPolicy:
    automated:
      prune: true                  # 自動刪除 Git 中已移除的資源
      selfHeal: true               # 有人手動修改叢集時自動還原
    syncOptions:
    - CreateNamespace=true

1. 開發者修改應用程式碼
   → 觸發 CI Pipeline（測試、建立 Docker Image、推送到 Registry）
   → CI 自動更新 Config Repo 中的 image tag

2. Config Repo 收到新 commit
   → ArgoCD 偵測到差異（Sync Status: OutOfSync）
   → ArgoCD 自動或手動同步到 K8s Cluster

3. 需要回滾？
   → git revert 到上一個 commit
   → ArgoCD 自動同步，叢集回到舊版本

# 定義 Role（限定在特定 Namespace）
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: pod-reader
  namespace: production
rules:
- apiGroups: [""]
  resources: ["pods", "pods/log"]
  verbs: ["get", "list", "watch"]   # 只能讀，不能修改

---
# 將 Role 綁定給 ServiceAccount
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods-binding
  namespace: production
subjects:
- kind: ServiceAccount
  name: my-app-sa
  namespace: production
roleRef:
  kind: Role
  apiGroup: rbac.authorization.k8s.io
  name: pod-reader

# 只允許來自 frontend namespace 的流量進入 backend
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-only
  namespace: backend
spec:
  podSelector:
    matchLabels:
      app: backend-api
  policyTypes:
  - Ingress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: frontend
    ports:
    - protocol: TCP
      port: 8080

spec:
  securityContext:
    runAsNonRoot: true           # 禁止以 root 執行
    runAsUser: 1000
    fsGroup: 2000
  containers:
  - name: my-app
    securityContext:
      allowPrivilegeEscalation: false  # 禁止提權
      readOnlyRootFilesystem: true     # 根目錄唯讀
      capabilities:
        drop:
        - ALL                          # 移除所有 Linux capabilities

# 宣告 Provider
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
  # 將狀態存在遠端（多人協作必須）
  backend "s3" {
    bucket = "my-tf-state"
    key    = "production/terraform.tfstate"
    region = "us-east-1"
  }
}

# 建立 VPC
resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
  tags = {
    Name        = "main-vpc"
    Environment = "production"
  }
}

# 輸出資源資訊
output "vpc_id" {
  value = aws_vpc.main.id
}

terraform init      # 初始化，下載 providers
terraform plan      # 預覽變更（不實際執行）
terraform apply     # 執行變更
terraform destroy   # 銷毀所有資源（謹慎使用）
terraform import    # 將既有資源納入 Terraform 管理
terraform state list  # 查看目前管理的資源

helm repo add bitnami https://charts.bitnami.com/bitnami
helm repo update

# 安裝，並覆寫預設值
helm install my-redis bitnami/redis \
  --namespace production \
  --create-namespace \
  --set auth.password=secret \
  --set replica.replicaCount=2

helm upgrade my-redis bitnami/redis --set image.tag=7.2  # 升級
helm rollback my-redis 1                                   # 回滾到版本 1
helm list -n production                                    # 查看安裝的 release
helm uninstall my-redis -n production                     # 卸載

Deployment（管理更新策略與版本）
  └── ReplicaSet（確保指定數量的 Pod 在運行）
       └── Pod（實際執行的容器，最小部署單位）

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: my-app-pdb
spec:
  minAvailable: 2    # 或 maxUnavailable: 1
  selector:
    matchLabels:
      app: my-app