# IP 访问频率 Top 10
awk '{print $1}' access.log | sort | uniq -c | sort -nr | head -10

# 查找 100 MB 以上文件
find / -type f -size +100M -exec ls -lh {} \; 2>/dev/null | sort -k5 -h | head

# 实时监控错误日志
tail -f app.log | grep --color=auto "ERROR\|CRITICAL"

# 统计项目代码行数
find SRC/ -name "*.py" | xargs wc -l | tail -1

# 查看磁盘占用 Top 10
du -sh /home/* | sort -rh | head -10

# 批量替换文件内容
grep -rl "old_string" CONFIG/ | xargs sed -i 's/old_string/new_string/g'

# 查看所有监听端口
ss -tulnp | awk 'NR>1{print $1, $5, $7}' | column -t

# 检查系统负载
uptime && free -h && df -h /

# === 在 Master 或独立存储节点上安装 NFS Server ===

# 1. 安装 NFS 服务端
sudo dnf install -y nfs-utils

# 2. 创建共享目录
sudo mkdir -p /srv/nfs/k8s
sudo chown nobody:nobody /srv/nfs/k8s
sudo chmod 777 /srv/nfs/k8s

# 3. 配置 exports
echo "/srv/nfs/k8s *(rw,sync,no_subtree_check,no_root_squash)" | sudo tee -a /etc/exports
sudo exportfs -rav
sudo systemctl enable --now nfs-server

# 4. 验证 NFS 可用（在 worker 节点测试）
# sudo dnf install -y nfs-utils
# sudo mount -t nfs <master-ip>:/srv/nfs/k8s /mnt
# ls /mnt
# sudo umount /mnt

# 1. 创建 RBAC + Deployment
# 这是社区维护的 NFS 动态供给器

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: ServiceAccount
metadata:
  name: nfs-provisioner
  namespace: default
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: nfs-provisioner-runner
rules:
- apiGroups: [""]
  resources: ["persistentvolumes"]
  verbs: ["get", "list", "watch", "create", "delete"]
- apiGroups: [""]
  resources: ["persistentvolumeclaims"]
  verbs: ["get", "list", "watch", "update"]
- apiGroups: ["storage.k8s.io"]
  resources: ["storageclasses"]
  verbs: ["get", "list", "watch"]
- apiGroups: [""]
  resources: ["events"]
  verbs: ["create", "update", "patch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: nfs-provisioner-runner
subjects:
- kind: ServiceAccount
  name: nfs-provisioner
  namespace: default
roleRef:
  kind: ClusterRole
  name: nfs-provisioner-runner
  apiGroup: rbac.authorization.k8s.io
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nfs-provisioner
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nfs-provisioner
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: nfs-provisioner
    spec:
      serviceAccountName: nfs-provisioner
      containers:
      - name: nfs-provisioner
        image: registry.cn-hangzhou.aliyuncs.com/google_containers/nfs-subdir-external-provisioner:v4.0.2
        env:
        - name: PROVISIONER_NAME
          value: k8s-sigs.io/nfs-subdir-external-provisioner
        - name: NFS_SERVER
          value: "10.0.0.1"              # 替换为你的 NFS 服务器 IP
        - name: NFS_PATH
          value: /srv/nfs/k8s
        volumeMounts:
        - name: nfs-root
          mountPath: /persistentvolumes
      volumes:
      - name: nfs-root
        nfs:
          server: 10.0.0.1               # 替换为你的 NFS 服务器 IP
          path: /srv/nfs/k8s
EOF

# 2. 创建 StorageClass
cat <<EOF | kubectl apply -f -
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs-sc
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
provisioner: k8s-sigs.io/nfs-subdir-external-provisioner
reclaimPolicy: Delete
volumeBindingMode: Immediate
EOF

# 3. 验证
kubectl get sc
# NAME               PROVISIONER                                    RECLAIMPOLICY
# nfs-sc (default)   k8s-sigs.io/nfs-subdir-external-provisioner   Delete

kubectl get pod -l app=nfs-provisioner
# Running

# 1. 创建 PVC（不再需要手动创建 PV！）
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: dynamic-pvc
spec:
  storageClassName: nfs-sc
  accessModes:
  - ReadWriteMany
  resources:
    requests:
      storage: 1Gi
EOF

# 2. 观察自动创建 PV
kubectl get pvc dynamic-pvc
# STATUS: Bound

kubectl get pv
# 看到自动创建的 PV（名称如 pvc-xxx-xxx-xxx）

# 3. 在 Pod 中使用
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: dynamic-pod
spec:
  containers:
  - name: app
    image: busybox:1.36
    command:
    - sh
    - -c
    - |
      echo "Dynamic provision test" > /data/test.txt
      cat /data/test.txt
      sleep 3600
    volumeMounts:
    - name: data
      mountPath: /data
  volumes:
  - name: data
    persistentVolumeClaim:
      claimName: dynamic-pvc
EOF

# 4. 验证 NFS 服务器上的实际文件
# ssh 到 NFS 服务器
ls /srv/nfs/k8s/
# 看到自动创建的目录（命名格式：<namespace>-<pvc-name>-<uuid>）

# 5. 清理
kubectl delete pod dynamic-pod
kubectl delete pvc dynamic-pvc
# PV 会自动删除（因为 reclaimPolicy: Delete）

# 1. 首先确保 StorageClass 允许扩容
kubectl get sc nfs-sc
# 修改 StorageClass 允许扩容
kubectl patch sc nfs-sc -p '{"allowVolumeExpansion":true}'

# 2. 创建 PVC
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: expandable-pvc
spec:
  storageClassName: nfs-sc
  accessModes: ["ReadWriteMany"]
  resources:
    requests:
      storage: 1Gi
EOF

# 3. 扩容 PVC（修改 requests.storage）
kubectl patch pvc expandable-pvc -p '{"spec":{"resources":{"requests":{"storage":"3Gi"}}}}'

# 4. 观察 PVC 状态
kubectl get pvc expandable-pvc -w
# CAPACITY 从 1Gi 逐渐变为 3Gi

# 5. 验证
kubectl get pvc expandable-pvc
kubectl get pv | grep expandable-pvc

# 6. 清理
kubectl delete pvc expandable-pvc

# 排查：
# 1. Provisioner Pod 是否运行？
kubectl get pod -l app=nfs-provisioner

# 2. 查看 Provisioner 日志
kubectl logs -l app=nfs-provisioner --tail=50

# 3. 检查 NFS 连通性
kubectl exec -it <provisioner-pod> -- sh -c "showmount -e <NFS_SERVER>"

# 4. 检查 StorageClass 的 provisioner 名称是否匹配
kubectl get sc nfs-sc -o yaml | grep provisioner

# 原因 1：StorageClass 不允许扩容
kubectl get sc <name> -o yaml | grep allowVolumeExpansion

# 原因 2：请求的容量小于当前容量
# PVC 只能扩容不能缩容

# 原因 3：PVC 正在被 Pod 使用
# 某些 CSI 驱动要求在 Pod 运行时才能扩容

# 生成 Pod YAML 模板
kubectl run nginx --image=nginx:alpine --dry-run=client -o yaml

# 生成 Deployment YAML 模板
kubectl create deploy nginx --image=nginx:alpine --dry-run=client -o yaml

# 生成 Service YAML 模板
kubectl create service clusterip nginx --tcp=80:80 --dry-run=client -o yaml

# 查看 Pod 资源定义
kubectl explain pod

# 逐层深入
kubectl explain pod.spec
kubectl explain pod.spec.containers
kubectl explain pod.spec.containers.resources
kubectl explain pod.spec.containers.livenessProbe
kubectl explain pod.spec.containers.livenessProbe.httpGet

# 查看其他资源
kubectl explain deployment.spec.strategy
kubectl explain deployment.spec.strategy.rollingUpdate
kubectl explain ingress.spec.rules.http.paths.backend

# 递归查看所有字段
kubectl explain pod --recursive | head -100

# 1. 生成 Pod YAML
kubectl run my-pod --image=nginx:alpine --dry-run=client -o yaml > pod-template.yaml

# 2. 生成 Deployment YAML
kubectl create deploy my-deploy --image=nginx:alpine --replicas=3 --dry-run=client -o yaml > deploy-template.yaml

# 3. 生成 Service YAML（ClusterIP）
kubectl create service clusterip my-svc --tcp=80:80 --dry-run=client -o yaml > svc-template.yaml

# 4. 生成 Service YAML（NodePort）
kubectl create service nodeport my-np --tcp=80:80 --dry-run=client -o yaml > np-template.yaml

# 5. 生成 ConfigMap YAML
kubectl create configmap my-config --from-literal=key1=val1 --from-literal=key2=val2 --dry-run=client -o yaml

# 6. 生成 Secret YAML
kubectl create secret generic my-secret --from-literal=password=123456 --dry-run=client -o yaml

# 7. 生成 Job YAML
kubectl create job my-job --image=busybox --dry-run=client -o yaml -- date

# 8. 生成 CronJob YAML
kubectl create cj my-cj --image=busybox --schedule="*/5 * * * *" --dry-run=client -o yaml -- date

