第11章故障排查和性能优化 - 在线学习与练习平台

11.1 故障排查概述

11.1.1 故障排查方法论

# 故障排查流程配置
apiVersion: v1
kind: ConfigMap
metadata:
  name: troubleshooting-methodology
data:
  troubleshooting-process.md: |
    # Kubernetes故障排查方法论
    
    ## 1. 问题识别和分类
    
    ### 问题类型分类:
    - **应用层问题**: 应用无法启动、功能异常、性能问题
    - **平台层问题**: Pod调度失败、网络连接问题、存储问题
    - **基础设施问题**: 节点故障、网络故障、存储故障
    - **配置问题**: 资源配置错误、权限配置错误、网络策略错误
    
    ### 严重级别分类:
    - **P0 - 紧急**: 服务完全不可用，影响所有用户
    - **P1 - 高**: 核心功能不可用，影响大部分用户
    - **P2 - 中**: 部分功能不可用，影响部分用户
    - **P3 - 低**: 性能问题或非核心功能问题
    
    ## 2. 信息收集
    
    ### 基础信息收集:
    ```bash
    # 集群状态
    kubectl cluster-info
    kubectl get nodes
    kubectl get pods --all-namespaces
    
    # 事件信息
    kubectl get events --all-namespaces --sort-by='.lastTimestamp'
    
    # 资源使用情况
    kubectl top nodes
    kubectl top pods --all-namespaces
    ```
    
    ### 详细信息收集:
    ```bash
    # Pod详细信息
    kubectl describe pod <pod-name> -n <namespace>
    kubectl logs <pod-name> -n <namespace> --previous
    
    # 网络信息
    kubectl get svc,endpoints --all-namespaces
    kubectl get networkpolicies --all-namespaces
    
    # 存储信息
    kubectl get pv,pvc --all-namespaces
    kubectl get storageclass
    ```
    
    ## 3. 问题分析
    
    ### 分析步骤:
    1. **症状分析**: 确定具体症状和影响范围
    2. **时间线分析**: 确定问题开始时间和相关变更
    3. **依赖关系分析**: 分析组件间的依赖关系
    4. **资源分析**: 检查资源使用情况和限制
    5. **日志分析**: 分析相关组件的日志
    
    ### 常用分析工具:
    - kubectl: 基础诊断工具
    - stern: 多Pod日志聚合
    - k9s: 交互式集群管理
    - Prometheus: 监控和告警
    - Jaeger: 分布式追踪
    
    ## 4. 解决方案实施
    
    ### 解决策略:
    1. **快速恢复**: 优先恢复服务可用性
    2. **根因修复**: 修复根本原因
    3. **预防措施**: 防止问题再次发生
    4. **文档记录**: 记录问题和解决方案
    
    ## 5. 验证和监控
    
    ### 验证步骤:
    1. 功能验证: 确认功能正常
    2. 性能验证: 确认性能恢复
    3. 稳定性验证: 观察一段时间确保稳定
    4. 监控设置: 设置相关监控和告警
  
  troubleshooting-checklist.md: |
    # 故障排查检查清单
    
    ## 快速检查清单
    
    ### 集群级别检查:
    - [ ] 检查集群状态: `kubectl cluster-info`
    - [ ] 检查节点状态: `kubectl get nodes`
    - [ ] 检查系统Pod: `kubectl get pods -n kube-system`
    - [ ] 检查最近事件: `kubectl get events --sort-by='.lastTimestamp'`
    
    ### 应用级别检查:
    - [ ] 检查Pod状态: `kubectl get pods -n <namespace>`
    - [ ] 检查Pod详情: `kubectl describe pod <pod-name>`
    - [ ] 检查Pod日志: `kubectl logs <pod-name>`
    - [ ] 检查服务状态: `kubectl get svc -n <namespace>`
    
    ### 网络级别检查:
    - [ ] 检查Service和Endpoints: `kubectl get svc,ep`
    - [ ] 检查网络策略: `kubectl get networkpolicies`
    - [ ] 检查DNS解析: `nslookup <service-name>`
    - [ ] 检查网络连通性: `ping/telnet`
    
    ### 存储级别检查:
    - [ ] 检查PV/PVC状态: `kubectl get pv,pvc`
    - [ ] 检查存储类: `kubectl get storageclass`
    - [ ] 检查挂载点: `df -h`
    - [ ] 检查存储权限: `ls -la`
    
    ### 资源级别检查:
    - [ ] 检查资源使用: `kubectl top nodes/pods`
    - [ ] 检查资源配额: `kubectl get resourcequota`
    - [ ] 检查限制范围: `kubectl get limitrange`
    - [ ] 检查HPA状态: `kubectl get hpa`

11.1.2 常用故障排查工具

# 故障排查工具配置
apiVersion: v1
kind: ConfigMap
metadata:
  name: troubleshooting-tools
data:
  install-tools.sh: |
    #!/bin/bash
    # 安装故障排查工具脚本
    
    echo "=== 安装Kubernetes故障排查工具 ==="
    
    # 安装stern (多Pod日志聚合)
    echo "1. 安装stern..."
    if ! command -v stern &> /dev/null; then
        curl -L https://github.com/stern/stern/releases/latest/download/stern_linux_amd64.tar.gz | tar xz
        sudo mv stern /usr/local/bin/
        echo "stern安装完成"
    else
        echo "stern已安装"
    fi
    
    # 安装k9s (交互式集群管理)
    echo "\n2. 安装k9s..."
    if ! command -v k9s &> /dev/null; then
        curl -L https://github.com/derailed/k9s/releases/latest/download/k9s_Linux_x86_64.tar.gz | tar xz
        sudo mv k9s /usr/local/bin/
        echo "k9s安装完成"
    else
        echo "k9s已安装"
    fi
    
    # 安装kubectx和kubens (上下文切换)
    echo "\n3. 安装kubectx和kubens..."
    if ! command -v kubectx &> /dev/null; then
        sudo git clone https://github.com/ahmetb/kubectx /opt/kubectx
        sudo ln -s /opt/kubectx/kubectx /usr/local/bin/kubectx
        sudo ln -s /opt/kubectx/kubens /usr/local/bin/kubens
        echo "kubectx和kubens安装完成"
    else
        echo "kubectx和kubens已安装"
    fi
    
    # 安装krew (kubectl插件管理器)
    echo "\n4. 安装krew..."
    if ! kubectl krew version &> /dev/null; then
        (
          set -x; cd "$(mktemp -d)" &&
          OS="$(uname | tr '[:upper:]' '[:lower:]')" &&
          ARCH="$(uname -m | sed -e 's/x86_64/amd64/' -e 's/\(arm\)\(64\)\?.*/\1\2/' -e 's/aarch64$/arm64/')" &&
          KREW="krew-${OS}_${ARCH}" &&
          curl -fsSLO "https://github.com/kubernetes-sigs/krew/releases/latest/download/${KREW}.tar.gz" &&
          tar zxvf "${KREW}.tar.gz" &&
          ./${KREW} install krew
        )
        echo 'export PATH="${KREW_ROOT:-$HOME/.krew}/bin:$PATH"' >> ~/.bashrc
        echo "krew安装完成，请重新加载shell"
    else
        echo "krew已安装"
    fi
    
    # 安装有用的kubectl插件
    echo "\n5. 安装kubectl插件..."
    kubectl krew install debug
    kubectl krew install trace
    kubectl krew install tree
    kubectl krew install who-can
    kubectl krew install resource-capacity
    
    echo "\n=== 工具安装完成 ==="
  
  debug-pod.yaml: |
    # 调试Pod模板
    apiVersion: v1
    kind: Pod
    metadata:
      name: debug-pod
      namespace: default
    spec:
      containers:
      - name: debug
        image: nicolaka/netshoot:latest
        command: ["sleep", "3600"]
        securityContext:
          capabilities:
            add:
            - NET_ADMIN
            - SYS_PTRACE
        volumeMounts:
        - name: host-root
          mountPath: /host
          readOnly: true
      volumes:
      - name: host-root
        hostPath:
          path: /
      hostNetwork: true
      hostPID: true
      restartPolicy: Never
  
  quick-debug.sh: |
    #!/bin/bash
    # 快速调试脚本
    
    NAMESPACE=${1:-"default"}
    POD_NAME=${2}
    
    if [ -z "$POD_NAME" ]; then
        echo "用法: $0 [namespace] <pod-name>"
        echo "快速调试指定Pod"
        exit 1
    fi
    
    echo "=== 快速调试Pod: $NAMESPACE/$POD_NAME ==="
    
    # 基本信息
    echo "1. Pod基本信息:"
    kubectl get pod $POD_NAME -n $NAMESPACE -o wide
    
    # Pod详细描述
    echo "\n2. Pod详细描述:"
    kubectl describe pod $POD_NAME -n $NAMESPACE
    
    # Pod日志
    echo "\n3. Pod当前日志:"
    kubectl logs $POD_NAME -n $NAMESPACE --tail=50
    
    # Pod之前的日志（如果存在）
    echo "\n4. Pod之前的日志:"
    kubectl logs $POD_NAME -n $NAMESPACE --previous --tail=50 2>/dev/null || echo "没有之前的日志"
    
    # 相关事件
    echo "\n5. 相关事件:"
    kubectl get events -n $NAMESPACE --field-selector involvedObject.name=$POD_NAME
    
    # 网络信息
    echo "\n6. 网络信息:"
    kubectl get svc,endpoints -n $NAMESPACE
    
    # 如果Pod正在运行，执行网络测试
    if kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.status.phase}' | grep -q "Running"; then
        echo "\n7. 网络连通性测试:"
        kubectl exec $POD_NAME -n $NAMESPACE -- nslookup kubernetes.default.svc.cluster.local 2>/dev/null || echo "DNS测试失败"
        kubectl exec $POD_NAME -n $NAMESPACE -- wget -qO- --timeout=5 http://kubernetes.default.svc.cluster.local 2>/dev/null || echo "服务连接测试失败"
    fi
    
    echo "\n=== 调试完成 ==="

11.2 Pod故障排查

11.2.1 Pod状态问题

# Pod状态故障排查
apiVersion: v1
kind: ConfigMap
metadata:
  name: pod-troubleshooting
