K8s 场景面试题（二）

etcdctl get /registry/secrets/default/my-secret

envFrom:
  - configMapRef:
      name: my-config

volumes:
  - name: config
    configMap:
      name: my-config

args: ["--config=$(CONFIG_KEY)"]

┌─────────────────────────────────────────────────────────────────┐
│                     第一层：Pod 自身状态                          │
│  kubectl get pod <pod> -o wide                                  │
│  kubectl describe pod <pod>  # 看 Events 是否有网络相关错误        │
└─────────────────────────┬───────────────────────────────────────┘
                          ↓
┌─────────────────────────────────────────────────────────────────┐
│                     第二层：容器网络命名空间                       │
│  kubectl exec -it <pod> -- sh                                   │
│  检查：IP 地址、路由表、DNS 配置、网卡状态                         │
│  cat /etc/resolv.conf  # 看 nameserver 是否是 coredns            │
└─────────────────────────┬───────────────────────────────────────┘
                          ↓
┌─────────────────────────────────────────────────────────────────┐
│                     第三层：同节点 Pod 通信                        │
│  进入 Pod A，ping Pod B 的 IP（同节点）                          │
│  如果不通 → CNI 插件没正确创建 veth pair 或网桥配置错误             │
└─────────────────────────┬───────────────────────────────────────┘
                          ↓
┌─────────────────────────────────────────────────────────────────┐
│                     第四层：跨节点 Pod 通信                        │
│  检查：                                                           │
│  1. CNI 插件状态（Calico/Flannel/Cilium）                        │
│     kubectl get pods -n kube-system | grep calico                │
│  2. 节点路由表：ip route                                           │
│  3. Overlay 网络封装是否正常（VXLAN/IPIP）                         │
│  4. 安全组/防火墙是否放行 Pod CIDR                                 │
└─────────────────────────┬───────────────────────────────────────┘
                          ↓
┌─────────────────────────────────────────────────────────────────┐
│                     第五层：Service 访问                          │
│  检查：                                                           │
│  1. Service Endpoints 是否有 Pod IP                               │
│     kubectl get endpoints <svc>                                  │
│  2. kube-proxy 模式（iptables/IPVS）                             │
│     kubectl logs -n kube-system kube-proxy-<xxx>                 │
│  3. iptables 规则是否创建                                          │
│     iptables -t nat -L KUBE-SERVICES                             │
└─────────────────────────┬───────────────────────────────────────┘
                          ↓
┌─────────────────────────────────────────────────────────────────┐
│                     第六层：外部访问                              │
│  检查：                                                           │
│  1. NodePort：节点安全组是否放行端口                               │
│  2. LoadBalancer：云厂商 LB 是否绑定正确                           │
│  3. Ingress：Controller 是否运行、规则是否匹配                     │
│     kubectl get ingress                                          │
│     kubectl logs -n ingress-nginx <controller-pod>               │
└─────────────────────────────────────────────────────────────────┘

# 1. 网络连通性测试
kubectl run test --image=nicolaka/netshoot --restart=Never --rm -it -- /bin/bash
nslookup kubernetes.default  # 测试 DNS
tcpdump -i any -n port 53    # 抓包看 DNS 请求
 
# 2. CNI 插件诊断（Calico 示例）
calicoctl node status
calicoctl get ippool -o wide
calicoctl ipam show
 
# 3. 查看 Service 后端
iptables -t nat -L KUBE-SEP-XXXXX  # 看具体的 Service Endpoint 规则
ipvsadm -Ln  # 如果使用 IPVS 模式
 
# 4. 检查网络策略是否阻挡
kubectl get networkpolicy

git push → 代码扫描 → 单元测试 → 构建镜像 → 推送镜像仓库
→ 更新镜像 Tag → 部署到测试环境 → 集成测试 → 审批 → 部署到生产