# 前提：创建一些测试资源
kubectl create deploy nginx --image=nginx:alpine --replicas=3

# 1. 提取所有 Pod 名称
kubectl get pods -o jsonpath='{range .items[*]}{.metadata.name}{"\n"}{end}'

# 2. 提取 Pod 名称:所在节点
kubectl get pods -o jsonpath='{range .items[*]}{.metadata.name}{": "}{.spec.nodeName}{"\n"}{end}'

# 3. 提取 Pod IP
kubectl get pods -o jsonpath='{range .items[*]}{.metadata.name}{": "}{.status.podIP}{"\n"}{end}'

# 4. 提取所有节点的 InternalIP
kubectl get nodes -o jsonpath='{range .items[*]}{.metadata.name}{": "}{.status.addresses[?(@.type=="InternalIP")].address}{"\n"}{end}'

# 5. 提取所有 Deployment 的副本数
kubectl get deploy -o jsonpath='{range .items[*]}{.metadata.name}{": replicas="}{.spec.replicas}{", ready="}{.status.readyReplicas}{"\n"}{end}'

# 6. 提取所有 Service 的 ClusterIP
kubectl get svc -o jsonpath='{range .items[*]}{.metadata.name}{" -> "}{.spec.clusterIP}{":"}{.spec.ports[0].port}{"\n"}{end}'

