# 1. 创建一些测试 Pod 分散在不同节点
kubectl create deploy test-app --image=nginx:alpine --replicas=5

# 2. 部署 DaemonSet 日志采集器
cat <<'EOF' | kubectl apply -f -
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: log-collector
spec:
  selector:
    matchLabels:
      app: log-collector
  template:
    metadata:
      labels:
        app: log-collector
    spec:
      containers:
      - name: collector
        image: busybox:1.36
        command:
        - sh
        - -c
        - |
          mkdir -p /host-data
          while true; do
            echo "[$(date)] Host: $(hostname)" >> /host-data/collector.log
            sleep 5
          done
        volumeMounts:
        - name: host-logs
          mountPath: /host-data
      volumes:
      - name: host-logs
        hostPath:
          path: /tmp/collector-logs
          type: DirectoryOrCreate
EOF

# 3. 验证每个节点都有一个 Pod
kubectl get pod -l app=log-collector -o wide
# 预期：3 个 Pod（每节点 1 个）

# 4. 验证数据写入
# 登录任一 worker 节点
ssh k8s-node1
cat /tmp/collector-logs/collector.log
# 看到采集日志

# 5. 查看 DaemonSet 状态
kubectl get ds log-collector
# DESIRED=3  CURRENT=3  READY=3

# 6. 清理
kubectl delete ds log-collector
kubectl delete deploy test-app

# 1. 先创建 Headless Service（必须！）
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Service
metadata:
  name: nginx-sts
spec:
  clusterIP: None          # Headless Service 的关键！
  selector:
    app: nginx-sts
  ports:
  - port: 80
    targetPort: 80
EOF

# 2. 部署 StatefulSet
cat <<'EOF' | kubectl apply -f -
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: nginx-sts
spec:
  serviceName: nginx-sts
  replicas: 3
  selector:
    matchLabels:
      app: nginx-sts
  template:
    metadata:
      labels:
        app: nginx-sts
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        ports:
        - containerPort: 80
        volumeMounts:
        - name: data
          mountPath: /usr/share/nginx/html
  volumeClaimTemplates:
  - metadata:
      name: data
    spec:
      accessModes: ["ReadWriteOnce"]
      resources:
        requests:
          storage: 100Mi
EOF

# 3. 观察顺序创建（0→1→2）
kubectl get pod -l app=nginx-sts -w
# nginx-sts-0  Running
# nginx-sts-1  Running
# nginx-sts-2  Running

# 4. 验证网络标识
kubectl exec nginx-sts-0 -- hostname
# nginx-sts-0

kubectl run dns-test --image=busybox:1.36 --rm -it --restart=Never -- \
  nslookup nginx-sts-0.nginx-sts.default.svc.cluster.local
# 返回 Pod IP

# 5. 验证 PVC 自动创建
kubectl get pvc
# 每个 Pod 独立 PVC：data-nginx-sts-0, data-nginx-sts-1, data-nginx-sts-2

# 6. 写入数据验证持久性
kubectl exec nginx-sts-0 -- sh -c 'echo "pod-0-data" > /usr/share/nginx/html/data.txt'

# 7. 删除 Pod 观察重建
kubectl delete pod nginx-sts-0
kubectl get pod nginx-sts-0 -w
# Pod 重建后名称仍然是 nginx-sts-0

# 8. 验证数据仍在（PVC 绑定未变）
kubectl exec nginx-sts-0 -- cat /usr/share/nginx/html/data.txt
# 输出：pod-0-data

# 9. 顺序缩容
kubectl scale sts nginx-sts --replicas=1
kubectl get pod -l app=nginx-sts -w
# 逆序终止：nginx-sts-2 Terminating → nginx-sts-1 Terminating

# 10. 扩容
kubectl scale sts nginx-sts --replicas=3

# 11. 清理
kubectl delete sts nginx-sts
kubectl delete svc nginx-sts
# ⚠️ PVC 不会自动删除，需要手动清理
kubectl delete pvc data-nginx-sts-0 data-nginx-sts-1 data-nginx-sts-2

# 1. 基础 Job
cat <<EOF | kubectl apply -f -
apiVersion: batch/v1
kind: Job
metadata:
  name: compute-pi
spec:
  template:
    spec:
      containers:
      - name: pi
        image: perl:5.34
        command:
        - perl
        - -Mbignum=bpi
        - -wle
        - print bpi(200)
      restartPolicy: Never
  backoffLimit: 4