data:
  pod-status-debug.sh: |
    #!/bin/bash
    # Pod状态调试脚本
    
    NAMESPACE=${1:-"default"}
    POD_NAME=${2}
    
    if [ -z "$POD_NAME" ]; then
        echo "用法: $0 [namespace] <pod-name>"
        exit 1
    fi
    
    echo "=== Pod状态诊断: $NAMESPACE/$POD_NAME ==="
    
    # 获取Pod状态
    POD_STATUS=$(kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.status.phase}')
    echo "Pod状态: $POD_STATUS"
    
    case $POD_STATUS in
        "Pending")
            echo "\n=== Pending状态诊断 ==="
            echo "可能原因:"
            echo "1. 资源不足（CPU/内存）"
            echo "2. 节点选择器不匹配"
            echo "3. 污点和容忍度不匹配"
            echo "4. PVC无法绑定"
            echo "5. 镜像拉取失败"
            
            echo "\n检查调度事件:"
            kubectl get events -n $NAMESPACE --field-selector involvedObject.name=$POD_NAME,reason=FailedScheduling
            
            echo "\n检查节点资源:"
            kubectl describe nodes | grep -A 5 "Allocated resources"
            
            echo "\n检查Pod资源请求:"
            kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.spec.containers[*].resources}'
            ;;
        
        "Running")
            echo "\n=== Running状态诊断 ==="
            echo "Pod正在运行，检查容器状态:"
            kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.status.containerStatuses[*].state}'
            
            echo "\n检查就绪状态:"
            kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.status.conditions[?(@.type=="Ready")].status}'
            
            echo "\n检查重启次数:"
            kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.status.containerStatuses[*].restartCount}'
            ;;
        
        "Failed")
            echo "\n=== Failed状态诊断 ==="
            echo "Pod执行失败，检查退出代码:"
            kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.status.containerStatuses[*].state.terminated.exitCode}'
            
            echo "\n检查失败原因:"
            kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.status.containerStatuses[*].state.terminated.reason}'
            
            echo "\n检查容器日志:"
            kubectl logs $POD_NAME -n $NAMESPACE --previous
            ;;
        
        "CrashLoopBackOff")
            echo "\n=== CrashLoopBackOff状态诊断 ==="
            echo "容器持续崩溃，检查崩溃原因:"
            kubectl describe pod $POD_NAME -n $NAMESPACE | grep -A 10 "Last State"
            
            echo "\n检查容器日志:"
            kubectl logs $POD_NAME -n $NAMESPACE --previous
            
            echo "\n检查资源限制:"
            kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.spec.containers[*].resources.limits}'
            ;;
        
        *)
            echo "\n=== 未知状态诊断 ==="
            echo "Pod状态: $POD_STATUS"
            kubectl describe pod $POD_NAME -n $NAMESPACE
            ;;
    esac
    
    echo "\n=== 通用检查 ==="
    echo "检查镜像拉取策略:"
    kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.spec.containers[*].imagePullPolicy}'
    
    echo "\n检查安全上下文:"
    kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.spec.securityContext}'
    
    echo "\n检查卷挂载:"
    kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.spec.volumes}'
    
    echo "\n=== 诊断完成 ==="
  
  container-debug.sh: |
    #!/bin/bash
    # 容器调试脚本
    
    NAMESPACE=${1:-"default"}
    POD_NAME=${2}
    CONTAINER_NAME=${3}
    
    if [ -z "$POD_NAME" ]; then
        echo "用法: $0 [namespace] <pod-name> [container-name]"
        exit 1
    fi
    
    echo "=== 容器调试: $NAMESPACE/$POD_NAME ==="
    
    # 如果没有指定容器名，获取第一个容器
    if [ -z "$CONTAINER_NAME" ]; then
        CONTAINER_NAME=$(kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.spec.containers[0].name}')
        echo "使用默认容器: $CONTAINER_NAME"
    fi
    
    # 检查容器状态
    echo "\n1. 容器状态:"
    kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath="{.status.containerStatuses[?(@.name=='$CONTAINER_NAME')].state}"
    
    # 检查容器资源使用
    echo "\n2. 容器资源使用:"
    kubectl top pod $POD_NAME -n $NAMESPACE --containers
    
    # 检查容器日志
    echo "\n3. 容器日志（最近50行）:"
    kubectl logs $POD_NAME -n $NAMESPACE -c $CONTAINER_NAME --tail=50
    
    # 如果容器正在运行，执行诊断命令
    if kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath="{.status.containerStatuses[?(@.name=='$CONTAINER_NAME')].state.running}" | grep -q "startedAt"; then
        echo "\n4. 容器内部诊断:"
        
        echo "进程列表:"
        kubectl exec $POD_NAME -n $NAMESPACE -c $CONTAINER_NAME -- ps aux 2>/dev/null || echo "无法获取进程列表"
        
        echo "\n网络连接:"
        kubectl exec $POD_NAME -n $NAMESPACE -c $CONTAINER_NAME -- netstat -tulpn 2>/dev/null || echo "无法获取网络连接"
        
        echo "\n磁盘使用:"
        kubectl exec $POD_NAME -n $NAMESPACE -c $CONTAINER_NAME -- df -h 2>/dev/null || echo "无法获取磁盘使用情况"
        
        echo "\n环境变量:"
        kubectl exec $POD_NAME -n $NAMESPACE -c $CONTAINER_NAME -- env 2>/dev/null || echo "无法获取环境变量"
    else
        echo "\n4. 容器未运行，无法执行内部诊断"
    fi
    
    echo "\n=== 调试完成 ==="

11.2.2 镜像拉取问题

# 镜像拉取故障排查
apiVersion: v1
kind: ConfigMap
metadata:
  name: image-pull-troubleshooting
data:
  image-pull-debug.sh: |
    #!/bin/bash
    # 镜像拉取调试脚本
    
    NAMESPACE=${1:-"default"}
    POD_NAME=${2}
    
    if [ -z "$POD_NAME" ]; then
        echo "用法: $0 [namespace] <pod-name>"
        exit 1
    fi
    
    echo "=== 镜像拉取诊断: $NAMESPACE/$POD_NAME ==="
    
    # 检查Pod事件中的镜像拉取错误
    echo "1. 检查镜像拉取事件:"
    kubectl get events -n $NAMESPACE --field-selector involvedObject.name=$POD_NAME,reason=Failed | grep -i "pull\|image"
    
    # 获取Pod中的镜像信息
    echo "\n2. Pod镜像信息:"
    kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.spec.containers[*].image}' | tr ' ' '\n'
    
    # 检查镜像拉取策略
    echo "\n3. 镜像拉取策略:"
    kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.spec.containers[*].imagePullPolicy}' | tr ' ' '\n'
    
    # 检查镜像拉取密钥
    echo "\n4. 镜像拉取密钥:"
    kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.spec.imagePullSecrets[*].name}' | tr ' ' '\n'
    
    # 检查节点上的镜像
    echo "\n5. 检查节点镜像:"
    NODE_NAME=$(kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.spec.nodeName}')
    if [ ! -z "$NODE_NAME" ]; then
        echo "Pod调度到节点: $NODE_NAME"
        kubectl get node $NODE_NAME -o jsonpath='{.status.images[*].names}' | tr ' ' '\n' | head -10
    else
        echo "Pod尚未调度到节点"
    fi
    
    # 检查容器运行时
    echo "\n6. 检查容器运行时:"
    if [ ! -z "$NODE_NAME" ]; then
        kubectl get node $NODE_NAME -o jsonpath='{.status.nodeInfo.containerRuntimeVersion}'
    fi
    
    # 提供解决建议
    echo "\n\n=== 常见解决方案 ==="
    echo "1. 镜像不存在或标签错误:"
    echo "   - 检查镜像名称和标签是否正确"
    echo "   - 使用 'docker pull <image>' 验证镜像是否可访问"
    
    echo "\n2. 私有仓库认证问题:"
    echo "   - 创建镜像拉取密钥: kubectl create secret docker-registry"
    echo "   - 在Pod中引用密钥: imagePullSecrets"
    
    echo "\n3. 网络连接问题:"
    echo "   - 检查节点到镜像仓库的网络连通性"
    echo "   - 检查防火墙和代理设置"
    
    echo "\n4. 磁盘空间不足:"
    echo "   - 检查节点磁盘空间: kubectl describe node"
    echo "   - 清理未使用的镜像: docker system prune"
    
    echo "\n=== 诊断完成 ==="
  
  test-image-pull.sh: |
    #!/bin/bash
    # 测试镜像拉取脚本
    
    IMAGE_NAME=${1}
    NAMESPACE=${2:-"default"}
    
    if [ -z "$IMAGE_NAME" ]; then
        echo "用法: $0 <image-name> [namespace]"
        exit 1
    fi
    
    echo "=== 测试镜像拉取: $IMAGE_NAME ==="
    
    # 创建测试Pod
    TEST_POD_NAME="image-pull-test-$(date +%s)"
    
    cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: $TEST_POD_NAME
  namespace: $NAMESPACE
spec:
  containers:
  - name: test
    image: $IMAGE_NAME
    command: ["sleep", "60"]
  restartPolicy: Never
EOF
    
    echo "创建测试Pod: $TEST_POD_NAME"
    
    # 等待Pod状态变化
    echo "等待Pod状态变化..."
    sleep 10
    
    # 检查Pod状态
    POD_STATUS=$(kubectl get pod $TEST_POD_NAME -n $NAMESPACE -o jsonpath='{.status.phase}')
    echo "Pod状态: $POD_STATUS"
    
    # 检查镜像拉取事件
    echo "\n镜像拉取事件:"
    kubectl get events -n $NAMESPACE --field-selector involvedObject.name=$TEST_POD_NAME
    
    # 清理测试Pod
    echo "\n清理测试Pod..."
    kubectl delete pod $TEST_POD_NAME -n $NAMESPACE
    
    echo "\n=== 测试完成 ==="

11.3 网络故障排查

11.3.1 Service连接问题

# Service网络故障排查
apiVersion: v1
kind: ConfigMap
metadata:
  name: service-troubleshooting