# 1. 查看所有命名空间的事件，按时间排序
kubectl get events --all-namespaces --sort-by='.lastTimestamp' | tail -20

# 2. 查看所有非 Running 的 Pod
kubectl get pods --all-namespaces --field-selector=status.phase!=Running

# 3. 查看节点资源使用（需要 metrics-server）
# 如果没有 metrics-server，先安装：
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

kubectl top nodes
kubectl top pods --all-namespaces

# 4. 查看集群版本信息
kubectl version

# 5. 检查证书到期时间
sudo kubeadm certs check-expiration

# 6. 检查所有组件的健康状态
kubectl get --raw='/healthz?verbose'

# === 在 Master 节点上执行 ===

# 1. 查看当前版本和可升级版本
kubeadm upgrade plan

# 2. 解锁 kubeadm（如果之前 versionlock 了）
sudo dnf versionlock delete kubeadm
sudo dnf install -y kubeadm-1.29.5  # 替换为目标版本

# 3. 执行升级
sudo kubeadm upgrade apply v1.29.5

# 4. 升级 kubelet 和 kubectl
sudo dnf versionlock delete kubelet kubectl
sudo dnf install -y kubelet-1.29.5 kubectl-1.29.5
sudo dnf versionlock add kubelet kubectl

# 5. 重启 kubelet
sudo systemctl daemon-reload
sudo systemctl restart kubelet

# 6. 验证升级
kubectl get nodes
# Master 版本应变为 v1.29.5

# === 在每个 Worker 节点上执行 ===

# 7. 排空 worker
kubectl drain k8s-node1 --ignore-daemonsets --delete-emptydir-data

# 8. 在 worker 上升级
sudo dnf versionlock delete kubeadm
sudo dnf install -y kubeadm-1.29.5
sudo kubeadm upgrade node

# 9. 升级 kubelet
sudo dnf versionlock delete kubelet
sudo dnf install -y kubelet-1.29.5
sudo dnf versionlock add kubelet
sudo systemctl daemon-reload
sudo systemctl restart kubelet

# 10. 恢复 worker
kubectl uncordon k8s-node1

# 11. 对所有 worker 重复 7-10，最终验证
kubectl get nodes
# 所有节点版本一致

# === 备份 etcd ===

# 1. 查看 etcd 证书位置
ls /etc/kubernetes/pki/etcd/

# 2. 创建备份
sudo ETCDCTL_API=3 etcdctl snapshot save /opt/etcd-backup-$(date +%Y%m%d).db \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key \
  --endpoints=127.0.0.1:2379

# 3. 验证备份
sudo ETCDCTL_API=3 etcdctl snapshot status /opt/etcd-backup-*.db
# 输出：hash、revision、total keys、total size

# 4. 验证备份内容
sudo ETCDCTL_API=3 etcdctl snapshot status /opt/etcd-backup-*.db --write-out=table

# === 恢复 etcd（模拟灾难恢复，请谨慎操作） ===

# 5. 创建恢复目录
sudo mkdir -p /var/lib/etcd-restore