// Jenkinsfile
pipeline {
    agent any
 
    parameters {
        choice(
            name: 'DEPLOY_ENV',
            choices: ['dev', 'staging', 'prod'],
            description: '选择部署环境'
        )
        string(
            name: 'VERSION',
            defaultValue: 'latest',
            description: '镜像版本标签'
        )
        booleanParam(
            name: 'SKIP_TESTS',
            defaultValue: false,
            description: '是否跳过测试'
        )
    }
 
    environment {
        // 根据环境加载不同配置
        CONFIG = loadEnvConfig(params.DEPLOY_ENV)
    }
 
    stages {
        stage('加载环境配置') {
            steps {
                script {
                    def envConfig = [
                        dev: [
                            namespace: 'app-dev',
                            replicas: 1,
                            resources: [cpu: '100m', memory: '256Mi'],
                            configMap: 'app-config-dev',
                            ingressHost: 'dev.app.example.com'
                        ],
                        staging: [
                            namespace: 'app-staging',
                            replicas: 2,
                            resources: [cpu: '500m', memory: '512Mi'],
                            configMap: 'app-config-staging',
                            ingressHost: 'staging.app.example.com'
                        ],
                        prod: [
                            namespace: 'app-prod',
                            replicas: 3,
                            resources: [cpu: '1000m', memory: '1Gi'],
                            configMap: 'app-config-prod',
                            ingressHost: 'app.example.com'
                        ]
                    ]
 
                    env.ENV_CONFIG = envConfig[params.DEPLOY_ENV]
                    echo "当前环境: ${params.DEPLOY_ENV}"
                    echo "命名空间: ${env.ENV_CONFIG.namespace}"
                }
            }
        }
 
        stage('构建镜像') {
            steps {
                sh """
                    docker build -t myapp:${params.VERSION} .
                    docker push myapp:${params.VERSION}
                """
            }
        }
 
        stage('部署到 K8s') {
            steps {
                script {
                    // 使用 envsubst 替换模板中的变量
                    sh """
                        export NAMESPACE=${env.ENV_CONFIG.namespace}
                        export REPLICAS=${env.ENV_CONFIG.replicas}
                        export CPU_LIMIT=${env.ENV_CONFIG.resources.cpu}
                        export MEMORY_LIMIT=${env.ENV_CONFIG.resources.memory}
                        export CONFIG_MAP=${env.ENV_CONFIG.configMap}
                        export INGRESS_HOST=${env.ENV_CONFIG.ingressHost}
                        export IMAGE_TAG=${params.VERSION}
 
                        envsubst < k8s/deployment-template.yaml > k8s/deployment.yaml
                        kubectl apply -f k8s/deployment.yaml -n ${env.ENV_CONFIG.namespace}
                    """
                }
            }
        }
    }
}

# k8s/config/dev-config.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: jenkins-pipeline-config
  namespace: jenkins
data:
  dev.properties: |
    namespace=app-dev
    replicas=1
    cpu_limit=100m
    memory_limit=256Mi
    ingress_host=dev.app.example.com
 
  staging.properties: |
    namespace=app-staging
    replicas=2
    cpu_limit=500m
    memory_limit=512Mi
    ingress_host=staging.app.example.com
 
  prod.properties: |
    namespace=app-prod
    replicas=3
    cpu_limit=1000m
    memory_limit=1Gi
    ingress_host=app.example.com

// 不同环境使用不同的 Credential
stage('部署') {
    steps {
        script {
            def credentialId = "kubeconfig-${params.DEPLOY_ENV}"
 
            withCredentials([file(credentialsId: credentialId, variable: 'KUBECONFIG')]) {
                sh """
                    kubectl --kubeconfig=$KUBECONFIG apply -f k8s/
                """
            }
 
            // 数据库密码等敏感信息
            def dbCredential = "db-password-${params.DEPLOY_ENV}"
            withCredentials([string(credentialsId: dbCredential, variable: 'DB_PASSWORD')]) {
                sh """
                    kubectl create secret generic db-secret \
                        --from-literal=password=$DB_PASSWORD \
                        --dry-run=client -o yaml | kubectl apply -f -
                """
            }
        }
    }
}