data:
  service-debug.sh: |
    #!/bin/bash
    # Service调试脚本
    
    NAMESPACE=${1:-"default"}
    SERVICE_NAME=${2}
    
    if [ -z "$SERVICE_NAME" ]; then
        echo "用法: $0 [namespace] <service-name>"
        exit 1
    fi
    
    echo "=== Service网络诊断: $NAMESPACE/$SERVICE_NAME ==="
    
    # 检查Service基本信息
    echo "1. Service基本信息:"
    kubectl get svc $SERVICE_NAME -n $NAMESPACE -o wide
    
    # 检查Service详细信息
    echo "\n2. Service详细信息:"
    kubectl describe svc $SERVICE_NAME -n $NAMESPACE
    
    # 检查Endpoints
    echo "\n3. Endpoints信息:"
    kubectl get endpoints $SERVICE_NAME -n $NAMESPACE -o wide
    
    # 检查后端Pod
    echo "\n4. 后端Pod状态:"
    SELECTOR=$(kubectl get svc $SERVICE_NAME -n $NAMESPACE -o jsonpath='{.spec.selector}' | jq -r 'to_entries[] | "\(.key)=\(.value)"' | tr '\n' ',' | sed 's/,$//')
    if [ ! -z "$SELECTOR" ]; then
        echo "选择器: $SELECTOR"
        kubectl get pods -n $NAMESPACE -l "$SELECTOR" -o wide
    else
        echo "Service没有选择器（可能是外部服务）"
    fi
    
    # 检查Service类型特定信息
    SERVICE_TYPE=$(kubectl get svc $SERVICE_NAME -n $NAMESPACE -o jsonpath='{.spec.type}')
    echo "\n5. Service类型: $SERVICE_TYPE"
    
    case $SERVICE_TYPE in
        "ClusterIP")
            echo "ClusterIP Service诊断:"
            CLUSTER_IP=$(kubectl get svc $SERVICE_NAME -n $NAMESPACE -o jsonpath='{.spec.clusterIP}')
            echo "ClusterIP: $CLUSTER_IP"
            
            # 测试DNS解析
            echo "\n测试DNS解析:"
            kubectl run dns-test --image=busybox --rm -it --restart=Never -- nslookup $SERVICE_NAME.$NAMESPACE.svc.cluster.local
            ;;
        
        "NodePort")
            echo "NodePort Service诊断:"
            NODE_PORT=$(kubectl get svc $SERVICE_NAME -n $NAMESPACE -o jsonpath='{.spec.ports[0].nodePort}')
            echo "NodePort: $NODE_PORT"
            
            echo "\n节点信息:"
            kubectl get nodes -o wide
            ;;
        
        "LoadBalancer")
            echo "LoadBalancer Service诊断:"
            EXTERNAL_IP=$(kubectl get svc $SERVICE_NAME -n $NAMESPACE -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
            echo "External IP: $EXTERNAL_IP"
            
            if [ "$EXTERNAL_IP" = "<pending>" ] || [ -z "$EXTERNAL_IP" ]; then
                echo "LoadBalancer IP处于pending状态，检查云提供商配置"
            fi
            ;;
    esac
    
    # 检查网络策略
    echo "\n6. 网络策略检查:"
    kubectl get networkpolicies -n $NAMESPACE
    
    # 检查kube-proxy
    echo "\n7. kube-proxy状态:"
    kubectl get pods -n kube-system -l k8s-app=kube-proxy
    
    echo "\n=== 诊断完成 ==="
  
  network-connectivity-test.sh: |
    #!/bin/bash
    # 网络连通性测试脚本
    
    SOURCE_NAMESPACE=${1:-"default"}
    SOURCE_POD=${2}
    TARGET_SERVICE=${3}
    TARGET_NAMESPACE=${4:-"default"}
    
    if [ -z "$SOURCE_POD" ] || [ -z "$TARGET_SERVICE" ]; then
        echo "用法: $0 [source-namespace] <source-pod> <target-service> [target-namespace]"
        exit 1
    fi
    
    echo "=== 网络连通性测试 ==="
    echo "源Pod: $SOURCE_NAMESPACE/$SOURCE_POD"
    echo "目标Service: $TARGET_NAMESPACE/$TARGET_SERVICE"
    
    # 检查源Pod状态
    echo "\n1. 检查源Pod状态:"
    kubectl get pod $SOURCE_POD -n $SOURCE_NAMESPACE
    
    # 检查目标Service状态
    echo "\n2. 检查目标Service状态:"
    kubectl get svc $TARGET_SERVICE -n $TARGET_NAMESPACE
    
    # DNS解析测试
    echo "\n3. DNS解析测试:"
    kubectl exec $SOURCE_POD -n $SOURCE_NAMESPACE -- nslookup $TARGET_SERVICE.$TARGET_NAMESPACE.svc.cluster.local
    
    # 获取Service IP和端口
    SERVICE_IP=$(kubectl get svc $TARGET_SERVICE -n $TARGET_NAMESPACE -o jsonpath='{.spec.clusterIP}')
    SERVICE_PORT=$(kubectl get svc $TARGET_SERVICE -n $TARGET_NAMESPACE -o jsonpath='{.spec.ports[0].port}')
    
    echo "\n4. 连通性测试:"
    echo "Service IP: $SERVICE_IP"
    echo "Service Port: $SERVICE_PORT"
    
    # Ping测试（如果支持）
    echo "\nPing测试:"
    kubectl exec $SOURCE_POD -n $SOURCE_NAMESPACE -- ping -c 3 $SERVICE_IP 2>/dev/null || echo "Ping失败或不支持"
    
    # 端口连通性测试
    echo "\n端口连通性测试:"
    kubectl exec $SOURCE_POD -n $SOURCE_NAMESPACE -- nc -zv $SERVICE_IP $SERVICE_PORT 2>/dev/null || echo "端口连接失败"
    
    # HTTP测试（如果是HTTP服务）
    echo "\nHTTP测试:"
    kubectl exec $SOURCE_POD -n $SOURCE_NAMESPACE -- wget -qO- --timeout=5 http://$SERVICE_IP:$SERVICE_PORT 2>/dev/null || echo "HTTP请求失败"
    
    # 检查网络策略影响
    echo "\n5. 网络策略检查:"
    echo "源命名空间网络策略:"
    kubectl get networkpolicies -n $SOURCE_NAMESPACE
    echo "\n目标命名空间网络策略:"
    kubectl get networkpolicies -n $TARGET_NAMESPACE
    
    echo "\n=== 测试完成 ==="

11.3.2 DNS解析问题

# DNS故障排查
apiVersion: v1
kind: ConfigMap
metadata:
  name: dns-troubleshooting
data:
  dns-debug.sh: |
    #!/bin/bash
    # DNS调试脚本
    
    echo "=== Kubernetes DNS诊断 ==="
    
    # 检查CoreDNS状态
    echo "1. CoreDNS状态检查:"
    kubectl get pods -n kube-system -l k8s-app=kube-dns
    
    # 检查CoreDNS配置
    echo "\n2. CoreDNS配置:"
    kubectl get configmap coredns -n kube-system -o yaml
    
    # 检查CoreDNS服务
    echo "\n3. CoreDNS服务:"
    kubectl get svc -n kube-system -l k8s-app=kube-dns
    
    # 检查DNS策略
    echo "\n4. 集群DNS配置:"
    kubectl get configmap cluster-info -n kube-public -o yaml 2>/dev/null || echo "cluster-info ConfigMap不存在"
    
    # 创建DNS测试Pod
    echo "\n5. 创建DNS测试Pod:"
    cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: dns-test
  namespace: default
spec:
  containers:
  - name: dns-test
    image: busybox:1.35
    command: ["sleep", "3600"]
  restartPolicy: Never
EOF
    
    # 等待Pod启动
    echo "等待DNS测试Pod启动..."
    kubectl wait --for=condition=Ready pod/dns-test --timeout=60s
    
    # DNS解析测试
    echo "\n6. DNS解析测试:"
    
    echo "测试集群内部DNS:"
    kubectl exec dns-test -- nslookup kubernetes.default.svc.cluster.local
    
    echo "\n测试外部DNS:"
    kubectl exec dns-test -- nslookup google.com
    
    echo "\n测试反向DNS:"
    kubectl exec dns-test -- nslookup 8.8.8.8
    
    # 检查DNS配置文件
    echo "\n7. Pod DNS配置:"
    kubectl exec dns-test -- cat /etc/resolv.conf
    
    # 清理测试Pod
    echo "\n8. 清理测试Pod:"
    kubectl delete pod dns-test
    
    echo "\n=== DNS诊断完成 ==="
  
  dns-performance-test.sh: |
    #!/bin/bash
    # DNS性能测试脚本
    
    echo "=== DNS性能测试 ==="
    
    # 创建DNS性能测试Pod
    cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: dns-perf-test
  namespace: default
spec:
  containers:
  - name: dns-perf-test
    image: busybox:1.35
    command: ["sleep", "3600"]
  restartPolicy: Never
EOF
    
    # 等待Pod启动
    kubectl wait --for=condition=Ready pod/dns-perf-test --timeout=60s
    
    # DNS查询性能测试
    echo "\n1. DNS查询延迟测试:"
    for i in {1..10}; do
        echo -n "查询 $i: "
        kubectl exec dns-perf-test -- time nslookup kubernetes.default.svc.cluster.local 2>&1 | grep real
    done
    
    # DNS缓存测试
    echo "\n2. DNS缓存测试:"
    echo "首次查询:"
    kubectl exec dns-perf-test -- time nslookup google.com 2>&1 | grep real
    echo "缓存查询:"
    kubectl exec dns-perf-test -- time nslookup google.com 2>&1 | grep real
    
    # 并发DNS查询测试
    echo "\n3. 并发DNS查询测试:"
    for i in {1..5}; do
        kubectl exec dns-perf-test -- nslookup kubernetes.default.svc.cluster.local &
    done
    wait
    echo "并发查询完成"
    
    # 清理测试Pod
    kubectl delete pod dns-perf-test
    
    echo "\n=== 性能测试完成 ==="

11.4 存储故障排查

11.4.1 PV/PVC问题

# 存储故障排查
apiVersion: v1
kind: ConfigMap
metadata:
  name: storage-troubleshooting
data:
  pv-pvc-debug.sh: |
    #!/bin/bash
    # PV/PVC调试脚本
    
    NAMESPACE=${1:-"default"}
    PVC_NAME=${2}
    
    if [ -z "$PVC_NAME" ]; then
        echo "用法: $0 [namespace] <pvc-name>"
        echo "或者: $0 [namespace] all  # 检查所有PVC"
        exit 1
    fi
    
    echo "=== 存储诊断: $NAMESPACE/$PVC_NAME ==="
    
    if [ "$PVC_NAME" = "all" ]; then
        echo "检查所有PVC状态:"
        kubectl get pvc -n $NAMESPACE
        
        echo "\n检查所有PV状态:"
        kubectl get pv
        
        echo "\n检查存储类:"
        kubectl get storageclass
        
        return
    fi
    
    # 检查PVC状态
    echo "1. PVC状态:"
    kubectl get pvc $PVC_NAME -n $NAMESPACE -o wide
    
    # 检查PVC详细信息
    echo "\n2. PVC详细信息:"
    kubectl describe pvc $PVC_NAME -n $NAMESPACE
    
    # 获取PVC状态
    PVC_STATUS=$(kubectl get pvc $PVC_NAME -n $NAMESPACE -o jsonpath='{.status.phase}')
    echo "\nPVC状态: $PVC_STATUS"
    
    case $PVC_STATUS in
        "Pending")
            echo "\n=== Pending状态诊断 ==="
            echo "可能原因:"
            echo "1. 没有匹配的PV"
            echo "2. 存储类不存在或配置错误"
            echo "3. 存储提供商问题"
            echo "4. 权限问题"
            
            # 检查存储类
            STORAGE_CLASS=$(kubectl get pvc $PVC_NAME -n $NAMESPACE -o jsonpath='{.spec.storageClassName}')
            if [ ! -z "$STORAGE_CLASS" ]; then
                echo "\n检查存储类: $STORAGE_CLASS"
                kubectl describe storageclass $STORAGE_CLASS
            else
                echo "\n使用默认存储类"
                kubectl get storageclass -o jsonpath='{.items[?(@.metadata.annotations.storageclass\.kubernetes\.io/is-default-class=="true")].metadata.name}'
            fi
            
            # 检查可用PV
            echo "\n检查可用PV:"
            kubectl get pv | grep Available
            ;;
        
        "Bound")
            echo "\n=== Bound状态诊断 ==="
            PV_NAME=$(kubectl get pvc $PVC_NAME -n $NAMESPACE -o jsonpath='{.spec.volumeName}')
            echo "绑定的PV: $PV_NAME"
            
            if [ ! -z "$PV_NAME" ]; then
                echo "\nPV详细信息:"
                kubectl describe pv $PV_NAME
                
                # 检查PV状态
                PV_STATUS=$(kubectl get pv $PV_NAME -o jsonpath='{.status.phase}')
                echo "\nPV状态: $PV_STATUS"
            fi
            ;;
        
        "Lost")
            echo "\n=== Lost状态诊断 ==="
            echo "PV已丢失，可能原因:"
            echo "1. 底层存储被删除"
            echo "2. 存储节点故障"
            echo "3. 网络连接问题"
            ;;
    esac
    
    # 检查使用该PVC的Pod
    echo "\n3. 使用该PVC的Pod:"
    kubectl get pods -n $NAMESPACE -o json | jq -r ".items[] | select(.spec.volumes[]?.persistentVolumeClaim.claimName==\"$PVC_NAME\") | .metadata.name"
    
    # 检查存储事件
    echo "\n4. 相关事件:"
    kubectl get events -n $NAMESPACE --field-selector involvedObject.name=$PVC_NAME
    
    echo "\n=== 诊断完成 ==="
  
  storage-performance-test.sh: |
    #!/bin/bash
    # 存储性能测试脚本
    
    NAMESPACE=${1:-"default"}
    PVC_NAME=${2}
    
    if [ -z "$PVC_NAME" ]; then
        echo "用法: $0 [namespace] <pvc-name>"
        exit 1
    fi
    
    echo "=== 存储性能测试: $NAMESPACE/$PVC_NAME ==="
    
    # 创建性能测试Pod
    TEST_POD_NAME="storage-perf-test-$(date +%s)"
    
    cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: $TEST_POD_NAME
  namespace: $NAMESPACE