# 6. 从快照恢复
sudo ETCDCTL_API=3 etcdctl snapshot restore /opt/etcd-backup-*.db \
  --data-dir=/var/lib/etcd-restore \
  --name=k8s-master \
  --initial-cluster=k8s-master=https://127.0.0.1:2380 \
  --initial-advertise-peer-urls=https://127.0.0.1:2380

# 7. 检查恢复的数据
sudo ls -la /var/lib/etcd-restore/

# ⚠️ 生产环境恢复需要修改 /etc/kubernetes/manifests/etcd.yaml 的 data-dir 指向恢复目录
# ⚠️ 练习环境请勿实际操作，理解流程即可

# 错误：
# The connection to the server localhost:8080 was refused

# 排查步骤：
# 1. 检查 kubeconfig 是否存在
ls -la ~/.kube/config

# 2. 检查环境变量
echo $KUBECONFIG

# 3. 检查当前 context
kubectl config current-context

# 4. 检查 api-server 是否运行
sudo crictl ps | grep kube-apiserver
# 或
sudo docker ps | grep kube-apiserver

# 5. 检查 6443 端口
sudo ss -tlnp | grep 6443

# 解决方案：
# - 如果 api-server 挂了 → systemctl restart kubelet
# - 如果 config 丢了 → sudo cp /etc/kubernetes/admin.conf ~/.kube/config

# 错误：
# Error from server (Forbidden): pods is forbidden

# 排查步骤：
# 1. 检查当前使用的证书
kubectl config view --raw | grep client-certificate

# 2. 检查当前 context 的用户
kubectl config current-context
kubectl config view -o jsonpath='{.contexts[?(@.name=="<context-name>")].context.user}'

# 3. 确认是用的哪个 kubeconfig
# 可能用了错误的 context 或证书
kubectl config get-contexts

# 解决方案：
# 切换到 admin context
kubectl config use-context kubernetes-admin@kubernetes

# --- Worker 节点 1、2 都执行 ---

# 关闭 swap
sudo swapoff -a
sudo sed -i '/ swap / s/^/#/' /etc/fstab

# 内核模块
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF
sudo modprobe overlay
sudo modprobe br_netfilter

# 内核参数
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF
sudo sysctl --system

# containerd
sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo dnf install -y containerd.io
sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
sudo systemctl restart containerd
sudo systemctl enable containerd

# kubeadm/kubelet/kubectl
cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://pkgs.k8s.io/core:/stable:/v1.29/rpm/
enabled=1
gpgcheck=1
gpgkey=https://pkgs.k8s.io/core:/stable:/v1.29/rpm/repodata/repomd.xml.key
EOF
sudo dnf install -y kubelet kubeadm kubectl
sudo dnf install -y dnf-plugins-core
sudo dnf versionlock kubelet kubeadm kubectl

# 如果昨天的 token 过期了，重新生成
kubeadm token create --print-join-command
# 输出类似：
# kubeadm join 10.0.0.1:6443 --token abc123.xxx --discovery-token-ca-cert-hash sha256:yyy

# 将上面输出的命令粘贴执行
sudo kubeadm join 10.0.0.1:6443 --token abc123.xxx --discovery-token-ca-cert-hash sha256:yyy

kubectl get nodes
# 预期输出：
# NAME         STATUS   ROLES           AGE   VERSION
# k8s-master   Ready    control-plane   1d    v1.29.0
# k8s-node1    Ready    <none>          30s   v1.29.0
# k8s-node2    Ready    <none>          30s   v1.29.0

# 查看所有节点及其标签
kubectl get nodes --show-labels

# 给节点打标签
kubectl label node k8s-node1 role=worker
kubectl label node k8s-node2 role=worker
kubectl label node k8s-node1 disk=ssd
kubectl label node k8s-node2 disk=hdd

# 查看特定标签
kubectl get nodes -l role=worker
kubectl get nodes -l disk=ssd --show-labels

# 覆盖标签（--overwrite）
kubectl label node k8s-node1 disk=nvme --overwrite

# 删除标签（标签名后加 -）
kubectl label node k8s-node1 disk-

# 验证
kubectl get nodes k8s-node1 --show-labels

# 1. 先创建 Deployment 观察
kubectl create deploy nginx --image=nginx:alpine --replicas=6
kubectl get pod -o wide
# 观察 Pod 分布到两个 worker

# 2. 对 node1 执行 cordon（停止调度）
kubectl cordon k8s-node1

# 3. 验证 node1 状态
kubectl get nodes
# k8s-node1   Ready,SchedulingDisabled   ...

# 4. 扩容，验证新 Pod 不调度到 node1
kubectl scale deploy/nginx --replicas=10
kubectl get pod -o wide
# 新 Pod 全部被调度到 node2