pipeline {
    agent any
 
    environment {
        DEPLOY_ENV = getEnvFromBranch(env.BRANCH_NAME)
    }
 
    stages {
        stage('部署') {
            when {
                anyOf {
                    branch 'main'
                    branch 'develop'
                    branch 'release'
                }
            }
            steps {
                sh "echo 部署到 ${env.DEPLOY_ENV}"
            }
        }
    }
}
 
def getEnvFromBranch(branch) {
    switch(branch) {
        case 'main': return 'prod'
        case 'release': return 'staging'
        case 'develop': return 'dev'
        default: return 'dev'
    }
}

┌─────────────────────────────────────────────────────────────────────────────┐
│                              数据采集层                                       │
├─────────────────────────────┬───────────────────────────────────────────────┤
│         后端日志             │                 前端日志                       │
├─────────────────────────────┼───────────────────────────────────────────────┤
│  ┌─────────────────────┐   │   ┌──────────────────────────────────────┐    │
│  │   Pod stdout/stderr │   │   │          浏览器/APP                   │    │
│  │   (容器标准输出)      │   │   └──────────────┬─────────────────────┘    │
│  └──────────┬──────────┘   │                  │                          │
│             │              │   ┌──────────────▼──────────────┐            │
│  ┌──────────▼──────────┐   │   │      SDK 日志采集            │            │
│  │   DaemonSet 采集     │   │   │  - 错误捕获 (onerror)       │            │
│  │  (Fluentd/Filebeat) │   │   │  - 性能数据 (Performance API)│            │
│  └──────────┬──────────┘   │   │  - 用户行为埋点              │            │
│             │              │   └──────────────┬──────────────┘            │
│  ┌──────────▼──────────┐   │                  │                          │
│  │   日志文件挂载       │   │   ┌──────────────▼──────────────┐            │
│  │  (EmptyDir/HostPath)│   │   │      日志上报网关            │            │
│  └──────────┬──────────┘   │   │   (Nginx/OpenResty)          │            │
│             │              │   └──────────────┬──────────────┘            │
│  ┌──────────▼──────────┐   │                  │                          │
│  │   Sidecar 模式       │   │   ┌──────────────▼──────────────┐            │
│  │ (业务+采集容器)       │   │   │      消息队列 (Kafka)        │            │
│  └──────────┬──────────┘   │   └──────────────┬──────────────┘            │
└─────────────┼──────────────┴──────────────────┼──────────────────────────┘
              │                                 │
┌─────────────▼─────────────────────────────────▼────────────────────────────┐
│                              数据处理层                                       │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                     日志处理引擎 (Flink/Logstash)                    │   │
│  │   - 结构化解析（JSON/正则）                                          │   │
│  │   - 字段提取（trace_id、user_id、timestamp）                         │   │
│  │   - 数据清洗（脱敏、过滤）                                           │   │
│  │   - 日志分级（ERROR/WARN/INFO）                                      │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
└─────────────────────────────┬──────────────────────────────────────────────┘
                              │
┌─────────────────────────────▼──────────────────────────────────────────────┐
│                              数据存储层                                       │
├─────────────────────────────┬───────────────────────────────────────────────┤
│   实时检索 (ES/ClickHouse)  │    长期归档 (S3/OSS/Ceph)                      │
│   ├─ 热数据 (7天)           │    ├─ 压缩存储                                  │
│   ├─ 温数据 (30天)          │    ├─ 低成本                                    │
│   └─ 索引生命周期管理        │    └─ 按需恢复                                  │
└─────────────────────────────┴───────────────────────────────────────────────┘

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: filebeat
  namespace: logging