EOF

# 2. 观察 Job 执行
kubectl get job compute-pi -w
# COMPLETIONS 从 0/1 → 1/1

kubectl get pod -l job-name=compute-pi
# Pod 状态 Completed

# 3. 查看计算结果
kubectl logs job/compute-pi
# 输出 π 值

# 4. 并行 Job
cat <<'EOF' | kubectl apply -f -
apiVersion: batch/v1
kind: Job
metadata:
  name: parallel-job
spec:
  completions: 6
  parallelism: 2
  template:
    spec:
      containers:
      - name: worker
        image: busybox:1.36
        command:
        - sh
        - -c
        - |
          echo "Task $((JOB_COMPLETION_INDEX+1)) running on $(hostname)"
          sleep $(( RANDOM % 10 ))
          echo "Task done"
      restartPolicy: Never
  backoffLimit: 4
EOF

# 5. 观察并行执行
kubectl get pod -l job-name=parallel-job -w
# 每次最多 2 个 Pod 同时运行

kubectl get job parallel-job
# COMPLETIONS: 6/6

# 6. 清理
kubectl delete job compute-pi parallel-job

# 1. 创建每分钟执行的 CronJob
cat <<EOF | kubectl apply -f -
apiVersion: batch/v1
kind: CronJob
metadata:
  name: health-checker
spec:
  schedule: "*/1 * * * *"
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: checker
            image: busybox:1.36
            command:
            - sh
            - -c
            - |
              echo "[$(date)] Health check executed"
              echo "Checking DNS..."
              nslookup kubernetes.default.svc.cluster.local
              echo "OK"
          restartPolicy: Never
      backoffLimit: 2
EOF

# 2. 查看 CronJob
kubectl get cj
kubectl describe cj health-checker

# 3. 等待 1～2 分钟，查看自动创建的 Job
kubectl get jobs
# 看到 health-checker-<timestamp>

# 4. 查看 Job 创建的 Pod
kubectl get pod -l job-name

# 5. 查看日志
kubectl logs job/health-checker-<timestamp>

# 6. 手动触发一次（不再等待定时器）
kubectl create job --from=cronjob/health-checker manual-run

# 7. 查看手动任务的日志
kubectl logs job/manual-run

# 8. 清理
kubectl delete cj health-checker
kubectl delete job manual-run

# 原因 1：PVC 无法绑定
kubectl get pvc
# STATUS: Pending

kubectl describe pvc <pvc-name>
# 看到 "no persistent volumes available..."

# 解决方案：
# - 检查 StorageClass 是否存在：kubectl get sc
# - 创建 PV 或确保 default StorageClass 可用

# 排查步骤

# 1. 检查 CronJob 配置
kubectl describe cj <name>
# 查看 Last Schedule Time

# 2. 检查 concurrencyPolicy
kubectl get cj <name> -o yaml | grep concurrencyPolicy
# Allow / Forbid / Replace

# 3. 检查 startingDeadlineSeconds
kubectl get cj <name> -o yaml | grep startingDeadlineSeconds

# 4. 检查 Job 是否被创建
kubectl get jobs --sort-by=.metadata.creationTimestamp

# 常见原因：
# - schedule 语法错误
# - concurrencyPolicy=Forbid 且上一次 Job 未完成
# - startingDeadlineSeconds 过期

# 1. 创建 Deployment（3 副本）
kubectl create deploy nginx --image=nginx:1.21 --replicas=3

# 2. 查看 Deployment
kubectl get deploy nginx
# NAME    READY   UP-TO-DATE   AVAILABLE   AGE
# nginx   3/3     3            3           30s

# 3. 查看 ReplicaSet（自动创建）
kubectl get rs -l app=nginx
# NAME               DESIRED   CURRENT   READY   AGE
# nginx-<hash>       3         3         3       30s

# 4. 查看 RS 管理的 Pod
kubectl get pod -l app=nginx -o wide
# 3 个 Pod 分布在不同节点

# 5. 验证 RS 的自我修复：删除一个 Pod
kubectl delete pod <任意一个 nginx pod>
kubectl get pod -l app=nginx -w
# RS 立即创建新 Pod 补足 3 副本

# 打开 3 个终端窗口：

# 终端1：观察 Deployment 状态
kubectl get deploy nginx -w

# 终端2：观察 Pod 变化
kubectl get pod -l app=nginx -w

# 终端3：观察 ReplicaSet 变化
kubectl get rs -l app=nginx -w