spec:
  containers:
  - name: storage-test
    image: busybox:1.35
    command: ["sleep", "3600"]
    volumeMounts:
    - name: test-volume
      mountPath: /test
  volumes:
  - name: test-volume
    persistentVolumeClaim:
      claimName: $PVC_NAME
  restartPolicy: Never
EOF
    
    # 等待Pod启动
    echo "等待测试Pod启动..."
    kubectl wait --for=condition=Ready pod/$TEST_POD_NAME -n $NAMESPACE --timeout=60s
    
    # 写入性能测试
    echo "\n1. 写入性能测试:"
    kubectl exec $TEST_POD_NAME -n $NAMESPACE -- dd if=/dev/zero of=/test/testfile bs=1M count=100 2>&1 | grep -E "copied|MB/s"
    
    # 读取性能测试
    echo "\n2. 读取性能测试:"
    kubectl exec $TEST_POD_NAME -n $NAMESPACE -- dd if=/test/testfile of=/dev/null bs=1M 2>&1 | grep -E "copied|MB/s"
    
    # 随机读写测试
    echo "\n3. 随机读写测试:"
    kubectl exec $TEST_POD_NAME -n $NAMESPACE -- dd if=/dev/urandom of=/test/randomfile bs=4K count=1000 2>&1 | grep -E "copied|MB/s"
    
    # 文件系统测试
    echo "\n4. 文件系统信息:"
    kubectl exec $TEST_POD_NAME -n $NAMESPACE -- df -h /test
    kubectl exec $TEST_POD_NAME -n $NAMESPACE -- mount | grep /test
    
    # 清理测试文件
    echo "\n5. 清理测试文件:"
    kubectl exec $TEST_POD_NAME -n $NAMESPACE -- rm -f /test/testfile /test/randomfile
    
    # 清理测试Pod
    kubectl delete pod $TEST_POD_NAME -n $NAMESPACE
    
    echo "\n=== 性能测试完成 ==="

11.4.2 挂载问题

# 挂载故障排查
apiVersion: v1
kind: ConfigMap
metadata:
  name: mount-troubleshooting
data:
  mount-debug.sh: |
    #!/bin/bash
    # 挂载调试脚本
    
    NAMESPACE=${1:-"default"}
    POD_NAME=${2}
    
    if [ -z "$POD_NAME" ]; then
        echo "用法: $0 [namespace] <pod-name>"
        exit 1
    fi
    
    echo "=== 挂载诊断: $NAMESPACE/$POD_NAME ==="
    
    # 检查Pod状态
    echo "1. Pod状态:"
    kubectl get pod $POD_NAME -n $NAMESPACE
    
    # 检查Pod事件
    echo "\n2. 挂载相关事件:"
    kubectl get events -n $NAMESPACE --field-selector involvedObject.name=$POD_NAME | grep -i "mount\|volume"
    
    # 检查Pod卷配置
    echo "\n3. Pod卷配置:"
    kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.spec.volumes}' | jq .
    
    # 检查容器挂载点
    echo "\n4. 容器挂载点:"
    kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.spec.containers[*].volumeMounts}' | jq .
    
    # 如果Pod正在运行，检查实际挂载情况
    POD_STATUS=$(kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.status.phase}')
    if [ "$POD_STATUS" = "Running" ]; then
        echo "\n5. 实际挂载情况:"
        kubectl exec $POD_NAME -n $NAMESPACE -- mount | grep -v "proc\|sys\|dev" || echo "无法获取挂载信息"
        
        echo "\n6. 磁盘使用情况:"
        kubectl exec $POD_NAME -n $NAMESPACE -- df -h || echo "无法获取磁盘使用情况"
        
        echo "\n7. 挂载点权限:"
        kubectl exec $POD_NAME -n $NAMESPACE -- ls -la / | grep -E "mnt|opt|data" || echo "无特殊挂载点"
    else
        echo "\n5. Pod未运行，无法检查实际挂载情况"
        
        # 检查挂载失败原因
        echo "\n检查挂载失败原因:"
        kubectl describe pod $POD_NAME -n $NAMESPACE | grep -A 10 -B 5 "Mount"
    fi
    
    # 检查相关PVC状态
    echo "\n8. 相关PVC状态:"
    kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.spec.volumes[*].persistentVolumeClaim.claimName}' | tr ' ' '\n' | while read pvc; do
        if [ ! -z "$pvc" ]; then
            echo "PVC: $pvc"
            kubectl get pvc $pvc -n $NAMESPACE
        fi
    done
    
    # 检查节点存储情况
    NODE_NAME=$(kubectl get pod $POD_NAME -n $NAMESPACE -o jsonpath='{.spec.nodeName}')
    if [ ! -z "$NODE_NAME" ]; then
        echo "\n9. 节点存储情况:"
        echo "节点: $NODE_NAME"
        kubectl describe node $NODE_NAME | grep -A 10 "Allocated resources"
    fi
    
    echo "\n=== 诊断完成 ==="

11.5 性能优化

11.5.1 资源优化

# 资源优化配置
apiVersion: v1
kind: ConfigMap
metadata:
  name: resource-optimization
data:
  resource-analysis.sh: |
    #!/bin/bash
    # 资源分析脚本
    
    NAMESPACE=${1:-"all"}
    
    echo "=== Kubernetes资源分析 ==="
    
    # 集群资源概览
    echo "1. 集群资源概览:"
    kubectl top nodes
    
    # 节点资源详情
    echo "\n2. 节点资源详情:"
    kubectl describe nodes | grep -A 5 "Allocated resources"
    
    # Pod资源使用
    echo "\n3. Pod资源使用TOP 10:"
    if [ "$NAMESPACE" = "all" ]; then
        kubectl top pods --all-namespaces | sort -k3 -nr | head -10
    else
        kubectl top pods -n $NAMESPACE | sort -k3 -nr | head -10
    fi
    
    # 资源请求和限制分析
    echo "\n4. 资源请求和限制分析:"
    if [ "$NAMESPACE" = "all" ]; then
        kubectl get pods --all-namespaces -o json | jq -r '.items[] | select(.spec.containers[].resources.requests or .spec.containers[].resources.limits) | "\(.metadata.namespace)/\(.metadata.name): requests=\(.spec.containers[].resources.requests // "none"), limits=\(.spec.containers[].resources.limits // "none")"'
    else
        kubectl get pods -n $NAMESPACE -o json | jq -r '.items[] | select(.spec.containers[].resources.requests or .spec.containers[].resources.limits) | "\(.metadata.name): requests=\(.spec.containers[].resources.requests // "none"), limits=\(.spec.containers[].resources.limits // "none")"'
    fi
    
    # 没有资源限制的Pod
    echo "\n5. 没有资源限制的Pod:"
    if [ "$NAMESPACE" = "all" ]; then
        kubectl get pods --all-namespaces -o json | jq -r '.items[] | select(.spec.containers[].resources.limits == null) | "\(.metadata.namespace)/\(.metadata.name)"'
    else
        kubectl get pods -n $NAMESPACE -o json | jq -r '.items[] | select(.spec.containers[].resources.limits == null) | "\(.metadata.name)"'
    fi
    
    # 资源配额使用情况
    echo "\n6. 资源配额使用情况:"
    if [ "$NAMESPACE" = "all" ]; then
        kubectl get resourcequota --all-namespaces
    else
        kubectl get resourcequota -n $NAMESPACE
    fi
    
    # HPA状态
    echo "\n7. HPA状态:"
    if [ "$NAMESPACE" = "all" ]; then
        kubectl get hpa --all-namespaces
    else
        kubectl get hpa -n $NAMESPACE
    fi
    
    echo "\n=== 分析完成 ==="
  
  optimize-resources.sh: |
    #!/bin/bash
    # 资源优化建议脚本
    
    NAMESPACE=${1:-"default"}
    
    echo "=== 资源优化建议 ==="
    
    # 分析CPU使用率
    echo "1. CPU使用率分析:"
    kubectl top pods -n $NAMESPACE --no-headers | while read pod cpu memory; do
        cpu_value=$(echo $cpu | sed 's/m//')
        if [ $cpu_value -lt 10 ]; then
            echo "  低CPU使用: $pod ($cpu) - 建议减少CPU请求"
        elif [ $cpu_value -gt 800 ]; then
            echo "  高CPU使用: $pod ($cpu) - 建议增加CPU限制或扩容"
        fi
    done
    
    # 分析内存使用率
    echo "\n2. 内存使用率分析:"
    kubectl top pods -n $NAMESPACE --no-headers | while read pod cpu memory; do
        memory_value=$(echo $memory | sed 's/Mi//')
        if [ $memory_value -lt 50 ]; then
            echo "  低内存使用: $pod ($memory) - 建议减少内存请求"
        elif [ $memory_value -gt 1000 ]; then
            echo "  高内存使用: $pod ($memory) - 建议增加内存限制或扩容"
        fi
    done
    
    # 检查资源请求与实际使用的差异
    echo "\n3. 资源请求优化建议:"
    kubectl get pods -n $NAMESPACE -o json | jq -r '.items[] | {name: .metadata.name, requests: .spec.containers[].resources.requests}' | while read line; do
        echo "$line"
    done
    
    # 生成优化建议
    echo "\n4. 优化建议:"
    echo "  - 为所有Pod设置资源请求和限制"
    echo "  - 根据实际使用情况调整资源配置"
    echo "  - 使用HPA进行自动扩缩容"
    echo "  - 考虑使用VPA进行垂直扩缩容"
    echo "  - 定期审查和调整资源配置"
    
    echo "\n=== 建议完成 ==="