spec:
  selector:
    matchLabels:
      app: filebeat
  template:
    metadata:
      labels:
        app: filebeat
    spec:
      containers:
      - name: filebeat
        image: docker.elastic.co/beats/filebeat:8.11.0
        volumeMounts:
        - name: varlog
          mountPath: /var/log
        - name: varlibdockercontainers
          mountPath: /var/lib/docker/containers
          readOnly: true
        - name: filebeat-config
          mountPath: /etc/filebeat
      volumes:
      - name: varlog
        hostPath:
          path: /var/log
      - name: varlibdockercontainers
        hostPath:
          path: /var/lib/docker/containers
      - name: filebeat-config
        configMap:
          name: filebeat-config
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: filebeat-config
  namespace: logging
data:
  filebeat.yml: |
    filebeat.inputs:
    - type: container
      paths:
        - /var/lib/docker/containers/*/*.log
      processors:
      - add_kubernetes_metadata:
          host: ${NODE_NAME}
          matchers:
          - logs_path:
              logs_path: "/var/lib/docker/containers/"
 
    output.kafka:
      hosts: ["kafka-1:9092", "kafka-2:9092"]
      topic: "k8s-logs"
      partition.round_robin:
        reachable_only: true

// frontend-logger.js
class FrontendLogger {
  constructor(config) {
    this.endpoint = config.endpoint;
    this.appName = config.appName;
    this.env = config.env;
    this.sampleRate = config.sampleRate || 1.0;
 
    this.initErrorCapture();
    this.initPerformanceCapture();
  }
 
  initErrorCapture() {
    // JS 运行时错误
    window.onerror = (msg, url, line, col, error) => {
      this.send({
        type: 'error',
        subtype: 'js_error',
        message: msg,
        filename: url,
        lineno: line,
        colno: col,
        stack: error?.stack,
        userAgent: navigator.userAgent,
        url: window.location.href,
        timestamp: new Date().toISOString()
      });
    };
 
    // Promise 未处理错误
    window.addEventListener('unhandledrejection', (event) => {
      this.send({
        type: 'error',
        subtype: 'unhandled_promise',
        message: event.reason?.message || String(event.reason),
        stack: event.reason?.stack,
        url: window.location.href,
        timestamp: new Date().toISOString()
      });
    });
 
    // 资源加载错误
    window.addEventListener('error', (event) => {
      if (event.target !== window) {
        this.send({
          type: 'error',
          subtype: 'resource_error',
          target: event.target.tagName,
          src: event.target.src || event.target.href,
          outerHTML: event.target.outerHTML.slice(0, 200)
        });
      }
    }, true);
  }
 
  send(data) {
    const payload = {
      ...data,
      app: this.appName,
      env: this.env,
      userId: this.getUserId(),
      sessionId: this.getSessionId()
    };
 
    // 使用 sendBeacon 确保页面关闭也能发送
    if (navigator.sendBeacon) {
      navigator.sendBeacon(this.endpoint, JSON.stringify(payload));
    } else {
      fetch(this.endpoint, {
        method: 'POST',
        body: JSON.stringify(payload),
        keepalive: true
      }).catch(() => {});
    }
  }
}

// crash-reporter.js
class CrashReporter {
  constructor(config) {
    this.config = {
      endpoint: config.endpoint,
      appKey: config.appKey,
      version: config.version,
      maxBreadcrumbs: 20,
      ...config
    };
    this.breadcrumbs = [];
    this.install();
  }
 
  install() {
    // 1. JS 全局错误
    window.onerror = (message, source, lineno, colno, error) => {
      this.captureException(error || new Error(message), {
        type: 'javascript',
        source, lineno, colno
      });
    };
 
    // 2. Promise 未处理错误
    window.addEventListener('unhandledrejection', (event) => {
      this.captureException(event.reason, {
        type: 'unhandledrejection'
      });
      event.preventDefault();
    });
 
    // 3. 资源加载错误
    window.addEventListener('error', (event) => {
      if (event.target !== window) {
        this.captureMessage('Resource failed to load', {
          type: 'resource',
          target: event.target.tagName.toLowerCase(),
          src: event.target.src || event.target.href
        });
      }
    }, true);
 
    // 4. 页面卸载前批量上报
    window.addEventListener('beforeunload', () => this.flush());
  }
 
  captureException(error, extra = {}) {
    const event = {
      event_id: this.generateId(),
      timestamp: new Date().toISOString(),
      level: 'error',
      message: error.message,
      stacktrace: this.parseStack(error.stack),
      url: window.location.href,
      user_agent: navigator.userAgent,
      ...extra
    };
    this.send(event);
  }
 
  parseStack(stack = '') {
    return stack.split('\n').slice(1).map(line => {
      const match = line.match(/at\s+(.*?)\s+\((.*?):(\d+):(\d+)\)/);
      if (match) {
        return {
          function: match[1],
          filename: match[2],
          lineno: parseInt(match[3]),
          colno: parseInt(match[4])
        };
      }
      return null;
    }).filter(Boolean);
  }
 
  send(event) {
    if (navigator.sendBeacon) {
      navigator.sendBeacon(this.config.endpoint, JSON.stringify(event));
    } else {
      fetch(this.config.endpoint, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(event),
        keepalive: true
      }).catch(() => {});
    }
  }
}

┌─────────────┐    ┌──────────┐    ┌──────────┐    ┌─────────┐
│ Application │───→│  Agent   │───→│  Kafka   │───→│  Flink  │
│   Logs      │    │(Filebeat)│    │ (Buffer) │    │(Process)│
└─────────────┘    └──────────┘    └──────────┘    └────┬────┘
                                                         │
                              ┌─────────────────────────┼─────────┐
                              ↓                         ↓         ↓
                           ┌──────┐                ┌────────┐ ┌─────────┐
                           │  ES  │                │S3/OSS  │ │ClickHouse│
                           │(查询) │                │(归档)   │ │ (分析)   │
                           └──────┘                └────────┘ └─────────┘

# 1. 节点安装 NVIDIA 驱动
sudo apt install -y nvidia-driver-535
sudo reboot
 
# 2. 安装 nvidia-container-toolkit
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | \
  sudo tee /etc/apt/sources.list.d/nvidia-docker.list
 
sudo apt update
sudo apt install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker
 
# 3. 部署 NVIDIA Device Plugin
kubectl apply -f https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/v0.14.0/nvidia-device-plugin.yml
 
# 4. 验证
kubectl get nodes -o json | jq '.items[].status.capacity | with_entries(select(.key | contains("nvidia")))'

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gpu-inference
spec:
  replicas: 2
  selector:
    matchLabels:
      app: gpu-inference
  template:
    metadata:
      labels:
        app: gpu-inference
    spec:
      nodeSelector:
        accelerator: nvidia-tesla-a100
      tolerations:
      - key: nvidia.com/gpu
        operator: Exists
        effect: NoSchedule
      containers:
      - name: inference
        image: my-gpu-app:v1
        resources:
          limits:
            nvidia.com/gpu: 1
            memory: "16Gi"
            cpu: "8"
        env:
        - name: NVIDIA_VISIBLE_DEVICES
          value: "all"
        - name: CUDA_CACHE_DISABLE
          value: "1"

# GPU 未被识别
nvidia-smi
kubectl logs -n kube-system nvidia-device-plugin-daemonset-xxxx
 
# 显存泄漏（Pod 删除后显存未释放）
nvidia-smi  # 查看 PID
ps -ef | grep <pid>
kill -9 <pid>
 
# Xid 错误诊断
nvidia-smi -q | grep -i xid

用户请求 → Ingress → KServe Predictor → vLLM Pod (GPU)
                     ↓
                HPA (基于 GPU 利用率/延迟)