# 5. 解除 cordon
kubectl uncordon k8s-node1
kubectl get nodes
# k8s-node1   Ready   ...

# 1. 确定 node1 上有 Pod
kubectl get pod -o wide | grep k8s-node1

# 2. 对 node1 执行 drain
# --ignore-daemonsets：忽略 DaemonSet Pod（它们无法被驱逐）
# --delete-emptydir-data：删除使用 emptyDir 的 Pod
kubectl drain k8s-node1 --ignore-daemonsets --delete-emptydir-data

# 3. 观察 Pod 迁移过程
kubectl get pod -o wide -w
# Pod 被驱逐后在 node2 重建

# 4. 验证 node1 状态
kubectl get nodes
# k8s-node1   Ready,SchedulingDisabled   ...

# 5. 恢复 node1
kubectl uncordon k8s-node1

# 1. 给 node1 添加污点（专用数据库节点）
kubectl taint node k8s-node1 db=only:NoSchedule

# 2. 创建普通 Deployment 验证不受影响
kubectl create deploy web --image=nginx:alpine --replicas=3
kubectl get pod -o wide
# 全部 Pod 应避开 node1

# 3. 创建带 Toleration 的 Pod 专门调度到 node1
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: db-pod
spec:
  tolerations:
  - key: "db"
    operator: "Equal"
    value: "only"
    effect: "NoSchedule"
  containers:
  - name: db
    image: nginx:alpine
EOF

kubectl get pod db-pod -o wide
# db-pod 可以调度到 node1（容忍了污点）

# 4. NoExecute 污点测试（驱逐已有 Pod）
kubectl taint node k8s-node2 test=evict:NoExecute
# 已有的普通 Pod 在 300 秒宽限期后会被驱逐

# 5. 移除污点（污点名后加 -）
kubectl taint node k8s-node1 db-
kubectl taint node k8s-node2 test-

# 6. 验证
kubectl describe node k8s-node1 | grep -A5 Taints
kubectl describe node k8s-node2 | grep -A5 Taints

# 1. 排空 node2
kubectl drain k8s-node2 --ignore-daemonsets --delete-emptydir-data

# 2. 从集群删除 node2
kubectl delete node k8s-node2

# 3. 在 node2 上重置 kubeadm
sudo kubeadm reset -f
sudo rm -rf /etc/cni/net.d

# 4. 重新加入集群
# 在 Master 上生成新 token
kubeadm token create --print-join-command
# 在 node2 上执行 join 命令

# 5. 验证节点回归
kubectl get nodes
# k8s-node2   Ready   <none>   10s   v1.29.0

# 模拟：在 worker 上使用过期 token join 失败
# 错误信息：failed to parse token ...

# 排查步骤：
# 1. 查看现有 token 列表
kubeadm token list
# 如果没有有效 token，显示空

# 2. 创建新 token
sudo kubeadm token create

# 3. 获取 CA 证书 hash
openssl x509 -pubkey -in /etc/kubernetes/pki/ca.crt | \
  openssl rsa -pubin -outform der 2>/dev/null | \
  openssl dgst -sha256 -hex | sed 's/^.* //'

# 4. 使用新 token 和 hash 重新 join

# 排查步骤：
# 1. 看节点状态
kubectl describe node k8s-node2 | grep -A10 Conditions
# 发现 KubeletNotReady，reason: ContainerNetworkNotReady

# 2. 登录 node2，检查 kubelet 日志
sudo journalctl -u kubelet -n 50 --no-pager
# 发现 "CNI plugin not initialized"

# 3. 检查 Calico Pod 是否已运行
kubectl get pods -n kube-system -l k8s-app=calico-node -o wide
# 如果 node2 上没有 Calico Pod，等待自动调度或检查 Calico DS 配置

# 4. 手动检查 CNI 配置
ls /etc/cni/net.d/
# 应有 calico 相关配置文件

# 1. 关闭 swap（K8s 要求）
sudo swapoff -a
sudo sed -i '/ swap / s/^/#/' /etc/fstab

# 2. 加载内核模块
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF
sudo modprobe overlay
sudo modprobe br_netfilter

# 3. 配置内核参数
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF
sudo sysctl --system

# 4. 安装 containerd（通过 Docker CE 仓库）
sudo dnf config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo dnf install -y containerd.io
sudo mkdir -p /etc/containerd
containerd config default | sudo tee /etc/containerd/config.toml
# 修改 SystemdCgroup = true
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
sudo systemctl restart containerd
sudo systemctl enable containerd