11.5.2 性能监控和调优

# 性能监控配置
apiVersion: v1
kind: ConfigMap
metadata:
  name: performance-monitoring
data:
  performance-monitor.sh: |
    #!/bin/bash
    # 性能监控脚本
    
    NAMESPACE=${1:-"default"}
    DURATION=${2:-"60"}
    
    echo "=== 性能监控 (持续 ${DURATION}秒) ==="
    
    # 创建监控日志文件
    TIMESTAMP=$(date +%Y%m%d_%H%M%S)
    LOG_FILE="/tmp/k8s_performance_${TIMESTAMP}.log"
    
    echo "监控日志文件: $LOG_FILE"
    echo "开始时间: $(date)" > $LOG_FILE
    
    # 监控循环
    for i in $(seq 1 $((DURATION/10))); do
        echo "\n=== 监控周期 $i ($(date)) ===" >> $LOG_FILE
        
        # 节点资源使用
        echo "\n节点资源使用:" >> $LOG_FILE
        kubectl top nodes >> $LOG_FILE
        
        # Pod资源使用
        echo "\nPod资源使用:" >> $LOG_FILE
        kubectl top pods -n $NAMESPACE >> $LOG_FILE
        
        # 集群事件
        echo "\n最新事件:" >> $LOG_FILE
        kubectl get events -n $NAMESPACE --sort-by='.lastTimestamp' | tail -5 >> $LOG_FILE
        
        # 等待10秒
        sleep 10
    done
    
    echo "\n结束时间: $(date)" >> $LOG_FILE
    echo "\n=== 监控完成，日志保存在: $LOG_FILE ==="
    
    # 生成性能报告
    echo "\n=== 性能报告摘要 ==="
    echo "监控时长: ${DURATION}秒"
    echo "平均节点CPU使用率:"
    grep -A 20 "节点资源使用" $LOG_FILE | grep -v "节点资源使用" | awk '{sum+=$3; count++} END {if(count>0) print sum/count"%"}'
    
    echo "\n高资源使用Pod:"
    grep -A 50 "Pod资源使用" $LOG_FILE | awk '$3 > 500 {print $1, $3}' | sort -k2 -nr | head -5
  
  cluster-health-check.sh: |
    #!/bin/bash
    # 集群健康检查脚本
    
    echo "=== Kubernetes集群健康检查 ==="
    
    # 检查集群基本状态
    echo "1. 集群基本状态:"
    kubectl cluster-info
    
    # 检查节点状态
    echo "\n2. 节点状态检查:"
    kubectl get nodes
    
    NOT_READY_NODES=$(kubectl get nodes --no-headers | grep -v Ready | wc -l)
    if [ $NOT_READY_NODES -gt 0 ]; then
        echo "⚠️  发现 $NOT_READY_NODES 个非Ready节点"
        kubectl get nodes | grep -v Ready
    else
        echo "✅ 所有节点状态正常"
    fi
    
    # 检查系统Pod状态
    echo "\n3. 系统Pod状态检查:"
    kubectl get pods -n kube-system
    
    FAILED_SYSTEM_PODS=$(kubectl get pods -n kube-system --no-headers | grep -v Running | grep -v Completed | wc -l)
    if [ $FAILED_SYSTEM_PODS -gt 0 ]; then
        echo "⚠️  发现 $FAILED_SYSTEM_PODS 个异常系统Pod"
        kubectl get pods -n kube-system | grep -v Running | grep -v Completed
    else
        echo "✅ 所有系统Pod状态正常"
    fi
    
    # 检查资源使用情况
    echo "\n4. 资源使用情况:"
    kubectl top nodes
    
    # 检查存储状态
    echo "\n5. 存储状态检查:"
    kubectl get pv
    
    FAILED_PVS=$(kubectl get pv --no-headers | grep -v Bound | grep -v Available | wc -l)
    if [ $FAILED_PVS -gt 0 ]; then
        echo "⚠️  发现 $FAILED_PVS 个异常PV"
        kubectl get pv | grep -v Bound | grep -v Available
    else
        echo "✅ 所有PV状态正常"
    fi
    
    # 检查网络组件
    echo "\n6. 网络组件检查:"
    kubectl get pods -n kube-system -l k8s-app=kube-dns
    kubectl get pods -n kube-system -l k8s-app=kube-proxy
    
    # 检查最近的错误事件
    echo "\n7. 最近的错误事件:"
    kubectl get events --all-namespaces --field-selector type=Warning --sort-by='.lastTimestamp' | tail -10
    
    # 生成健康评分
    echo "\n8. 集群健康评分:"
    TOTAL_SCORE=100
    
    if [ $NOT_READY_NODES -gt 0 ]; then
        TOTAL_SCORE=$((TOTAL_SCORE - NOT_READY_NODES * 20))
    fi
    
    if [ $FAILED_SYSTEM_PODS -gt 0 ]; then
        TOTAL_SCORE=$((TOTAL_SCORE - FAILED_SYSTEM_PODS * 10))
    fi
    
    if [ $FAILED_PVS -gt 0 ]; then
        TOTAL_SCORE=$((TOTAL_SCORE - FAILED_PVS * 5))
    fi
    
    echo "集群健康评分: $TOTAL_SCORE/100"
    
    if [ $TOTAL_SCORE -ge 90 ]; then
        echo "✅ 集群状态优秀"
    elif [ $TOTAL_SCORE -ge 70 ]; then
        echo "⚠️  集群状态良好，建议关注警告项"
    else
        echo "❌ 集群状态需要立即关注"
    fi
    
    echo "\n=== 健康检查完成 ==="
  
  performance-tuning.sh: |
    #!/bin/bash
    # 性能调优脚本
    
    echo "=== Kubernetes性能调优 ==="
    
    # 1. 节点性能调优
    echo "1. 节点性能调优建议:"
    
    # 检查节点资源使用率
    kubectl top nodes --no-headers | while read node cpu memory; do
        cpu_percent=$(echo $cpu | sed 's/%//')
        memory_percent=$(echo $memory | sed 's/%//')
        
        if [ $cpu_percent -gt 80 ]; then
            echo "  ⚠️  节点 $node CPU使用率过高 ($cpu_percent%) - 建议扩容或迁移工作负载"
        fi
        
        if [ $memory_percent -gt 80 ]; then
            echo "  ⚠️  节点 $node 内存使用率过高 ($memory_percent%) - 建议扩容或优化内存使用"
        fi
    done
    
    # 2. Pod性能调优
    echo "\n2. Pod性能调优建议:"
    
    # 检查没有资源限制的Pod
    echo "  检查没有资源限制的Pod:"
    kubectl get pods --all-namespaces -o json | jq -r '.items[] | select(.spec.containers[].resources.limits == null) | "    ⚠️  \(.metadata.namespace)/\(.metadata.name) - 建议设置资源限制"'
    
    # 检查重启频繁的Pod
    echo "\n  检查重启频繁的Pod:"
    kubectl get pods --all-namespaces --no-headers | awk '$4 > 5 {print "    ⚠️  " $1 "/" $2 " - 重启次数:" $4 " - 建议检查应用稳定性"}'
    
    # 3. 存储性能调优
    echo "\n3. 存储性能调优建议:"
    
    # 检查PVC使用情况
    kubectl get pvc --all-namespaces -o json | jq -r '.items[] | select(.status.phase == "Bound") | "\(.metadata.namespace)/\(.metadata.name): \(.spec.resources.requests.storage)"' | while read pvc_info; do
        echo "  $pvc_info"
    done
    
    # 4. 网络性能调优
    echo "\n4. 网络性能调优建议:"
    
    # 检查Service数量
    SERVICE_COUNT=$(kubectl get svc --all-namespaces --no-headers | wc -l)
    echo "  当前Service数量: $SERVICE_COUNT"
    
    if [ $SERVICE_COUNT -gt 1000 ]; then
        echo "    ⚠️  Service数量较多，建议优化服务发现机制"
    fi
    
    # 检查NetworkPolicy
    NETPOL_COUNT=$(kubectl get networkpolicies --all-namespaces --no-headers | wc -l)
    echo "  当前NetworkPolicy数量: $NETPOL_COUNT"
    
    # 5. 调度性能调优
    echo "\n5. 调度性能调优建议:"
    
    # 检查Pending的Pod
    PENDING_PODS=$(kubectl get pods --all-namespaces --no-headers | grep Pending | wc -l)
    if [ $PENDING_PODS -gt 0 ]; then
        echo "  ⚠️  发现 $PENDING_PODS 个Pending状态的Pod"
        kubectl get pods --all-namespaces | grep Pending | while read line; do
            echo "    $line"
        done
    else
        echo "  ✅ 没有Pending状态的Pod"
    fi
    
    # 6. 生成调优建议报告
    echo "\n6. 性能调优建议报告:"
    echo "  "
    echo "  📊 资源优化:"
    echo "    - 为所有Pod设置合适的资源请求和限制"
    echo "    - 使用HPA和VPA进行自动扩缩容"
    echo "    - 定期审查资源使用情况"
    echo "  "
    echo "  🚀 应用优化:"
    echo "    - 优化应用启动时间和内存使用"
    echo "    - 使用多阶段构建减小镜像大小"
    echo "    - 实施健康检查和就绪探针"
    echo "  "
    echo "  🌐 网络优化:"
    echo "    - 使用Service Mesh优化服务间通信"
    echo "    - 合理配置NetworkPolicy"
    echo "    - 考虑使用Ingress Controller负载均衡"
    echo "  "
    echo "  💾 存储优化:"
    echo "    - 选择合适的存储类型和性能等级"
    echo "    - 使用本地存储提高I/O性能"
    echo "    - 定期清理未使用的PV和PVC"
    
    echo "\n=== 性能调优完成 ==="