# === 触发滚动更新 ===

# 终端4：更新镜像
kubectl set image deploy/nginx nginx=nginx:1.22

# 在终端1 观察：
# UP-TO-DATE 从 0 → 1 → 2 → 3
# 在终端2 观察：
# 新 Pod 创建，旧 Pod 逐步 Terminating
# 在终端3 观察：
# 新 RS 的 DESIRED 递增，旧 RS 的 DECREASED 递减

# 查看更新状态
kubectl rollout status deploy/nginx

# 查看更新历史
kubectl rollout history deploy/nginx
# REVISION  CHANGE-CAUSE
# 1         <none>
# 2         <none>

# 1. 制造一个失败的更新
kubectl set image deploy/nginx nginx=nginx:not-exists

# 2. 观察卡住
kubectl rollout status deploy/nginx
# 看到 "Waiting for deployment rollout to finish..."

# 3. 查看 Pod 状态
kubectl get pod -l app=nginx
# 新 Pod ImagePullBackOff 或 ErrImagePull

# 4. 立即回滚！
kubectl rollout undo deploy/nginx

# 5. 查看回滚后的 Pod 状态
kubectl get pod -l app=nginx
# 恢复为旧版本

# 6. 查看历史记录
kubectl rollout history deploy/nginx
# REVISION  CHANGE-CAUSE
# 1         <none>
# 3         <none>        # REVISION 2 被跳过了

# 7. 回滚到指定 REVISION
kubectl rollout undo deploy/nginx --to-revision=1

# 8. 为更新添加记录标记
kubectl set image deploy/nginx nginx=nginx:1.23 --record=false
# 注意：--record 在新版中已弃用，使用 annotation 替代
kubectl annotate deploy/nginx kubernetes.io/change-cause="update to 1.23"
kubectl rollout history deploy/nginx

# 1. 快速扩容到 6 个副本
kubectl scale deploy/nginx --replicas=6

# 2. 观察 Pod 增加
kubectl get pod -l app=nginx -w

# 3. 缩容到 2 个
kubectl scale deploy/nginx --replicas=2

# 4. 观察 Pod 被终止
kubectl get pod -l app=nginx -w

# 5. 查看 Deployment 的当前期望和实际状态
kubectl get deploy nginx -o jsonpath='
期望副本：{.spec.replicas}
就绪副本：{.status.readyReplicas}
可用副本：{.status.availableReplicas}
'

# 原理：暂停滚动更新 → 验证小部分新 Pod → 恢复全量更新

# 1. 恢复到稳定状态
kubectl scale deploy/nginx --replicas=10

# 2. 暂停 Deployment 的滚动更新
kubectl rollout pause deploy/nginx

# 3. 触发镜像更新（因为有 pause，只会创建新 RS 但不创建新 Pod）
kubectl set image deploy/nginx nginx=nginx:1.24
kubectl annotate deploy/nginx kubernetes.io/change-cause="canary 1.24"

# 4. 查看当前的 ReplicaSet
kubectl get rs -l app=nginx
# 看到新 RS 的 DESIRED=0（因为暂停了）

# 5. "放行" 1 个新版本 Pod 做金丝雀验证
# 方法：手动改新 RS 的 replicas（不太好）
# 更好方法：直接 resume 但限制 maxSurge
kubectl rollout resume deploy/nginx

# 6. 实时观察
kubectl rollout status deploy/nginx

# 7. 清理
kubectl delete deploy nginx

# 1. 创建 Deployment
kubectl create deploy test --image=nginx:1.21 --replicas=3

# 2. 更新到不存在镜像
kubectl set image deploy/test nginx=nginx:99.99

# 3. 观察状态
kubectl get deploy test
# 看到 READY 3/3、UP-TO-DATE 1、AVAILABLE 3

kubectl get rs -l app=test
# 新 RS READY=0，旧 RS READY=3

kubectl get pod -l app=test
# 新 Pod ImagePullBackOff

# 4. 查看详细原因
kubectl describe pod <新 pod> | grep -A5 Events

# 5. 排查命令总结
kubectl rollout status deploy/test
kubectl describe deploy test
kubectl logs <pod-name>  # 如果是应用启动失败

# 6. 回滚
kubectl rollout undo deploy/test

# 7. 清理
kubectl delete deploy test

# 创建新 Deployment
kubectl create deploy test2 --image=nginx:1.21 --replicas=2