## 11.6 监控和告警

### 11.6.1 性能监控指标

```yaml
# 性能监控指标配置
apiVersion: v1
kind: ConfigMap
metadata:
  name: performance-metrics
data:
  key-metrics.yaml: |
    # 关键性能指标定义
    metrics:
      # 集群级别指标
      cluster:
        - name: cluster_cpu_usage
          description: 集群CPU使用率
          query: (1 - avg(rate(node_cpu_seconds_total{mode="idle"}[5m]))) * 100
          threshold:
            warning: 70
            critical: 85
        
        - name: cluster_memory_usage
          description: 集群内存使用率
          query: (1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100
          threshold:
            warning: 75
            critical: 90
        
        - name: cluster_disk_usage
          description: 集群磁盘使用率
          query: (1 - (node_filesystem_avail_bytes / node_filesystem_size_bytes)) * 100
          threshold:
            warning: 80
            critical: 95
      
      # 节点级别指标
      node:
        - name: node_ready_status
          description: 节点就绪状态
          query: kube_node_status_condition{condition="Ready",status="true"}
          threshold:
            critical: 0
        
        - name: node_cpu_usage
          description: 节点CPU使用率
          query: (1 - avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m]))) * 100
          threshold:
            warning: 70
            critical: 85
        
        - name: node_memory_usage
          description: 节点内存使用率
          query: (1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100
          threshold:
            warning: 75
            critical: 90
        
        - name: node_disk_usage
          description: 节点磁盘使用率
          query: (1 - (node_filesystem_avail_bytes / node_filesystem_size_bytes)) * 100
          threshold:
            warning: 80
            critical: 95
        
        - name: node_network_errors
          description: 节点网络错误率
          query: rate(node_network_receive_errs_total[5m]) + rate(node_network_transmit_errs_total[5m])
          threshold:
            warning: 10
            critical: 50
      
      # Pod级别指标
      pod:
        - name: pod_cpu_usage
          description: Pod CPU使用率
          query: rate(container_cpu_usage_seconds_total[5m]) * 100
          threshold:
            warning: 70
            critical: 90
        
        - name: pod_memory_usage
          description: Pod内存使用率
          query: (container_memory_working_set_bytes / container_spec_memory_limit_bytes) * 100
          threshold:
            warning: 75
            critical: 90
        
        - name: pod_restart_count
          description: Pod重启次数
          query: increase(kube_pod_container_status_restarts_total[1h])
          threshold:
            warning: 3
            critical: 10
        
        - name: pod_ready_status
          description: Pod就绪状态
          query: kube_pod_status_ready{condition="true"}
          threshold:
            critical: 0
      
      # 应用级别指标
      application:
        - name: http_request_duration
          description: HTTP请求响应时间
          query: histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))
          threshold:
            warning: 1
            critical: 5
        
        - name: http_request_rate
          description: HTTP请求速率
          query: rate(http_requests_total[5m])
          threshold:
            warning: 1000
            critical: 5000
        
        - name: http_error_rate
          description: HTTP错误率
          query: (rate(http_requests_total{status=~"5.."}[5m]) / rate(http_requests_total[5m])) * 100
          threshold:
            warning: 5
            critical: 10
  
  monitoring-dashboard.json: |
    {
      "dashboard": {
        "title": "Kubernetes性能监控",
        "panels": [
          {
            "title": "集群CPU使用率",
            "type": "graph",
            "targets": [
              {
                "expr": "(1 - avg(rate(node_cpu_seconds_total{mode=\"idle\"}[5m]))) * 100",
                "legendFormat": "CPU使用率"
              }
            ]
          },
          {
            "title": "集群内存使用率",
            "type": "graph",
            "targets": [
              {
                "expr": "(1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100",
                "legendFormat": "内存使用率"
              }
            ]
          },
          {
            "title": "Pod状态分布",
            "type": "piechart",
            "targets": [
              {
                "expr": "count by (phase) (kube_pod_status_phase)",
                "legendFormat": "{{phase}}"
              }
            ]
          },
          {
            "title": "节点资源使用TOP 10",
            "type": "table",
            "targets": [
              {
                "expr": "topk(10, (1 - avg by (instance) (rate(node_cpu_seconds_total{mode=\"idle\"}[5m]))) * 100)",
                "format": "table"
              }
            ]
          }
        ]
      }
    }

11.6.2 告警配置

# Prometheus告警规则
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: kubernetes-performance-alerts
  namespace: monitoring
spec:
  groups:
  - name: kubernetes.performance
    rules:
    # 集群级别告警
    - alert: ClusterCPUUsageHigh
      expr: (1 - avg(rate(node_cpu_seconds_total{mode="idle"}[5m]))) * 100 > 85
      for: 5m
      labels:
        severity: critical
        component: cluster
      annotations:
        summary: "集群CPU使用率过高"
        description: "集群CPU使用率已达到 {{ $value }}%，超过85%阈值"
        runbook_url: "https://runbooks.example.com/cluster-cpu-high"
    
    - alert: ClusterMemoryUsageHigh
      expr: (1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100 > 90
      for: 5m
      labels:
        severity: critical
        component: cluster
      annotations:
        summary: "集群内存使用率过高"
        description: "集群内存使用率已达到 {{ $value }}%，超过90%阈值"
    
    - alert: ClusterDiskUsageHigh
      expr: (1 - (node_filesystem_avail_bytes / node_filesystem_size_bytes)) * 100 > 95
      for: 5m
      labels:
        severity: critical
        component: cluster
      annotations:
        summary: "集群磁盘使用率过高"
        description: "集群磁盘使用率已达到 {{ $value }}%，超过95%阈值"
    
    # 节点级别告警
    - alert: NodeNotReady
      expr: kube_node_status_condition{condition="Ready",status="true"} == 0
      for: 1m
      labels:
        severity: critical
        component: node
      annotations:
        summary: "节点未就绪"
        description: "节点 {{ $labels.node }} 未就绪状态持续超过1分钟"
    
    - alert: NodeCPUUsageHigh
      expr: (1 - avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m]))) * 100 > 85
      for: 5m
      labels:
        severity: warning
        component: node
      annotations:
        summary: "节点CPU使用率过高"
        description: "节点 {{ $labels.instance }} CPU使用率已达到 {{ $value }}%"
    
    - alert: NodeMemoryUsageHigh
      expr: (1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100 > 90
      for: 5m
      labels:
        severity: warning
        component: node
      annotations:
        summary: "节点内存使用率过高"
        description: "节点 {{ $labels.instance }} 内存使用率已达到 {{ $value }}%"
    
    # Pod级别告警
    - alert: PodCrashLooping
      expr: increase(kube_pod_container_status_restarts_total[1h]) > 5
      for: 5m
      labels:
        severity: warning
        component: pod
      annotations:
        summary: "Pod频繁重启"
        description: "Pod {{ $labels.namespace }}/{{ $labels.pod }} 在过去1小时内重启了 {{ $value }} 次"
    
    - alert: PodNotReady
      expr: kube_pod_status_ready{condition="true"} == 0
      for: 5m
      labels:
        severity: warning
        component: pod
      annotations:
        summary: "Pod未就绪"
        description: "Pod {{ $labels.namespace }}/{{ $labels.pod }} 未就绪状态持续超过5分钟"
    
    - alert: PodMemoryUsageHigh
      expr: (container_memory_working_set_bytes / container_spec_memory_limit_bytes) * 100 > 90
      for: 5m
      labels:
        severity: warning
        component: pod
      annotations:
        summary: "Pod内存使用率过高"
        description: "Pod {{ $labels.namespace }}/{{ $labels.pod }} 内存使用率已达到 {{ $value }}%"
    
    # 应用级别告警
    - alert: HighHTTPErrorRate
      expr: (rate(http_requests_total{status=~"5.."}[5m]) / rate(http_requests_total[5m])) * 100 > 10
      for: 5m
      labels:
        severity: critical
        component: application
      annotations:
        summary: "HTTP错误率过高"
        description: "应用 {{ $labels.job }} HTTP错误率已达到 {{ $value }}%"
    
    - alert: HighHTTPLatency
      expr: histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m])) > 5
      for: 5m
      labels:
        severity: warning
        component: application
      annotations:
        summary: "HTTP响应延迟过高"
        description: "应用 {{ $labels.job }} 95%分位数响应时间已达到 {{ $value }}秒"

---
# AlertManager配置
apiVersion: v1
kind: ConfigMap
metadata:
  name: alertmanager-config
  namespace: monitoring
data:
  alertmanager.yml: |
    global:
      smtp_smarthost: 'smtp.example.com:587'
      smtp_from: 'alerts@example.com'
      smtp_auth_username: 'alerts@example.com'
      smtp_auth_password: 'password'
    
    route:
      group_by: ['alertname', 'cluster', 'service']
      group_wait: 10s
      group_interval: 10s
      repeat_interval: 1h
      receiver: 'default'
      routes:
      - match:
          severity: critical
        receiver: 'critical-alerts'
      - match:
          component: cluster
        receiver: 'cluster-alerts'
      - match:
          component: application
        receiver: 'application-alerts'
    
    receivers:
    - name: 'default'
      email_configs:
      - to: 'team@example.com'
        subject: '[K8s Alert] {{ .GroupLabels.alertname }}'
        body: |
          {{ range .Alerts }}
          告警: {{ .Annotations.summary }}
          描述: {{ .Annotations.description }}
          标签: {{ range .Labels.SortedPairs }}{{ .Name }}={{ .Value }} {{ end }}
          时间: {{ .StartsAt }}
          {{ end }}
    
    - name: 'critical-alerts'
      email_configs:
      - to: 'oncall@example.com'
        subject: '[CRITICAL] {{ .GroupLabels.alertname }}'
        body: |
          🚨 严重告警 🚨
          {{ range .Alerts }}
          告警: {{ .Annotations.summary }}
          描述: {{ .Annotations.description }}
          标签: {{ range .Labels.SortedPairs }}{{ .Name }}={{ .Value }} {{ end }}
          时间: {{ .StartsAt }}
          {{ end }}
      webhook_configs:
      - url: 'http://webhook-service:8080/alerts'
        send_resolved: true
    
    - name: 'cluster-alerts'
      email_configs:
      - to: 'infrastructure@example.com'
        subject: '[Cluster] {{ .GroupLabels.alertname }}'
    
    - name: 'application-alerts'
      email_configs:
      - to: 'developers@example.com'
        subject: '[App] {{ .GroupLabels.alertname }}'
      slack_configs:
      - api_url: 'https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK'
        channel: '#alerts'
        title: 'Kubernetes应用告警'
        text: '{{ range .Alerts }}{{ .Annotations.summary }}{{ end }}'

11.6.3 自动化故障响应

# 自动化故障响应配置
apiVersion: v1
kind: ConfigMap
metadata:
  name: auto-remediation
data:
  auto-restart-failed-pods.sh: |
    #!/bin/bash
    # 自动重启失败Pod脚本
    
    echo "=== 自动故障恢复脚本 ==="
    
    # 检查失败的Pod
    echo "1. 检查失败的Pod:"
    FAILED_PODS=$(kubectl get pods --all-namespaces --field-selector=status.phase=Failed --no-headers)
    
    if [ -z "$FAILED_PODS" ]; then
        echo "没有发现失败的Pod"
    else
        echo "发现失败的Pod:"
        echo "$FAILED_PODS"
        
        # 删除失败的Pod（如果有Deployment会自动重建）
        echo "\n2. 删除失败的Pod:"
        kubectl get pods --all-namespaces --field-selector=status.phase=Failed -o json | jq -r '.items[] | "\(.metadata.namespace) \(.metadata.name)"' | while read namespace pod; do
            echo "删除Pod: $namespace/$pod"
            kubectl delete pod $pod -n $namespace
        done
    fi
    
    # 检查CrashLoopBackOff状态的Pod
    echo "\n3. 检查CrashLoopBackOff状态的Pod:"
    CRASH_PODS=$(kubectl get pods --all-namespaces --no-headers | grep CrashLoopBackOff)
    
    if [ -z "$CRASH_PODS" ]; then
        echo "没有发现CrashLoopBackOff状态的Pod"
    else
        echo "发现CrashLoopBackOff状态的Pod:"
        echo "$CRASH_PODS"
        
        # 记录日志并重启
        echo "$CRASH_PODS" | while read namespace pod ready status restarts age; do
            echo "\n处理Pod: $namespace/$pod"
            echo "获取Pod日志:"
            kubectl logs $pod -n $namespace --previous --tail=20
            
            # 如果重启次数超过10次，暂时不自动重启
            if [ $restarts -gt 10 ]; then
                echo "Pod重启次数过多($restarts)，跳过自动重启"
                continue
            fi
            
            echo "删除Pod进行重启:"
            kubectl delete pod $pod -n $namespace
        done
    fi
    
    echo "\n=== 自动故障恢复完成 ==="
  
  auto-scale-resources.sh: |
    #!/bin/bash
    # 自动扩容脚本
    
    echo "=== 自动资源扩容脚本 ==="
    
    # 检查高CPU使用率的Deployment
    echo "1. 检查高CPU使用率的Deployment:"
    kubectl get deployments --all-namespaces -o json | jq -r '.items[] | select(.spec.replicas > 0) | "\(.metadata.namespace) \(.metadata.name) \(.spec.replicas)"' | while read namespace deployment replicas; do
        # 获取Deployment的平均CPU使用率
        AVG_CPU=$(kubectl top pods -n $namespace -l app=$deployment --no-headers 2>/dev/null | awk '{sum+=$2} END {if(NR>0) print sum/NR; else print 0}' | sed 's/m//')
        
        if [ ! -z "$AVG_CPU" ] && [ $AVG_CPU -gt 800 ]; then
            echo "Deployment $namespace/$deployment CPU使用率过高: ${AVG_CPU}m"
            
            # 检查是否有HPA
            HPA_EXISTS=$(kubectl get hpa -n $namespace $deployment 2>/dev/null | wc -l)
            
            if [ $HPA_EXISTS -eq 0 ]; then
                echo "创建HPA for $namespace/$deployment"
                kubectl autoscale deployment $deployment -n $namespace --cpu-percent=70 --min=1 --max=10
            else
                echo "HPA已存在for $namespace/$deployment"
            fi
        fi
    done
    
    # 检查Pending状态的Pod
    echo "\n2. 检查Pending状态的Pod:"
    PENDING_PODS=$(kubectl get pods --all-namespaces --field-selector=status.phase=Pending --no-headers)
    
    if [ ! -z "$PENDING_PODS" ]; then
        echo "发现Pending状态的Pod:"
        echo "$PENDING_PODS"
        
        # 检查是否是资源不足导致的
        echo "\n检查节点资源:"
        kubectl describe nodes | grep -A 5 "Allocated resources"
        
        # 建议扩容节点
        echo "\n建议: 考虑添加更多节点或调整Pod资源请求"
    fi
    
    echo "\n=== 自动资源扩容完成 ==="
  
  webhook-handler.py: |
    #!/usr/bin/env python3
    # Webhook处理器
    
    from flask import Flask, request, jsonify
    import json
    import subprocess
    import logging
    
    app = Flask(__name__)
    logging.basicConfig(level=logging.INFO)
    
    @app.route('/alerts', methods=['POST'])
    def handle_alert():
        """处理AlertManager发送的告警"""
        try:
            alerts = request.json.get('alerts', [])
            
            for alert in alerts:
                alert_name = alert.get('labels', {}).get('alertname')
                severity = alert.get('labels', {}).get('severity')
                component = alert.get('labels', {}).get('component')
                
                logging.info(f"收到告警: {alert_name}, 严重级别: {severity}, 组件: {component}")
                
                # 根据告警类型执行自动化响应
                if alert_name == 'PodCrashLooping':
                    handle_pod_crash_looping(alert)
                elif alert_name == 'NodeNotReady':
                    handle_node_not_ready(alert)
                elif alert_name == 'ClusterCPUUsageHigh':
                    handle_high_cpu_usage(alert)
                elif alert_name == 'PodNotReady':
                    handle_pod_not_ready(alert)
            
            return jsonify({'status': 'success'}), 200
            
        except Exception as e:
            logging.error(f"处理告警时出错: {str(e)}")
            return jsonify({'status': 'error', 'message': str(e)}), 500
    
    def handle_pod_crash_looping(alert):
        """处理Pod崩溃循环"""
        namespace = alert.get('labels', {}).get('namespace')
        pod = alert.get('labels', {}).get('pod')
        
        if namespace and pod:
            logging.info(f"处理崩溃循环Pod: {namespace}/{pod}")
            
            # 获取Pod日志
            try:
                result = subprocess.run(
                    ['kubectl', 'logs', pod, '-n', namespace, '--previous', '--tail=50'],
                    capture_output=True, text=True
                )
                logging.info(f"Pod日志: {result.stdout}")
                
                # 删除Pod进行重启
                subprocess.run(['kubectl', 'delete', 'pod', pod, '-n', namespace])
                logging.info(f"已删除Pod {namespace}/{pod} 进行重启")
                
            except Exception as e:
                logging.error(f"处理崩溃循环Pod时出错: {str(e)}")
    
    def handle_node_not_ready(alert):
        """处理节点未就绪"""
        node = alert.get('labels', {}).get('node')
        
        if node:
            logging.info(f"处理未就绪节点: {node}")
            
            try:
                # 获取节点详细信息
                result = subprocess.run(
                    ['kubectl', 'describe', 'node', node],
                    capture_output=True, text=True
                )
                logging.info(f"节点信息: {result.stdout}")
                
                # 这里可以添加更多自动化处理逻辑
                # 例如：重启节点、迁移Pod等
                
            except Exception as e:
                logging.error(f"处理未就绪节点时出错: {str(e)}")
    
    def handle_high_cpu_usage(alert):
        """处理高CPU使用率"""
        logging.info("处理高CPU使用率告警")
        
        try:
            # 执行自动扩容脚本
            subprocess.run(['bash', '/scripts/auto-scale-resources.sh'])
            logging.info("已执行自动扩容脚本")
            
        except Exception as e:
            logging.error(f"处理高CPU使用率时出错: {str(e)}")
    
    def handle_pod_not_ready(alert):
        """处理Pod未就绪"""
        namespace = alert.get('labels', {}).get('namespace')
        pod = alert.get('labels', {}).get('pod')
        
        if namespace and pod:
            logging.info(f"处理未就绪Pod: {namespace}/{pod}")
            
            try:
                # 获取Pod详细信息
                result = subprocess.run(
                    ['kubectl', 'describe', 'pod', pod, '-n', namespace],
                    capture_output=True, text=True
                )
                logging.info(f"Pod信息: {result.stdout}")
                
                # 检查Pod事件
                result = subprocess.run(
                    ['kubectl', 'get', 'events', '-n', namespace, '--field-selector', f'involvedObject.name={pod}'],
                    capture_output=True, text=True
                )
                logging.info(f"Pod事件: {result.stdout}")
                
            except Exception as e:
                logging.error(f"处理未就绪Pod时出错: {str(e)}")
    
    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=8080)

11.7 故障排查最佳实践

11.7.1 故障排查流程

# 故障排查最佳实践
apiVersion: v1
kind: ConfigMap
metadata:
  name: troubleshooting-best-practices
data:
  troubleshooting-workflow.md: |
    # Kubernetes故障排查最佳实践
    
    ## 1. 故障排查准备
    
    ### 1.1 建立基线
    - 了解正常状态下的系统指标
    - 记录关键配置和架构信息
    - 建立监控和告警体系
    - 准备故障排查工具和脚本
    
    ### 1.2 文档化
    - 维护最新的架构文档
    - 记录常见问题和解决方案
    - 建立故障排查手册
    - 保持联系人信息更新
    
    ## 2. 故障响应流程
    
    ### 2.1 初始响应（0-5分钟）
    1. **确认告警**: 验证告警的真实性和严重性
    2. **初步评估**: 快速评估影响范围和用户影响
    3. **启动响应**: 根据严重级别启动相应的响应流程
    4. **通知相关人员**: 通知相关团队和利益相关者
    
    ### 2.2 问题诊断（5-30分钟）
    1. **收集信息**: 使用标准化脚本收集系统状态信息
    2. **分析症状**: 分析告警、日志和监控数据
    3. **确定范围**: 确定问题的影响范围和根本原因
    4. **制定计划**: 制定详细的解决计划
    
    ### 2.3 问题解决（30分钟+）
    1. **实施解决方案**: 按计划实施解决方案
    2. **验证修复**: 验证问题是否得到解决
    3. **监控稳定性**: 持续监控系统稳定性
    4. **更新状态**: 及时更新问题状态和进展
    
    ### 2.4 事后处理
    1. **根因分析**: 进行详细的根因分析
    2. **改进措施**: 制定预防措施和改进计划
    3. **文档更新**: 更新故障排查文档和知识库
    4. **经验分享**: 与团队分享经验和教训
    
    ## 3. 故障排查技巧
    
    ### 3.1 系统性方法
    - 从上到下：从应用层到基础设施层
    - 从外到内：从用户体验到系统内部
    - 分层诊断：网络、存储、计算、应用
    - 时间线分析：确定问题开始时间和相关变更
    
    ### 3.2 工具使用
    - **kubectl**: 基础诊断和操作
    - **stern**: 多Pod日志聚合
    - **k9s**: 交互式集群管理
    - **Prometheus**: 监控和告警
    - **Grafana**: 可视化分析
    - **Jaeger**: 分布式追踪
    
    ### 3.3 日志分析
    - 使用结构化日志格式
    - 设置合适的日志级别
    - 关联请求ID进行追踪
    - 使用日志聚合工具
    
    ## 4. 常见问题模式
    
    ### 4.1 资源相关问题
    - **症状**: Pod Pending、OOMKilled、节点压力
    - **排查**: 检查资源请求、限制、节点容量
    - **解决**: 调整资源配置、扩容、优化应用
    
    ### 4.2 网络相关问题
    - **症状**: 连接超时、DNS解析失败、服务不可达
    - **排查**: 检查Service、Endpoints、网络策略
    - **解决**: 修复配置、重启网络组件、调整策略
    
    ### 4.3 存储相关问题
    - **症状**: PVC Pending、挂载失败、I/O错误
    - **排查**: 检查PV、PVC、存储类、权限
    - **解决**: 修复存储配置、清理资源、调整权限
    
    ### 4.4 应用相关问题
    - **症状**: 启动失败、频繁重启、功能异常
    - **排查**: 检查日志、配置、依赖、健康检查
    - **解决**: 修复代码、调整配置、更新依赖
    
    ## 5. 预防措施
    
    ### 5.1 监控和告警
    - 设置全面的监控指标
    - 配置合理的告警阈值
    - 实施多层次告警策略
    - 定期审查和调整告警规则
    
    ### 5.2 自动化
    - 自动化常见故障的检测和修复
    - 使用健康检查和自愈机制
    - 实施自动扩缩容
    - 建立自动化测试流程
    
    ### 5.3 容量规划
    - 定期进行容量评估
    - 预留足够的资源缓冲
    - 制定扩容计划和流程
    - 监控资源使用趋势
    
    ### 5.4 变更管理
    - 建立标准化的变更流程
    - 实施渐进式部署
    - 保持配置版本控制
    - 建立回滚机制
  
  incident-response-checklist.md: |
    # 故障响应检查清单
    
    ## 严重故障响应清单（P0/P1）
    
    ### 立即响应（0-5分钟）
    - [ ] 确认告警并评估影响范围
    - [ ] 通知相关团队和管理层
    - [ ] 启动故障响应流程
    - [ ] 建立沟通渠道（如Slack频道）
    - [ ] 指定故障响应负责人
    
    ### 初步诊断（5-15分钟）
    - [ ] 检查集群整体状态：`kubectl cluster-info`
    - [ ] 检查节点状态：`kubectl get nodes`
    - [ ] 检查系统Pod状态：`kubectl get pods -n kube-system`
    - [ ] 检查最近事件：`kubectl get events --sort-by='.lastTimestamp'`
    - [ ] 检查监控Dashboard确认问题范围
    
    ### 详细分析（15-30分钟）
    - [ ] 收集相关Pod日志：`kubectl logs <pod-name>`
    - [ ] 检查Pod详细状态：`kubectl describe pod <pod-name>`
    - [ ] 分析网络连通性
    - [ ] 检查存储状态
    - [ ] 查看资源使用情况：`kubectl top nodes/pods`
    
    ### 解决实施
    - [ ] 制定解决方案并评估风险
    - [ ] 实施解决方案
    - [ ] 验证修复效果
    - [ ] 监控系统稳定性
    - [ ] 更新故障状态
    
    ### 事后处理
    - [ ] 进行根因分析
    - [ ] 编写故障报告
    - [ ] 制定预防措施
    - [ ] 更新文档和流程
    - [ ] 团队复盘和经验分享
    
    ## 一般故障响应清单（P2/P3）
    
    ### 问题确认
    - [ ] 验证问题的真实性
    - [ ] 评估影响范围和紧急程度
    - [ ] 确定是否需要立即处理
    
    ### 信息收集
    - [ ] 使用标准化脚本收集系统信息
    - [ ] 分析相关日志和监控数据
    - [ ] 确定问题的时间线
    
    ### 问题解决
    - [ ] 制定解决计划
    - [ ] 实施解决方案
    - [ ] 验证修复效果
    - [ ] 文档化解决过程
    
    ## 通用检查项目
    
    ### 集群健康检查
    - [ ] 所有节点状态正常
    - [ ] 系统组件运行正常
    - [ ] 网络组件功能正常
    - [ ] 存储系统可用
    - [ ] DNS解析正常
    
    ### 应用健康检查
    - [ ] 关键应用Pod运行正常
    - [ ] 服务发现功能正常
    - [ ] 负载均衡工作正常
    - [ ] 数据库连接正常
    - [ ] 外部依赖可访问
    
    ### 性能检查
    - [ ] CPU使用率在正常范围
    - [ ] 内存使用率在正常范围
    - [ ] 磁盘使用率在正常范围
    - [ ] 网络延迟在正常范围
    - [ ] 应用响应时间正常

11.8 总结

本章详细介绍了Kubernetes的故障排查和性能优化，主要内容包括：

11.8.1 故障排查体系

方法论建立: 系统性的故障排查方法和流程
工具使用: kubectl、stern、k9s等专业工具的使用
问题分类: 按照组件和严重程度进行问题分类
检查清单: 标准化的故障排查检查清单

11.8.2 具体故障类型

Pod故障: 状态问题、镜像拉取、容器崩溃等
网络故障: Service连接、DNS解析、网络策略等
存储故障: PV/PVC问题、挂载失败、性能问题等
节点故障: 资源不足、网络问题、系统故障等

11.8.3 性能优化

资源优化: CPU、内存、存储资源的合理配置
应用优化: 启动时间、内存使用、响应性能等
集群优化: 调度策略、网络配置、存储配置等
监控优化: 关键指标监控和性能基线建立

11.8.4 监控和告警

指标体系: 集群、节点、Pod、应用多层次指标
告警配置: 基于阈值的智能告警规则
自动化响应: 故障自动检测和修复机制
可视化分析: Grafana Dashboard和性能分析

11.8.5 最佳实践

预防为主: 通过监控、自动化、容量规划预防故障
快速响应: 建立标准化的故障响应流程
持续改进: 通过根因分析和经验总结持续优化
文档化: 维护完整的故障排查文档和知识库

11.8.6 关键要点

系统性方法: 采用分层、分类的系统性故障排查方法
工具熟练: 熟练掌握各种故障排查和性能分析工具
自动化程度: 提高故障检测、响应和修复的自动化程度
监控完善: 建立全面的监控体系和合理的告警策略
经验积累: 通过实践积累故障排查经验和优化技巧

通过本章的学习，你应该能够： - 建立完整的Kubernetes故障排查体系 - 快速定位和解决各类常见故障 - 实施有效的性能优化策略 - 建立自动化的监控和告警机制 - 制定预防性的运维策略

下一章我们将学习Kubernetes的高级特性和扩展机制。

📂 分类导航

▶ 学与练
- ▶ 软件技术基础
  - ▶ 操作系统技术
    - Linux实战
    - ▶ Linux技巧
      - debug-remote-api.md
  - ▶ 容器化与编排
    - Docker实战
    - ▶ Docker高级
- ▶ 前端开发技术
  - ▶ 框架与库
    - js
    - vue
  - ▶ 前端生态
    - bootstrap
    - vue-ssr
- ▶ 后端开发技术
  - ▶ 编程语言
    - ▶ Java
    - ▶ Go
      - go-server.md
      - mini.md
    - Rust
    - Python
    - csharp
  - ▶ 中间件
    - redis
    - ▶ minio
      - minio.md
    - elasticsearch
    - kafka
    - elk
    - caddy
  - ▶ 数据库
    - MySQL
    - SQLServer
    - ▶ Dameng
      - sql.md
    - clickhouse
- ▶ 数据开发与运维
  - ▶ 数据开发
    - hadoop
  - ▶ 运维开发
    - ▶ CI/CD
      - jenkins
    - ▶ 自动化
      - allinssl.md
    - ▶ 日志处理
      - elk
    - ▶ 监控
- 软件速学教程
▶ 软件园
- AI智能体与应用
- 开发工具与环境
- AI 开发和编排
- 业务与生产力应用
- 数据和中间件
▶ 工具箱
- 内容管理
- 编码解码
- ▶ 系统监控
  - miaotixing.md
- ▶ 日常工具
- 工具命令
- 使用教程

📚 第11章故障排查和性能优化

11.1 故障排查概述

11.1.1 故障排查方法论

11.1.2 常用故障排查工具

11.2 Pod故障排查

11.2.1 Pod状态问题

11.2.2 镜像拉取问题

11.3 网络故障排查

11.3.1 Service连接问题

11.3.2 DNS解析问题

11.4 存储故障排查

11.4.1 PV/PVC问题

11.4.2 挂载问题

11.5 性能优化

11.5.1 资源优化

11.5.2 性能监控和调优

11.6.2 告警配置

11.6.3 自动化故障响应

11.7 故障排查最佳实践

11.7.1 故障排查流程

11.8 总结

11.8.1 故障排查体系

11.8.2 具体故障类型

11.8.3 性能优化

11.8.4 监控和告警

11.8.5 最佳实践

11.8.6 关键要点

📂 分类导航

📰 最新文章

📚 第11章 故障排查和性能优化

11.1 故障排查概述

11.1.1 故障排查方法论

11.1.2 常用故障排查工具

11.2 Pod故障排查

11.2.1 Pod状态问题

11.2.2 镜像拉取问题

11.3 网络故障排查

11.3.1 Service连接问题

11.3.2 DNS解析问题

11.4 存储故障排查

11.4.1 PV/PVC问题

11.4.2 挂载问题

11.5 性能优化

11.5.1 资源优化

11.5.2 性能监控和调优

11.6.2 告警配置

11.6.3 自动化故障响应

11.7 故障排查最佳实践

11.7.1 故障排查流程

11.8 总结

11.8.1 故障排查体系

11.8.2 具体故障类型

11.8.3 性能优化

11.8.4 监控和告警

11.8.5 最佳实践

11.8.6 关键要点

📂 分类导航

📰 最新文章

📚 第11章故障排查和性能优化