# 查看 revisionHistoryLimit（默认 10）
kubectl get deploy test2 -o jsonpath='{.spec.revisionHistoryLimit}'

# 模拟没有历史
kubectl rollout undo deploy/test2
# 可能报错：no rollout history found（首次创建没有历史）

# 解决方案：至少要有一次成功的更新才能回滚
kubectl set image deploy/test2 nginx=nginx:1.22
kubectl rollout status deploy/test2
kubectl rollout history deploy/test2
# 现在有了两个 revision

kubectl delete deploy test2

# 1. 创建 Pod 并实时观察
kubectl run lifecycle-pod --image=nginx:alpine --restart=Never

# 在另一个终端 watch
kubectl get pod lifecycle-pod -w
# 观察：Pending → ContainerCreating → Running

# 2. 查看详细信息
kubectl describe pod lifecycle-pod
# 重点关注 Events 部分

# 3. 进入容器看运行细节
kubectl exec lifecycle-pod -- cat /etc/nginx/conf.d/default.conf

# 4. 删除并观察终止过程（默认 30 秒优雅终止）
kubectl delete pod lifecycle-pod &
kubectl get pod lifecycle-pod -w
# 观察：Running → Terminating → 消失

# 5. 创建带较长 terminationGracePeriodSeconds 的 Pod
kubectl run graceful-pod --image=nginx:alpine --restart=Never \
  --overrides='{"spec":{"terminationGracePeriodSeconds":60}}'

# 验证
kubectl get pod graceful-pod -o jsonpath='{.spec.terminationGracePeriodSeconds}'
kubectl delete pod graceful-pod

# 创建 Sidecar Pod：主容器写日志，Sidecar 读取
cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: sidecar-demo
spec:
  containers:
  - name: app
    image: busybox:1.36
    args:
    - /bin/sh
    - -c
    - |
      i=0
      while true; do
        echo "$(date): log entry $i" >> /var/log/app.log
        i=$((i+1))
        sleep 2
      done
    volumeMounts:
    - name: logs
      mountPath: /var/log

  - name: log-reader
    image: busybox:1.36
    args:
    - /bin/sh
    - -c
    - tail -f /var/log/app.log
    volumeMounts:
    - name: logs
      mountPath: /var/log

  volumes:
  - name: logs
    emptyDir: {}
EOF

# 验证 Sidecar 能读到主容器的日志
kubectl logs sidecar-demo -c log-reader --tail=10

# 查看两个容器的状态
kubectl get pod sidecar-demo
# READY 2/2

# 清理
kubectl delete pod sidecar-demo

# 第一步：创建需要等待的依赖 Service
kubectl create deploy backend --image=nginx:alpine --replicas=1
kubectl expose deploy backend --port=80

# 第二步：创建带 InitContainer 的 Pod
cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: init-demo
spec:
  initContainers:
  - name: wait-for-backend
    image: busybox:1.36
    command:
    - sh
    - -c
    - |
      echo "Waiting for backend service..."
      until wget -q --spider http://backend-service.default.svc.cluster.local; do
        echo "Backend not ready yet..."
        sleep 2
      done
      echo "Backend is ready!"
  containers:
  - name: app
    image: busybox:1.36
    command:
    - sh
    - -c
    - echo "Main app started!" && sleep 3600
EOF

# 观察 InitContainer 执行
kubectl get pod init-demo -w
# 看到 STATUS 列：Init:0/1 → PodInitializing → Running

# 查看 InitContainer 日志
kubectl logs init-demo -c wait-for-backend

# 清理
kubectl delete pod init-demo
kubectl delete deploy backend
kubectl delete svc backend

cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: liveness-demo
spec:
  containers:
  - name: unhealthy
    image: busybox:1.36
    command:
    - sh
    - -c
    - |
      touch /tmp/healthy
      # 30 秒后删除健康标志文件，模拟程序故障
      sleep 30
      rm /tmp/healthy
      sleep 3600
    livenessProbe:
      exec:
        command:
        - cat
        - /tmp/healthy
      initialDelaySeconds: 5
      periodSeconds: 5
      failureThreshold: 3
EOF

# 持续观察 Pod 状态
kubectl get pod liveness-demo -w

# 另一个终端查看事件
kubectl describe pod liveness-demo | grep -A5 "Events"

# 预期：约 30 + 5*3 = 45 秒后 Pod 被重启
kubectl get pod liveness-demo
# RESTARTS 列从 0 递增

# 清理
kubectl delete pod liveness-demo

cat <<'EOF' | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  name: readiness-demo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: readiness-demo
  template:
    metadata:
      labels:
        app: readiness-demo
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        ports:
        - containerPort: 80
        readinessProbe:
          httpGet:
            path: /
            port: 80
          initialDelaySeconds: 3
          periodSeconds: 3
---
apiVersion: v1
kind: Service
metadata:
  name: readiness-svc
spec:
  selector:
    app: readiness-demo
  ports:
  - port: 80
    targetPort: 80
EOF

# 查看 Endpoint 变化
kubectl get endpoints readiness-svc -w
# Pod Ready 后 Endpoint 出现

# 模拟 Pod 不健康：修改 nginx 配置让 / 返回错误
# （略，比赛环境可能需要替代方案）

# 清理
kubectl delete deploy readiness-demo
kubectl delete svc readiness-svc

# 创建一个会立即退出的 Pod
kubectl run crash-demo --image=busybox:1.36 --restart=Always -- /bin/false

# 观察状态
kubectl get pod crash-demo
# STATUS: CrashLoopBackOff

# 查看上一次崩溃的日志
kubectl logs crash-demo --previous

# 查看事件
kubectl describe pod crash-demo | grep -A10 Events

# 进入容器调试（如果容器立即退出，无法 exec）
kubectl run debug-pod --image=busybox:1.36 --restart=Never -it --rm -- sh

# 清理
kubectl delete pod crash-demo

# 创建一个配置了错误端口的 readinessProbe
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: ready-fail
spec:
  containers:
  - name: nginx
    image: nginx:alpine
    readinessProbe:
      httpGet:
        path: /
        port: 8080    # 错误端口！nginx 在 80
      initialDelaySeconds: 3
      periodSeconds: 3
EOF

# 观察
kubectl get pod ready-fail
# STATUS: Running   READY: 0/1

kubectl describe pod ready-fail | grep -A5 Readiness
# Warning  Unhealthy  Readiness probe failed: dial tcp ...:8080: connect: connection refused

# 修复：正确配置端口 → 直接重建 Pod（探针不可变）
kubectl delete pod ready-fail

watch -n 1 'df -h'                   # 每秒刷新监控磁盘使用
watch -n 5 'ps aux | grep nginx'     # 每 5 秒监控 nginx 进程
watch -d 'free -h'                   # 高亮变化行监控内存
watch -n 60 'ls -l'                  # 每分钟查看文件变化

wget HTTP://EXAMPLE.COM/FILE.ZIP                  # 下载文件到当前目录
wget -O OUTPUT.ZIP HTTP://EXAMPLE.COM/FILE.ZIP    # 另存为指定文件名
wget -c HTTP://EXAMPLE.COM/FILE.ZIP               # 断点续传
wget -b -q HTTP://EXAMPLE.COM/FILE.ZIP            # 后台静默下载
wget --limit-rate=1M HTTP://EXAMPLE.COM/FILE.ZIP  # 限速 1MB/s 下载
wget -P /tmp HTTP://EXAMPLE.COM/PKG.DEB           # 下载到指定目录

bg               # 将当前暂停作业放到后台
bg %1            # 后台运行作业号 1

fg               # 将最近后台作业调到前台
fg %2            # 将作业号 2 调到前台

jobs             # 列出所有后台作业
jobs -l          # 显示作业对应的 PID

htop                            # 启动交互式进程查看器
htop -t                         # 树形视图
htop -u ALICE                   # 只显示 ALICE 的进程
htop -d 10                      # 每 1 秒刷新（10 个十分之一秒）

kill 1234                       # 默认发送 TERM 信号
kill -15 1234                   # 发送 SIGTERM（请求终止）
kill -9 1234                    # 发送 SIGKILL（强制杀死）
kill -1 5678                    # 发送 SIGHUP（重载配置）
kill -l                         # 列出所有可用信号
kill -INT 1234                  # 发送 SIGINT（中断）

killall nginx                    # 杀死所有 nginx 进程
killall -9 java                  # 强制杀死所有 java 进程
killall -I python3               # 忽略大小写匹配
killall -u ALICE --exact node    # 只杀 ALICE 用户下名为 node 的进程

nice -n 19 ./HEAVY-TASK         # 最低优先级运行，不影响系统
nice -n 10 make                 # 降低编译优先级
nice -n -5 ./URGENT-TASK        # 提高优先级（需 root）