高阶问题(AI 工程师)
Docker 与 K8s 与云原生交付 100 题
AI 工程师面试题库 · 第五批(题号 400–499):Docker 基础与镜像、K8s 核心对象与进阶、可观测与运维、CI/CD 与交付、Linux 与进程基础、GPU 与 AI 负载、综合上云场景。
- 面试
- AI 工程师
- 云原生
AI 工程师面试题库 · 第五批:Docker、K8s 与云原生交付
目录
-
- 400. Docker 镜像分层与构建缓存:为什么你的构建那么慢?
- 401. 多阶段构建:镜像怎么从 1GB 瘦到 100MB?
- 402. COPY 与 ADD、CMD 与 ENTRYPOINT:四组易混指令的边界?
- 403. 镜像基础选型:alpine、slim、distroless 怎么选?
- 404. 容器文件系统:overlay2 与写时复制是怎么回事?
- 405. volume 与 bind mount:容器数据持久化怎么做?
- 406. 容器网络:bridge、host 与端口映射是怎么回事?
- 407. Docker Compose:本地多服务编排怎么组织?
- 408. 容器里的 PID 1:僵尸进程与信号处理?
- 409. namespace 与 cgroups:容器和虚拟机的本质区别?
- 410. 容器资源限制:—memory 与 —cpus 之下到底发生什么?
- 411. 镜像仓库:私有 registry 与分发加速怎么做?
- 412. 镜像扫描与签名:trivy 与 cosign 怎么进流水线?
- 413. .dockerignore 与构建上下文:被忽视的构建提速?
- 414. 容器安全基线:非 root、capability 收缩与 seccomp?
-
- 415. K8s 心智模型:控制平面、节点与声明式 API?
- 416. Pod:为什么最小调度单元是 Pod 而不是容器?
- 417. Pod 生命周期与重启策略:从 Pending 到 Terminating 发生了什么?
- 418. Deployment:滚动更新与回滚怎么发生?
- 419. Service:四种类型与流量到底怎么到 Pod?
- 420. Ingress:七层路由怎么组织?
- 421. ConfigMap:配置注入的三种方式与热更新边界?
- 422. Secret:base64 不是加密,密钥管理的正确姿势?
- 423. requests/limits 与 QoS 等级:资源声明背后的调度逻辑?
- 424. 三种探针:liveness、readiness、startup 怎么配才不闯祸?
- 425. kubectl 排障工具箱:从”进不去容器”到”看清现场”的命令地图?
- 426. Job 与 CronJob:批处理任务怎么跑才可靠?
- 427. StatefulSet:有状态应用的正确打开方式?
- 428. DaemonSet:节点级组件怎么部署?
- 429. Pod 网络与 CNI:Pod 之间到底怎么互通的?
- 430. 集群 DNS 与服务发现:服务名是怎么变成 IP 的?
- 431. Init 容器与原生 Sidecar:启动顺序怎么编排?
- 432. Namespace、ResourceQuota 与 LimitRange:多团队怎么共用一个集群?
- 433. Label、Selector 与 Annotation:元数据的分工是什么?
- 434. 从 docker-compose 到 K8s:迁移怎么对照着做?
-
- 435. HPA:自动扩缩容怎么配才不震荡?
- 436. VPA 与 HPA 的配合:自动调资源怎么不出冲突?
- 437. 亲和性与反亲和性:调度位置怎么控制?
- 438. 污点与容忍:节点专属怎么实现?
- 439. PDB:自愿驱逐时怎么保住法定副本数?
- 440. 节点压力驱逐:内存磁盘吃紧时谁先被杀?
- 441. 优先级与抢占:重要任务能不能”抢”资源?
- 442. RBAC:权限模型怎么设计与审计?
- 443. NetworkPolicy:Pod 网络隔离怎么做?
- 444. 存储体系:PV、PVC 与 StorageClass 怎么协作?
- 445. 数据库该不该上 K8s:有状态数据的实践决策?
- 446. etcd 与控制面运维:集群的”命根子”怎么守护?
- 447. Pod 安全准入(PSS):把 414 题的基线变成集群强制?
- 448. 大节点 vs 小节点、资源碎片:集群形态怎么选?
- 449. K8s 版本升级:怎么升才不翻车?
-
- 450. 日志采集架构:容器日志怎么集中化?
- 451. K8s 事件与审计日志:排障与合规的两类”系统日志”?
- 452. kube-prometheus-stack:监控栈怎么部署与配置?
- 453. 服务指标接入:从应用到面板的完整链路?
- 454. Alertmanager:告警路由与值班体验怎么设计?
- 455. CrashLoopBackOff:崩溃循环怎么系统性诊断?
- 456. OOMKilled:容器内存问题在 K8s 里怎么定位?
- 457. Service 不通:网络排障的决策树?
- 458. kubectl debug:临时容器与节点诊断怎么用?
- 459. 本地调试三件套:port-forward、exec 与 proxy 的边界?
- 460. 备份与恢复:velero 与 etcd 快照怎么配合?
- 461. 节点维护:cordon 与 drain 的标准动作?
-
- 462. 镜像流水线:从代码合并到生产,一条链路长什么样?
- 463. 部署方式总览:kubectl apply、Helm 与 Kustomize 怎么选?
- 464. GitOps 与 ArgoCD:声明式的发布怎么运作?
- 465. Helm chart 的组织:values 分层与依赖怎么管?
- 466. Kustomize:多环境 overlay 怎么组织?
- 467. 金丝雀发布:Argo Rollouts 怎么落地?
- 468. 蓝绿部署:流量一次切换的价值与代价?
- 469. 回滚策略:不可变发布与”可逆性”怎么设计?
- 470. external-secrets:密钥怎么从 Vault 流到 Pod?
- 471. 多环境晋升:dev → staging → prod 怎么设计?
- 472. 数据库迁移与部署协同:schema 变更怎么不卡发布?
- 473. 发布门禁与渐进交付:怎么把 293 题的门禁延伸到部署侧?
-
- 474. 进程状态与负载:R、S、D 到底什么意思?
- 475. 文件描述符:fd 泄漏怎么发现与根治?
- 476. 内存全景:page cache、RSS 与 OOM killer 的宿主视角?
- 477. CPU 排查:上下文切换、运行队列与 steal?
- 478. 磁盘 IO:iostat 怎么读,队列与 Util 的陷阱?
- 479. 文件系统:inode 耗尽与”磁盘满”的另类形态?
- 480. ss 与连接状态机:TCP 排查的基本功?
- 481. tcpdump:什么时候抓包、怎么抓才有用?
- 482. iptables 与连接跟踪:K8s 网络的宿主地基?
- 483. systemd 与 journalctl:节点服务的”K8s 之外”?
- 484. /proc 与 /sys:为什么它是排障的金矿?
- 485. USE 方法:系统性性能排查的通用框架?
一、Docker 基础与镜像(400–414)
本章是 AI 工程师从”会跑 docker run”到”理解容器交付”的分水岭:背命令的人知道 EXPOSE,理解原理的人能解释为什么镜像能秒级启动、构建缓存为什么失效、容器里的 Node 为什么收不到 SIGTERM。
400. Docker 镜像分层与构建缓存:为什么你的构建那么慢?
概念 镜像由只读层(layer)堆叠而成:每条 Dockerfile 指令产生一层,层内容由指令 + 输入文件内容的哈希决定;构建缓存按”指令 + 上传上下文文件哈希”命中,一旦某层失效其后所有层重建。容器启动时在顶层加可写层(写时复制)。所以 Dockerfile 的指令顺序就是缓存策略:变得勤的步骤放后面。
典型场景 改一行代码整个镜像重建 10 分钟;CI 上缓存永远不命中;npm install 每次全量下载。
解决方案 三步递进:复现缓存失效 → 依赖与代码分离 → BuildKit 缓存挂载。
第一步:缓存失效现场——COPY 放前面毁掉一切
# 文件: Dockerfile.bad
FROM node:20-slim
WORKDIR /app
COPY . . # ❌ 任何文件变化 → 这层失效 → npm install 层跟着重建
RUN npm ci # 每次改代码都重新下载全部依赖, 构建 10 分钟
CMD ["node", "dist/main.js"]
第二步:依赖与代码分离——package.json 不变则 npm ci 层命中
# 文件: Dockerfile.good
FROM node:20-slim
WORKDIR /app
COPY package.json package-lock.json ./ # 只拷依赖清单: 这层只在依赖变化时失效
RUN npm ci # 命中缓存时秒过
COPY . . # 代码变化只重建最后两层
CMD ["node", "dist/main.js"]
第三步:BuildKit 缓存挂载——npm 缓存跨构建复用
# 文件: Dockerfile.cache
# syntax=docker/dockerfile:1.7
FROM node:20-slim
WORKDIR /app
COPY package.json package-lock.json ./
RUN --mount=type=cache,target=/root/.npm \
npm ci # npm 下载缓存持久化: 即使 lock 层失效, 也只是解压安装不重新下载
COPY . .
RUN npm run build
CMD ["node", "dist/main.js"]
# CI 上配 BuildKit 远程缓存(470 题), 分支间也能共享层 —— 构建从分钟级降到秒级
总结:镜像分层决定缓存粒度,Dockerfile 顺序决定缓存寿命:清单先行、代码殿后;BuildKit 缓存挂载解决”层失效但下载不用重来”;读构建输出里的 CACHED 标记是验证缓存命中的唯一标准。
追问1:层的哈希由什么决定? → 指令文本 + 该层输入文件内容哈希 + 父层哈希;COPY 整个目录时任何一个文件变都会换哈希 追问2:为什么指令合并(RUN apt + rm cache 写一行)能减层? → 同层内先装后清,层只保留净结果;拆两条则中间层保留 apt 缓存,镜像变大 追问3:docker history 能看出什么? → 每层大小与指令:找出把镜像撑大的元凶(常见:带走了 apt 缓存或 .git 目录)
401. 多阶段构建:镜像怎么从 1GB 瘦到 100MB?
概念 多阶段构建:用一个 Dockerfile 定义多个 FROM 阶段,构建阶段装工具链(devDependencies、tsc、gcc),运行阶段只拷产物——编译器不进最终镜像。这是镜像瘦身第一杠杆:Node 项目典型 1.2GB(node:20 带 build 工具+dev deps)→ 150MB(slim + prod deps + dist)。
典型场景 镜像拉取慢、仓库存储贵、攻击面大(devDependencies 里的漏洞全被扫出来);Node 原生模块(sharp/bcrypt)需要编译工具但运行时不需要。
解决方案 三步:基础多阶段 → 按架构/依赖再优化 → distroless 终极瘦身。
第一步:基础多阶段——builder 与 runtime 分离
# 文件: Dockerfile.ms
FROM node:20-slim AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build && npm prune --omit=dev # 产物 + 只留生产依赖
FROM node:20-slim
WORKDIR /app
ENV NODE_ENV=production
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/dist ./dist
CMD ["node", "dist/main.js"]
# builder 阶段的 tsc/devDeps/源码全部不进最终镜像
第二步:原生模块的场景——编译期与运行期分离
# 文件: Dockerfile.native
FROM node:20-slim AS builder
RUN apt-get update && apt-get install -y --no-install-recommends \
python3 make g++ libvips42 && rm -rf /var/lib/apt/lists/* # 编译 sharp 需要
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build && npm prune --omit=dev
FROM node:20-slim
RUN apt-get update && apt-get install -y --no-install-recommends libvips42 \
&& rm -rf /var/lib/apt/lists/* # 运行时只需要运行库, 不需要编译器
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/dist ./dist
CMD ["node", "dist/main.js"]
第三步:distroless——连 shell 都不要
# 文件: Dockerfile.distroless
FROM node:20-slim AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci && npm prune --omit=dev --ignore-scripts # distroless 装不了新包, 依赖全部 builder 阶段就位
COPY . .
RUN npm run build
FROM gcr.io/distroless/nodejs20-debian12
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/dist ./dist
CMD ["dist/main.js"]
# 没有 shell/apt/包管理器: 攻击者拿到 RCE 也无 curl 可用; 镜像再小一截
# 代价: 不能 docker exec 进容器调试(只能 kubectl debug 临时容器, 455 题) —— 用日志与指标换安全
总结:多阶段的本质是”编译环境与运行环境解耦”:builder 全副武装,runtime 最小可用;瘦身三板斧依次上:多阶段 → slim/alpine 基础镜像 → distroless;镜像越小,拉取快、存储省、漏洞扫描面小。
追问1:alpine 和 slim 怎么选? → slim 是 Debian 剪裁(glibc 兼容好, 原生模块稳);alpine 用 musl(更小但原生模块偶有坑)——有原生依赖选 slim, 纯 JS 选 alpine 追问2:怎么验证镜像里没有多余东西? → dive 逐层看内容差异;docker history 看层大小;扫描器(trivy)看 devDeps 是否还在 追问3:多阶段对 CI 缓存有什么影响? → 阶段间也走缓存: builder 的 npm ci 层可跨分支命中; 用 —target 只构建到某阶段做单测镜像
402. COPY 与 ADD、CMD 与 ENTRYPOINT:四组易混指令的边界?
概念 COPY 只拷文件;ADD 额外会解压 tar 与拉 URL(隐式行为,不推荐)。ENTRYPOINT 定义容器的”主命令”,CMD 提供默认参数:两者拼接成最终命令(docker run 的参数只覆盖 CMD 部分)。exec 形式([“cmd”,“arg”])与 shell 形式(cmd arg)的关键差异:shell 形式经 sh -c 启动,主进程是 sh 不是你的程序——信号收不到。
典型场景 容器 SIGTERM 后总要等 30 秒被强杀(239 题的容器版根因);想给镜像加启动脚本却把参数覆盖搞乱;ADD 一个 tar 意外被解压。
解决方案 三步:信号问题(shell vs exec 形式)→ ENTRYPOINT/CMD 组合模式 → tini 与启动脚本。
第一步:exec 形式——信号能到达主进程
# 文件: Dockerfile.exec
FROM node:20-slim
WORKDIR /app
COPY dist ./dist
# ❌ CMD node dist/main.js # sh -c node ...: SIGTERM 发给 sh, node 收不到 → 永远等强杀
CMD ["node", "dist/main.js"] # ✅ node 是 PID 1, 直接收 SIGTERM, 优雅停机才可能
# 验证: docker stop 3 秒内退出 = 信号通; 等满 10 秒 = 信号被 sh 吞了
第二步:ENTRYPOINT + CMD 组合——主命令与默认参数
# 文件: Dockerfile.combo
FROM node:20-slim
WORKDIR /app
COPY dist ./dist
ENTRYPOINT ["node", "dist/main.js"]
CMD ["--port", "3000"]
# 效果:
# docker run img → node dist/main.js --port 3000 (CMD 提供默认参数)
# docker run img --port 8080 → node dist/main.js --port 8080 (run 参数替换 CMD, ENTRYPOINT 不动)
# docker run --entrypoint sh img → 显式覆盖 ENTRYPOINT(调试用)
# 心智: ENTRYPOINT = 这个镜像"是什么", CMD = 默认"怎么跑"
第三步:启动脚本与 init 进程
# 文件: Dockerfile.entry
FROM node:20-slim
WORKDIR /app
COPY dist ./dist
COPY entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh
# 脚本做预处理(等依赖/渲染配置)后必须 exec 交接进程 —— 否则 node 变成脚本子进程, 信号还是断
ENTRYPOINT ["/entrypoint.sh"]
CMD ["node", "dist/main.js"]
#!/bin/sh
# 文件: entrypoint.sh
set -e
echo "waiting for config..." # 预处理: 渲染配置/等待 sidecar 就绪
exec "$@" # ⚠️ exec: 用 node 替换 sh 进程, PID 1 交接出去 —— 没有这行前面全白做
总结:四组边界的实用判据:COPY 优先(要解压才 ADD)、exec 形式优先(信号)、ENTRYPOINT 定主命令 + CMD 给默认参;启动脚本必须 exec 交接;容器里信号断流的排查入口永远是”谁在当 PID 1”。
追问1:docker stop 的超时后发生什么? → SIGTERM 等宽限期(默认 10s),超时发 SIGKILL——所以”stop 很慢”= 信号没到主进程或应用收尾超时(227 题) 追问2:PID 1 的僵尸进程问题是什么? → PID 1 不自动回收孤儿;Node 当 PID 1 时子进程退出可能变僵尸——加 tini(init: true 或 —init)托管(408 题) 追问3:HEALTHCHECK 指令还需要吗? → 单机有用;K8s 里被探针(424 题)取代,镜像里可以不写,避免两套健康定义漂移
403. 镜像基础选型:alpine、slim、distroless 怎么选?
概念 三类运行时基础镜像哲学:slim(Debian 减肥版,glibc 完整,兼容优先)、alpine(musl libc,~5MB,极小但原生模块/字体/加密行为有差异)、distroless(Google 出品,只有运行时 + 你的程序,无 shell 无包管理)。选型维度:原生依赖兼容、调试需求、攻击面要求、镜像分发成本。
典型场景 Node 服务用哪个基础镜像争论;Python AI 服务装 numpy/torch 时 alpine 装不上或极慢;安全合规要求最小攻击面。
解决方案 三步:决策树 → 各场景实测注意点 → 锁定 digest。
第一步:决策树
# 文件: base-choice.txt
有原生模块/科学计算依赖(numpy/torch/sharp/onnxruntime)?
├─ 是 → debian slim 系(228 题同源: 原生模块按 glibc 编译)
│ 纯 JS 的 Node 服务 → 可试 alpine, 但先过完整测试(加密/ICU/时区)
└─ 否 → 纯 JS/纯静态 → alpine(追求小)或 distroless(追求安全)
合规/对外暴露面敏感(金融/医疗)?
→ distroless: 无 shell 无包管理器, CVE 面最小, 但调试要靠临时容器(455 题)
团队调试能力与可观测成熟度一般?
→ 先 slim: 有 shell 能 exec 排障, 等观测体系(450~461 题)成熟再收紧
统一原则: 全公司基础镜像版本收敛到一两个, 用统一基础镜像 + 补丁流水线轮更
第二步:各场景的坑与验证清单
# 文件: base-verify.sh
# alpine 迁移必测:
# 1) 原生模块重装(npm rebuild) —— musl 与 glibc 二进制不通用
# 2) 加密行为: crypto 哈希结果一致(OpenSSL 版本差异)
# 3) 时区/ICU: Intl 与 TimeZone 输出(下单时间显示错 8 小时的经典事故)
# 4) 文件监控: chokidar 跨平台差异
# distroless 验证:
# 1) kubectl exec 无 shell → 用 kubectl debug 远程诊断(458 题)
# 2) 依赖在 builder 阶段全部就位(运行时装不了任何东西)
# 镜像尺寸与 CVE 三连:
docker images | grep api
trivy image api:1.0.0 --severity HIGH,CRITICAL # 411 题扫描门禁
第三步:锁定 digest——不要 tag,要 sha256
# 文件: Dockerfile.pin
# ❌ FROM node:20-slim # tag 会被上游悄悄重推(打补丁), 昨天和今天构建的不是同一个镜像
FROM node:20-slim@sha256:3d3e2d1d8d1a2f3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2c3d4e5f6a7
# digest 固定到字节级: 构建可复现, 供应链可审计(423 题锁定思想的镜像版)
# 运维节奏: 统一升级 PR(renovate 管 digest) → 全量重建 → canary 验证(282 题)
总结:基础镜像是供应链的地基:兼容优先 slim、极致小 alpine、安全优先 distroless;决策依据是原生依赖与团队能力而不是”哪个新”;无论选谁都要 digest 锁定 + 统一轮更,别让基础镜像成为不可复现的暗变量。
追问1:为什么 musl 下 numpy/torch 特别慢? → 官方 wheel 按 glibc 构建, musl 下要源码编译且部分优化路径失效;AI 镜像一律 Debian 系 追问2:基础镜像 CVE 扫描爆红怎么办? → 分层看: 可达性分析(服务是否用到受影响组件)→ 升级基础镜像 → 不可达的记录豁免;扫描门禁要”高危且可达”才挡(411 题) 追问3:scratch 基础镜像什么时候用? → 静态编译的 Go/Rust 二进制;Node/Python 这类解释型运行时用不了 scratch, 对应的是 distroless
404. 容器文件系统:overlay2 与写时复制是怎么回事?
概念 容器根文件系统 = 镜像只读层 + 顶部可写层,用 overlay FS 实现:读时自上而下找第一个命中(upperdir → lowerdir);写时复制(copy-up):修改只读层的文件先整个复制到可写层再改;删除是 whiteout 标记遮盖。镜像层在宿主机被同镜像的所有容器共享,所以”再起一个容器只要 MB 级内存”。
典型场景 容器里改了文件重启后消失;大文件编辑让容器启动/首次写变慢(copy-up 整文件拷贝);容器删了日志也想找回。
解决方案 三步:读写行为验证 → copy-up 的性能陷阱 → 数据放 volume。
第一步:读写行为验证
# 文件: overlay-demo.sh
docker run --rm node:20-slim sh -c '
echo hi > /tmp/a && rm /etc/hostname 2>/dev/null;
cat /usr/local/bin/node > /dev/null && echo read-ok'
# 解读:
# 写 /tmp/a → 落在可写层(upperdir), 容器删除即消失
# rm /etc/hostname → whiteout 遮盖, 镜像层文件并未删除
# 读 node 二进制 → 直接命中镜像只读层, 多容器共享同一份 page cache
# 宿主机视角: docker inspect <id> | grep -A3 GraphDriver 看 upperdir/lowerdir 实际路径
第二步:copy-up 的性能陷阱
# 文件: copyup.txt
在容器内修改镜像里已有的大文件(如虚拟机镜像、大数据库文件)时:
首次写触发 copy-up —— 整个文件从只读层复制到可写层
一个 2GB 的文件改 1 字节 = 先拷 2GB
正确姿势: 大文件/高频写路径放 volume(405 题)或挂载宿主目录, 绕过 overlay
验证: time dd if=/dev/zero of=/data/inside.img bs=1M count=512 第一次与第二次的耗时差
第三步:什么数据该放哪
# 文件: data-placement.txt
可写层(默认): 临时文件、进程运行态 —— 随容器生命周期, 随时可以被丢弃重建(无状态原则)
named volume: 数据库数据、需要持久化但不想管宿主路径的场景 —— 由 docker 管理, 删容器不删卷
bind mount: 开发时挂源码、配置文件直投 —— 路径耦合宿主机, 生产少用(K8s 里对应 hostPath, 445 题)
判据一句话: 这个目录的内容, 容器重建后还需不需要? 需要 → volume;不需要 → 可写层
总结:overlay2 = 只读层栈 + 可写层 + whiteout;写时复制是”改镜像文件先整拷”的性能税,大数据放 volume 绕开;容器可写层是易失的——把”可丢弃”作为默认设计,状态外置是十二要素的核心。
追问1:镜像层共享在 K8s 节点上意味着什么? → 同镜像的多个 Pod 共享只读层与 page cache,节点镜像缓存(GC 策略)决定拉取成本——滚动更新时新 Pod 秒起的原因 追问2:容器可写层会无限涨吗? → 会: 日志/临时文件都写可写层;单机靠 —storage-opt 限额, K8s 靠 ephemeral-storage 上限驱逐(437 题) 追问3:docker commit 产生的镜像为什么”脏”? → 它把可写层固化成镜像层: 手工改动不可追溯、包含垃圾文件 —— 生产镜像必须由 Dockerfile 构建(可复现), commit 只用于现场取证
405. volume 与 bind mount:容器数据持久化怎么做?
概念 三种挂载:named volume(Docker 管理的持久卷,独立于容器生命周期)、bind mount(宿主目录直投容器路径)、tmpfs(内存挂载,敏感临时数据)。核心判据:数据生命周期与容器解耦的需要程度。K8s 侧对应 PVC/emptyDir(445 题)。
典型场景 数据库容器删了数据也没了;开发时源码热更新;token 之类敏感文件不想落盘。
解决方案 三步:volume 基本操作 → bind mount 的开发场景与坑 → tmpfs 与权限。
第一步:named volume——持久数据的默认答案
# 文件: volume-ops.sh
docker volume create pgdata # 显式创建(或 -v pgdata:/var/lib/postgresql/data 隐式建)
docker run -d --name pg -v pgdata:/var/lib/postgresql/data -e POSTGRES_PASSWORD=xx postgres:16
docker rm -f pg && docker run -d --name pg -v pgdata:/var/lib/postgresql/data ... postgres:16
# 数据还在: 卷的生命周期独立于容器
docker volume ls; docker volume inspect pgdata # 实际路径在 /var/lib/docker/volumes/...
docker run --rm -v pgdata:/data -v $(pwd):/backup alpine \
sh -c 'cd /data && tar czf /backup/pgdata.tgz .' # 备份: 挂同一个卷的临时容器打包
# 匿名卷(-v /var/lib/...)容易泄漏: 定期 docker volume prune 清理无主卷
第二步:bind mount——开发的源码热更新
# 文件: bind-dev.sh
docker run -it --rm \
-v "$(pwd)/src:/app/src" \
-v "$(pwd)/package.json:/app/package.json" \
-p 3000:3000 node:20-slim sh -c 'npm i && npm run dev'
# 源码变更实时反映进容器(依赖只装一次, 用具名卷缓存 node_modules):
docker run -it --rm \
-v "$(pwd):/app" -v app_node_modules:/app/node_modules \
-w /app node:20-slim sh -c 'npm i && npm run dev'
# ⚠️ 关键技巧: node_modules 用 volume "遮盖" 宿主目录 —— 否则宿主的 node_modules(可能装了别的平台的
# 原生模块)会覆盖容器内的, 直接报 NODE_MODULE_VERSION 错(228 题同款 ABI 问题)
第三步:tmpfs 与权限收紧
# 文件: docker-compose.tmpfs.yml
services:
api:
image: api:1.0.0
tmpfs:
- /tmp:size=100m,mode=1777 # 临时文件不落盘: 密钥处理的中间产物、上传暂存
read_only: true # 根文件系统只读 —— 强迫所有写入显式声明挂载点
volumes:
- api-cache:/var/cache/app # 唯一可写点: 显式声明的缓存卷
volumes:
api-cache: {}
# read_only + 显式可写点: 文件系统层面的最小权限, 乱写文件的 bug 在开发期就炸出来
总结:挂载选型按数据归属:持久数据 named volume、开发源码 bind mount(注意 node_modules 遮盖)、敏感临时 tmpfs;生产容器尽量 read_only + 白名单挂载点,让”哪里会写”成为显式设计。
追问1:volume 和 bind mount 在性能上有差异吗? → volume 在 Linux 上同为 overlay 之上的文件系统,量级相近;macOS/Windows 的 bind mount 跨虚拟机边界,慢一个数量级(开发慢的常见根因) 追问2:多个容器共享一个 volume 安全吗? → 要并发协调:数据库类一写多读可以,多写需要文件锁或外部协调——通常说明该上真正的共享存储 追问3:K8s 里对应物是什么? → volume→PVC,bind mount→hostPath(少用),tmpfs→emptyDir medium: Memory(444 题)
406. 容器网络:bridge、host 与端口映射是怎么回事?
概念 单机网络模式:bridge(默认,虚拟网桥 + veth,容器有独立 netns,NAT 出网)、host(共享宿主网络栈,无隔离但低开销)、none(只有 lo)。端口映射(-p)是 iptables DNAT:宿主端口→容器 IP:端口。容器间通信用容器网络(compose 里服务名互访,自建 DNS)。
典型场景 容器里连不上宿主的数据库;localhost 语义混乱(容器里的 localhost 不是宿主);端口映射后外网访问不通。
解决方案 三步:bridge 与端口映射 → host.docker.internal 与宿主互访 → compose 服务网络。
第一步:bridge 模式与端口映射验证
# 文件: net-bridge.sh
docker run -d --name api -p 3000:3000 api:1.0.0
# 数据路径: 外部 → 宿主:3000 →(iptables DNAT)→ 容器 IP:172.17.0.2:3000
docker inspect api | grep IPAddress # 容器在 docker0 网桥的子网内
docker exec api sh -c 'curl -s ifconfig.me' # 容器出网: SNAT 成宿主 IP
# ⚠️ -p 3000:3000 绑定的是宿主所有网卡; 只想本机访问用 -p 127.0.0.1:3000:3000
# EXPOSE 指令只是文档声明, 不产生任何映射 —— 真正开放端口全靠 -p
第二步:容器与宿主互访
# 文件: net-host.sh
# 容器 → 宿主上的服务(本地开发的数据库):
docker run --rm api:1.0.0 sh -c 'curl http://host.docker.internal:5432'
# Mac/Win 内建; Linux 要 --add-host=host.docker.internal:host-gateway
# localhost 陷阱: 容器里的 localhost = 容器自己 —— 连宿主必须用 host.docker.internal 或网关 IP
# host 模式(对照): --network host 下容器直接用宿主网络栈, localhost 才等于宿主
# 代价: 端口冲突无隔离、攻击面变大 —— 一般只给高性能转发类组件用
第三步:compose 的服务网络
# 文件: compose-net.yml
services:
api:
image: api:1.0.0
environment:
DATABASE_URL: postgres://user:pass@db:5432/app # 用服务名 "db" 而不是 IP
depends_on: [db]
db:
image: postgres:16
environment: { POSTGRES_PASSWORD: pass }
# compose 自动建独立网络 + 内嵌 DNS: 服务名即域名, 容器重启 IP 变了也不影响
# 多环境: networks: 段定义多个网络, 把前后台分网隔离(数据库不暴露给无关服务)
总结:bridge 是默认与底线:独立 netns + NAT;host 换性能舍隔离;容器间通信靠自建 DNS 用服务名;localhost 语义在容器里会骗人——跨边界一律用显式名字。
追问1:同一宿主两个容器怎么互通? → 同一 bridge 网络内直接访问容器名/IP(不走 -p 映射);不同网络要 networks 连通或走宿主端口 追问2:K8s 的网络模型和这个什么关系? → Pod 也是 IP 级互通(flat network),Service 是稳定虚拟 IP——单机 bridge 的”每容器一 IP”思想被推广到集群(419 题) 追问3:容器里 DNS 解析慢怎么办? → ndots 问题:resolv.conf 里 search 域 + 未加点域名触发多次查询;用全限定名(db.corp.local.)或调 ndots:1
407. Docker Compose:本地多服务编排怎么组织?
概念 Compose 用一个 YAML 声明多容器应用(services/networks/volumes),一条命令拉起完整环境;核心能力:依赖顺序、环境变量插值、覆盖文件(override)分层、健康检查 gating。定位:开发/测试环境的事实标准,生产交给 K8s(415 题起)——同一份”服务拓扑”思想的两种宿主。
典型场景 新人入职一天配不齐 pg+redis+mq;本地要模拟完整链路;CI 里起真实依赖(289 题集成测试)。
解决方案 三步:基础 compose → override 分层 → 健康检查与依赖。
第一步:基础文件——完整拓扑一图流
# 文件: docker-compose.yml
services:
api:
build: { context: ., dockerfile: Dockerfile } # 开发直接从源码构建
ports: ["3000:3000"]
environment:
DATABASE_URL: postgres://app:app@db:5432/app
REDIS_URL: redis://cache:6379
depends_on:
db: { condition: service_healthy } # 等 db 真就绪, 不只是"启动了"
cache: { condition: service_started }
volumes:
- ./src:/app/src # 源码热更新(405 题遮盖技巧)
- api_node_modules:/app/node_modules
healthcheck:
test: ["CMD", "wget", "-qO-", "http://localhost:3000/health"]
interval: 5s
retries: 3
db:
image: postgres:16
environment: { POSTGRES_USER: app, POSTGRES_PASSWORD: app, POSTGRES_DB: app }
volumes: [pgdata:/var/lib/postgresql/data]
healthcheck:
test: ["CMD-SHELL", "pg_isready -U app"]
interval: 3s
cache:
image: redis:7-alpine
volumes: { pgdata: {}, api_node_modules: {} }
第二步:override 分层——本地差异不打散主文件
# 文件: docker-compose.override.yml(自动叠加, 不用 -f 指定)
services:
api:
command: npm run dev # 本地跑 dev 模式(热更新)
environment:
LOG_LEVEL: debug
# docker-compose.debug.yml(显式 -f 使用):
# 挂 profiling 工具、开 inspector 端口
# 分层纪律: 主文件放"拓扑真相"(有哪些服务、怎么连), 差异文件只放"怎么跑"
第三步:CI 里的用法与陷阱
# 文件: ci-compose.yml(GitHub Actions 片段)
# 与 289 题集成测试配合: 真实依赖用 compose 起, 测试跑在 CI 容器里
services:
pg:
image: postgres:16
env: { POSTGRES_PASSWORD: test }
ports: ["5432:5432"]
options: >-
--health-cmd "pg_isready -U postgres" --health-interval 3s --health-retries 10
# 陷阱清单:
# 1) 容器 "started" ≠ 依赖可用 —— 必须 healthcheck gating
# 2) 端口冲突: CI 并行任务用随机映射(publish-all / -P)
# 3) 卷残留: CI 用 --renew-anon-volumes 防脏数据串测试
总结:compose 的价值是把环境变成代码:拓扑一图流、差异分层、就绪靠 healthcheck gating;它是 K8s 的思维前身——学会用服务名思考拓扑,manifest 只是换了语法。
追问1:depends_on 的 condition 有哪几种? → service_started(进程起)/service_healthy(健康检查过)/service_completed_successfully(初始化任务跑完,如等迁移容器) 追问2:compose 里怎么做数据库迁移? → 独立 migrate 服务(service_completed_successfully)+ api 依赖它;或应用启动时自迁移(小项目) 追问3:compose 能上生产吗? → 有 compose spec 的生产实现(Swarm/第三方),但生态已收敛到 K8s——compose 留在开发与 CI,别让两套编排漂移
408. 容器里的 PID 1:僵尸进程与信号处理?
概念 容器内主进程是 PID 1(独立 PID namespace):PID 1 特殊——默认忽略很多信号、且负责回收孤儿进程。Node/Python 当 PID 1 的两个坑:收到 SIGTERM 但没注册处理器(默认不退出,容器等强杀);spawn 的子进程退出后无人 reap 变僵尸。解法:tini/—init 当 PID 1,或应用自己处理信号 + reap。
典型场景 docker stop 永远等满超时被 SIGKILL;容器 ps 里一堆 defunct 僵尸进程;spawn 的 ffmpeg 转码任务残留。
解决方案 三步:复现两个坑 → tini 方案 → 应用层正确姿势。
第一步:坑的复现
# 文件: pid1-bug.sh
# 坑1: 信号 —— node 没监听 SIGTERM 时, PID 1 默认行为是"忽略"而不是终止
docker run -d --name t1 node:20-slim node -e "setInterval(()=>{},1e9)"
docker stop t1 # 卡满 10 秒才杀(SIGTERM 被忽略, 等 SIGKILL)
# 坑2: 僵尸 —— node 当 PID 1, spawn 的子进程退出后没人 reap
docker run -d --name t2 node:20-slim node -e "
const {spawn}=require('child_process');
setInterval(()=>{ const p=spawn('true'); p.on('exit',()=>{}); }, 100);"
sleep 3 && docker exec t2 ps aux | head # 一排 [true] <defunct>
第二步:tini——把 PID 1 交给专业选手
# 文件: Dockerfile.tini
FROM node:20-slim
RUN apt-get update && apt-get install -y --no-install-recommends tini && rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY dist ./dist
ENTRYPOINT ["/usr/bin/tini", "--"] # tini 当 PID 1: 转发信号 + reap 僵尸
CMD ["node", "dist/main.js"]
# 更简单: docker run --init(注入 docker-init, 效果同);
# K8s 侧: shareProcessNamespace: true 或镜像内 tini —— shareProcessNamespace 有副作用(PID 1 变 pause), 常用镜像内 tini
第三步:应用层正确姿势(Nest/Node)
// 文件: main.ts(Nest 侧配合 239 题)
// 1) 信号必须显式处理(enableShutdownHooks 的底层就是这些事件)
process.on('SIGTERM', () => app.close().then(() => process.exit(0)));
// 2) spawn 子进程必须消费 exit 事件(触发 reap), 长任务要可中止(227 题 AbortController)
// 3) 别用 shell 形式起子进程(shell 会再 fork 一层, 信号与僵尸都难管):
import { spawn } from 'node:child_process';
const p = spawn('ffmpeg', ['-i', inPath, outPath]); // ✅ exec 形式
p.on('exit', (code) => logger.log(`ffmpeg exit ${code}`));
总结:PID 1 的两件职责(响应信号、reap 孤儿)默认不是你的应用擅长的事;镜像里 tini 或 —init 兜底,应用侧显式处理信号 + 消费子进程 exit;排查口令:容器里 ps 看 defunct、docker stop 秒退与否。
追问1:shareProcessNamespace 的机制? → Pod 的 1 号进程变成 pause,业务容器进程不再是 PID 1,信号与僵尸由 pause 之外各容器自己处理——副作用是 ps 能看到别的容器进程 追问2:僵尸进程有什么实际危害? → 占 PID 与进程表项,泄漏积累后无法再 fork;本身不吃内存 CPU,但说明 reap 链路断了 追问3:为什么 PID 1 默认忽略信号? → 内核对 init 进程的保护设计:未注册 handler 的致命信号对 PID 1 无效——防止”祖先进程被随手杀死”,容器把它继承了下来
409. namespace 与 cgroups:容器和虚拟机的本质区别?
概念 容器 = 共享宿主内核的被隔离进程组:namespace 隔离”看得见什么”(PID/net/mnt/uts/ipc/user 六大空间),cgroups 隔离”用得了多少”(CPU/内存/IO/设备配额)。虚拟机则通过 Hypervisor 虚拟整套硬件、跑独立内核。所以:容器秒级启动、密度高,但隔离强度弱于 VM(共享内核);逃逸风险 = 内核漏洞面。
典型场景 面试概念题;“容器是不是轻量虚拟机”争论;多租户隔离选型(容器 vs VM vs 混合)。
解决方案 三步:namespace 清单与验证 → cgroups 验证 → 隔离强度与选型结论。
第一步:namespace——资源的”视图”隔离
# 文件: ns-demo.sh
docker run --rm -d --name box node:20-slim node -e "setInterval(()=>{},1e9)"
# 容器内 PID 空间: 自己是 1
docker exec box sh -c 'echo pid=$$' # pid=1
docker inspect box --format '{{.State.Pid}}' # 宿主视角的真实 PID, 如 12345
ls /proc/12345/ns/ # 每个进程的 6 个 namespace 链接:
# pid(进程号) net(网卡/端口/路由) mnt(挂载点) uts(主机名) ipc(信号量/共享内存) user(uid 映射)
# 验证网络隔离: 容器有独立的 eth0/veth 对, iptables NAT 出网(406 题)
docker exec box ip addr
第二步:cgroups——资源的”额度”限制
# 文件: cgroup-demo.sh
docker run --rm -m 256m --cpus=1.5 node:20-slim node -e "
const a=[]; setInterval(()=>a.push(Buffer.alloc(1024*1024)),100);"
# -m 256m: cgroup memory.max=256MiB —— 超限触发 cgroup OOM kill(退出码 137, 410 题细讲)
# --cpus=1.5: 等价 cpu.max=150000/100000 —— 每 100ms 调度周期最多用 150ms CPU(可跨核)
# 对照虚拟机: VM 要先虚拟硬件+引导内核(分钟级), 容器只是 clone(2) 带 flags 的进程(毫秒级)
ls /sys/fs/cgroup/.../memory.max # cgroup v2 统一层级, 容器配额就写在这些文件里
第三步:隔离强度与选型
# 文件: isolation-choice.txt
共享内核的后果:
1) 内核漏洞 = 容器逃逸面(runc CVE 历史) —— 敏感多租户要 VM/沙箱层(gVisor/Kata)
2) /proc、sysctl 部分可见性与全局性(某个 namespace 化, 某些是宿主全局)
3) 内核参数调优影响同宿主所有容器(TCP 缓冲区类)
工程选型:
同公司服务互信 → 纯容器(K8s 默认)
强隔离需求(跑外部代码/高密多租户) → gVisor(用户态内核)/ Kata(轻量 VM)/ 独立 VM
AI 平台常见: 训练/推理任务来自多团队 → 节点池按信任级分池 + 独占节点(486 题 GPU 场景同源)
总结:容器不是小虚拟机,是”namespace 给视图 + cgroups 给额度”的隔离进程组;启动快密度高的代价是共享内核的隔离边界;强隔离场景叠沙箱或 VM 层,别拿默认容器硬扛。
追问1:user namespace 解决什么? → 容器内 root 映射为宿主普通用户:即使逃逸也拿不到宿主 root——Docker 默认没开,K8s 侧 userNs 开逐步支持 追问2:容器能看到宿主的 ps 吗? → 默认不能(PID namespace);hostPID: true 或 shareProcessNamespace 才共享——安全审计要盯这两个开关 追问3:IO 也被 cgroups 限制吗? → blkio cgroup 限块设备带宽/IOPS;网络 IO 不在 cgroups,靠网络 QoS(tc/带宽插件)
410. 容器资源限制:—memory 与 —cpus 之下到底发生什么?
概念 内存限制:超限时 cgroup OOM killer 杀掉容器内进程(退出码 137),没有商量;CPU 限制:超限时被节流(throttle),进程变慢但不死。与 Node 的配合:V8 堆上限必须显式小于容器限额并给堆外留余量(219 题);CPU 节流会造成尾延迟毛刺——CPU limit 要么不给、要么按测量给。
典型场景 容器莫名重启(137)找不到原因;加了 CPU limit 后 P99 飙升;容器内存限额 512M 但 Node 默认堆按宿主内存推算直接爆。
解决方案 三步:OOM 现场与判读 → CPU 节流观测 → 配置纪律。
第一步:OOM 现场与判读
# 文件: oom-demo.sh
docker run --rm -m 200m node:20-slim node --max-old-space-size=1024 -e "
const a=[]; setInterval(()=>a.push(new Array(1e6).fill(0)),200);"
# 结局: V8 想堆 1G, cgroup 只给 200M → cgroup OOM kill, 退出码 137(OOMKilled)
docker inspect <id> --format '{{.State.OOMKilled}} {{.State.ExitCode}}' # true 137
# 判读三件套:
# 1) OOMKilled=true → 内存超限, 看下一条定位谁吃的
# 2) 宿主 dmesg | grep -i oom → 内核记录的进程 RSS 与 cgroup 路径
# 3) 应用内 process.memoryUsage() 指标(214 题): heapUsed 涨还是 external 涨(219 题堆外)
第二步:CPU 节流观测
# 文件: cpu-throttle.sh
docker run -d --name cpu1 --cpus=1 api:1.0.0
# cgroup v2: 节流统计文件
CAT=/sys/fs/cgroup/$(docker inspect cpu1 --format '{{.Id}}' | cut -c1-12)/...
cat $CAT/cpu.stat # nr_throttled(节流次数) throttled_usec(被节流总时长)
# 现象链: limit=1 核, 瞬时要用 1.2 核 → 100ms 周期内前 83ms 用完额度 → 剩 17ms 强制睡眠
# → 单请求尾延迟抬升 → P99 毛刺(286 题容量视角)
# 结论: CPU limit 是尾延迟杀手; 常见策略: 只设 request 不设 limit(K8s, 423 题), 或按压测给足
第三步:配置纪律
# 文件: compose-resources.yml
services:
api:
image: api:1.0.0
mem_limit: 512m # 硬限: OOM 边界
environment:
NODE_OPTIONS: --max-old-space-size=358 # 219 题: 堆 ≈ 限额 70%, 余量给堆外/线程栈
deploy:
resources:
limits: { cpus: "2", memory: 512M }
reservations: { cpus: "0.5", memory: 256M } # 软保留: 调度保障
# 验证: 压测下观察 3 个信号 —— OOMKilled 次数 / cpu.stat 节流 / P99 曲线(286 题拐点法)
总结:内存超限是”死”(OOMKilled 137),CPU 超限是”慢”(节流);Node 的堆上限要主动对齐容器限额;CPU limit 慎给——它是用尾延迟换”公平”;资源问题的观测三件套:退出码、cgroup 统计、应用内存指标。
追问1:OOMKilled 和应用 panic 怎么区分? → 退出码 137(SIGKILL)+ OOMKilled=true 是 cgroup OOM;应用异常退出有自己的日志与非 137 码 追问2:内存 limit 给 swap 会怎样? → 容器默认禁 swap;开启后超限先换页(变慢)不死——K8s 节点普遍禁 swap,别依赖 追问3:request 和 limit 的区别(K8s 语境)? → request 用于调度承诺,limit 是运行时硬顶;内存 limit 超 = 死,CPU limit 超 = 节流(423 题细讲)
411. 镜像仓库:私有 registry 与分发加速怎么做?
概念 registry 存镜像 manifest 与层 blob;pull = 拉 manifest → 按需拉层(带 range 续传);私有 registry(Harbor)的增值:RBAC、漏洞扫描、镜像复制(跨区域)、代理缓存(拉公共镜像走本地缓存)。镜像标签的不可变性只有 digest 有:同 tag 可被覆盖,生产引用要 digest 或强推纪律。
典型场景 公司镜像放 Docker Hub 又慢又有配额;多机房拉镜像拖慢扩容;公共镜像反复外拉浪费带宽。
解决方案 三步:Harbor 部署形态 → 代理缓存 → 分发加速。
第一步:私有 registry 基本形态
# 文件: registry-basic.sh
# 最小 registry(测试):
docker run -d -p 5000:5000 -v regdata:/var/lib/registry --restart=always registry:2
# 生产标准: Harbor —— 在裸 registry 之上加了项目/RBAC/扫描/复制/签名
# docker run -d -p 443:443 goharbor/harbor-core... (正式部署用 installer/chart)
docker tag api:1.0.0 harbor.corp.local/team/api:1.0.0
docker push harbor.corp.local/team/api:1.0.0
# 命名结构: registry/项目/镜像:tag —— 项目即权限边界(前端团队 push 不了后端项目)
# CI 侧: 构建机 docker login 用 robot 账号(最小权限, 只推指定项目)
第二步:代理缓存——公共镜像走本地
# 文件: harbor-proxy.txt
Harbor 配置 proxy cache 项目(指向 docker.io):
团队 pull harbor.corp.local/docker-proxy/library/nginx:1.25
→ 首次: Harbor 代拉 docker.io 并缓存 blob
→ 后续: 节点内网秒拉
配套纪律:
1) 基础镜像白名单化(403 题 digest 锁定的前提)
2) 上游被删(投毒下架)不影响已缓存层 —— 供应链缓冲区(423 题冷却期思想)
3) K8s 节点 imagePullSecrets 指向 Harbor robot(422 题 imagePullSecrets)
第三步:分发加速与多机房
# 文件: distribution.txt
大規模节点拉取优化:
1) P2P 分发(Dragonfly/Spegel): 千节点并发拉同一镜像, 层在节点间互传, registry 只出一份
2) 跨区域复制(Harbor replication rule): push 主库自动复制到区域库, 就近拉取
3) 镜像预热(preheat): 大规模扩容前把镜像预拉到目标节点(避免扩容潮全部打 registry)
4) 镜像本身够小(401 题)是最根本的加速 —— 分层共享让滚动更新只拉差异层
总结:registry 是镜像供应链的心脏:私有化用 Harbor(RBAC/扫描/复制),公共镜像走代理缓存;tag 会骗人,digest 不会;大规模场景的优化顺序:镜像瘦身 → 分层共享 → 预热 → P2P。
追问1:pull 一个镜像的实际网络流程? → GET manifest(认证 token)→ 对比本地已有层 → 并发 GET 缺失 blob(range 断点续传)→ 组装 overlay 层 追问2:latest tag 的生产危害? → 不可复现、回滚无锚点、缓存误导 —— 生产禁用 latest,发布用语义 tag + digest 双保险 追问3:镜像 GC 怎么做才安全? → Harbor 的 GC 要停写或用无停机模式;先改保留策略(按 tag 数/天数)再 GC,防止正在使用的层被误删
412. 镜像扫描与签名:trivy 与 cosign 怎么进流水线?
概念 镜像安全两件套:扫描(trivy 等,比对层内包的 CVE 库,输出漏洞清单)与签名(cosign,用密钥对镜像 digest 签名,部署侧验签)。定位:扫描是”发现”(门禁拦高危),签名是”证明”(只允许自己签过的镜像跑)。两者都锚定 digest——与 222 题供应链门禁衔接。
典型场景 基础镜像 CVE 爆红要不要发版;防止被投毒的镜像进集群;审计要求镜像来源可追溯。
解决方案 三步:trivy 扫描与门禁 → cosign 签发与验证 → 准入控制串起来。
第一步:trivy 扫描与分级门禁
# 文件: trivy-gate.sh
trivy image --severity HIGH,CRITICAL --exit-code 1 harbor.corp.local/team/api:1.0.0
# CI 用法(293 题流水线的一站):
# 1) 构建后立即扫: 高危且可达 → 挡合并
# 2) 基础镜像问题 → 升级基础镜像 PR(别在应用层补丁硬修)
# 3) 不可达的记录豁免(.trivyignore 带原因与到期日) —— 豁免要有期限, 否则名单无限膨胀
trivy image --format json --output report.json api:1.0.0 # 结构化结果进质量看板
第二步:cosign 签名与验证
# 文件: cosign-flow.sh
# 密钥用 KMS 托管(283 题思想: 密钥不落盘)
cosign sign --key hashivault://ci-sign harbor.corp.local/team/api@sha256:abc... # 对 digest 签, 不对 tag 签
cosign verify --key hashivault://ci-sign harbor.corp.local/team/api@sha256:abc...
# 流程: CI 构建并推镜像 → 扫描过 → 用 CI 身份(KMS 密钥)签名 → 部署系统只认签名
# keyless 模式更现代: 用 OIDC(GitHub Actions token)身份签名, 验证方校验身份与 repo —— 免管密钥
第三步:准入控制——没有签名的镜像不准跑
# 文件: policy.yaml(kyverno/cosign-guard 策略示意)
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata: { name: verify-image-signature }
spec:
validationFailureAction: Enforce
rules:
- name: check-signature
match: { resources: { kinds: [Pod] } }
verifyImages:
- imageReferences: ["harbor.corp.local/team/*"]
attestors: [{ entries: [{ keys: { secretRef: { name: cosign-pub } } }] }]
# 效果: 即使有人拿到集群权限塞一个未签名镜像, 准入控制器直接拒绝 —— "供应链的最后一道门"
总结:扫描管”带没带病”(trivy 门禁 + 有期限豁免),签名管”是不是自己人”(cosign 按 digest 签 + 准入验签);两者组合把镜像从”随便一个 tar”变成有身份、有体检报告的交付物。
追问1:扫描为什么会误报很多? → CVE 在层里 ≠ 可达(没被调用的库);修复靠可达性分析或运行时检测,粗暴”全修”会疲于奔命 追问2:SBOM 是什么、和扫描什么关系? → 镜像内软件物料清单(syft 生成);扫描 = SBOM × CVE 库 —— 存 SBOM 才能在新 CVE 出现时反查”哪些镜像中招”(222 题) 追问3:签名的镜像被要求紧急回滚怎么办? → 回滚也是部署已签名的历史 digest,不需要重新签——这是”按 digest 签”的好处
413. .dockerignore 与构建上下文:被忽视的构建提速?
概念 docker build 会把”构建上下文”(命令行路径的整个目录)打包发给 daemon,再按 Dockerfile 处理;.dockerignore 在发送前剔除文件。不发 = 不上传(提速)、不进 COPY(安全:.git 密钥)、不破缓存(无关文件变化不再使 COPY 层失效)。
典型场景 构建日志 “transferring context 800MB” 等半分钟;.git 被打进镜像(泄露历史);node_modules 拷进镜像又装一遍。
解决方案 三步:上下文实测 → 标准 ignore 清单 → 生成与维护。
第一步:上下文实测
# 文件: ctx-measure.sh
docker build -t api:tmp . # 观察Sending build context to Docker daemon X MB
du -sh . # 目录实际大小对比
# 没有 .dockerignore 时: .git(可能几百 MB)/node_modules/日志/媒体文件全部上传
# 即使 Dockerfile 没 COPY 它们 —— 上传发生在解析 Dockerfile 之前
第二步:标准清单
# 文件: .dockerignore
.git
.gitignore
node_modules
dist
coverage
*.log
.env
.env.*
!.env.example
docker-compose*.yml
Dockerfile*
README.md
.vscode
.idea
# 注释掉的是刻意的反例:
# .env 必须忽略(密钥进镜像 = 事故); 需要默认值用 .env.example
# dist 忽略: 镜像内构建(401 题多阶段), 宿主产物不该进上下文
# ! 语法反向包含: 需要 COPY docs 进镜像时用 !docs
第三步:生成与维护纪律
# 文件: ignore-hygiene.txt
1) 新项目脚手架自带(模板仓库统一)
2) CI 检查: 上下文大小超过阈值(如 50MB)直接告警 —— 防止"没人注意时"长回 800MB
3) 与 .gitignore 的关系: 语义不同(一个防入库, 一个防入镜像), 内容有重叠但不互相替代
4) 安全联动: 定期扫镜像里的敏感文件路径(如 COPY . . 项目重点查)
docker run --rm api:1.0.0 sh -c 'ls -la /app | head' 之外, 用 dive 看层内实际内容
总结:.dockerignore 三重收益:上下文小(快)、镜像干净(安全)、缓存稳(准);它是 Dockerfile 的另一半,新建项目第一天就该有;上下文大小是构建健康度的免费指标。
追问1:构建上下文和 WORKDIR 什么关系? → 无关:上下文是”发给 daemon 的打包目录”,COPY 的源路径相对它;WORKDIR 只是容器内路径 追问2:为什么 COPY . . 还是需要的场景怎么防敏感文件? → ignore 兜底 + 镜像扫描敏感文件 + 密钥只在运行时注入(env/K8s Secret, 422 题),镜像零密钥是铁律 追问3:多阶段构建需要忽略 dist 吗? → 需要:镜像内会重新构建,宿主 dist 进上下文只会拖慢与污染缓存命中
414. 容器安全基线:非 root、capability 收缩与 seccomp?
概念 默认容器以 root 跑(只是被 namespace 削权):仍持有一组默认 capabilities(CHOWN/NET_BIND_SERVICE 等),root + 漏洞 = 逃逸放大器。安全基线三层:USER 降权(非 root 运行)、capability 白名单(cap_drop ALL 再按需 add)、seccomp 系统调用过滤(默认 profile 已挡高危 syscall,可再收紧)。
典型场景 安全审计要求非 root;容器内要绑 80 端口但不想给 root;合规扫描报告 capability 过多。
解决方案 三步:USER 降权 → capability 收缩 → readOnly + 组合基线。
第一步:USER 降权
# 文件: Dockerfile.user
FROM node:20-slim
WORKDIR /app
COPY --chown=node:node dist ./dist # 属主一起改, 否则非 root 写不了
COPY --chown=node:node node_modules ./node_modules
USER node # node 官方镜像自带 uid 1000 的 node 用户
CMD ["node", "dist/main.js"]
# ⚠️ 文件权限: 运行时要写的路径(volume 挂载点)必须对 uid 可写 ——
# 宿主 volume 的属主是 root 时, 非 root 容器写不进(经典报错 EACCES)
第二步:capability 白名单
# 文件: caps.sh
docker run --rm node:20-slim sh -c 'grep CapEff /proc/self/status'
# 默认携带十余项 capability
docker run --rm --cap-drop=ALL --cap-add=NET_BIND_SERVICE api:1.0.0
# 收缩到只剩"绑低端口"一项 —— 需要特权的场景逐项加, 加的时候写注释说明用途
# 常见需求对照:
# 绑 80/443 → NET_BIND_SERVICE(或干脆改应用监听 3000, 别要这个权限)
# chown volume → CHOWN(或初始化容器一次性格式化属主后撤掉)
# tcpdump 排障 → NET_RAW(临时开, 用完撤)
# ⚠️ --privileged 是核弹: 全部 capability + 设备全访问 —— 生产禁用, 测试仪器的例外要审批
第三步:组合基线与验证
# 文件: hardened.yaml(compose/K8s 通用字段)
services:
api:
image: api:1.0.0
user: "1000:1000" # 非 root
read_only: true # 根文件系统只读(405 题)
cap_drop: [ALL] # 清空 capability
security_opt: [no-new-privileges:true] # 禁止提权(setuid 失效)
tmpfs: [/tmp]
# 验证清单:
# id → uid=1000;grep Cap /proc/self/status → 全 0
# 尝试 touch /etc/x → 只读拒绝
# 基线分级: 一般业务 = 上面这整套; 有特殊需求的按最小例外逐项开并记录
总结:容器安全的默认值是”root + 一把 capabilities”,要自己收紧:USER 降权 + cap_drop ALL 再按需加 + read_only + no-new-privileges;每次加权限都当成一次设计决策留痕;privileged 在生产没有合法席位。
追问1:no-new-privileges 挡什么? → 进程不能通过 setuid/setgid/capabilities 提权——即使镜像里带了 setuid root 的二进制也失效 追问2:seccomp 默认挡了哪些? → Docker 默认 profile 已屏蔽几十个高危 syscall(如 kexec_load);定制收紧用自定义 profile,配合审计先观察 追问3:非 root 后 volume 权限怎么处理? → 初始化容器(445 题 initContainer)chown 一次;或镜像内入口脚本提权自愈(需要 CAP_CHOWN,不如前者干净)
二、K8s 核心对象(415–434)
415. K8s 心智模型:控制平面、节点与声明式 API?
概念 控制平面(大脑):API Server(唯一入口,etcd 读写)、etcd(集群状态库)、Scheduler(决定 Pod 去哪个节点)、Controller Manager( reconcile 循环:实际状态向声明状态收敛)。节点(手脚):kubelet(节点代理,照 spec 起容器)、kube-proxy(Service 流量规则)、容器运行时。声明式 API:你提交”期望”(YAML),控制器持续对比期望与实际并修正——这是 K8s 一切自愈能力的来源。
典型场景 概念总览题;理解”为什么删了 Pod 它又自己起来”;排障时知道该看哪个组件的日志。
解决方案 三步:reconcile 循环演示 → 组件协作一次扩容全程 → 声明式 vs 命令式。
第一步:reconcile 循环——自愈的本质
# 文件: reconcile.txt
你声明: Deployment replicas=3(期望状态写入 etcd)
Controller 持续循环:
观察: 实际运行几个副本? → 2 个(有人手滑删了一个 Pod)
对比: 期望 3 ≠ 实际 2
修正: 创建 1 个新 Pod(Scheduler 选节点, kubelet 起容器)
下一轮: 3 == 3, 无事发生
推论:
1) "删 Pod"从来不是运维动作 —— 改副本数/删 Deployment 才是
2) 控制面挂了 ≠ 业务挂(存量 Pod 继续跑), 但失去自愈与调度能力
3) 所有 kubectl 命令本质都是"改 etcd 里的期望", 动作由控制器异步完成
第二步:一次扩容的组件协作全程
# 文件: scale-flow.sh
kubectl scale deployment api --replicas=5
# 全链路:
# 1) kubectl → API Server(认证/鉴权/准入) → etcd 写入 replicas=5
# 2) Deployment Controller 发现偏差 → 创建 2 个 Pod 对象(状态 Pending)
# 3) Scheduler 监听 Pending Pod → 打分选节点(过滤: 资源够/亲和满足; 优先: 均衡) → 绑定节点名
# 4) 目标节点 kubelet 监听到"分给我的 Pod" → 拉镜像 → 起容器 → 上报状态 Running
# 5) readiness 探针通过 → Endpoints 加入该 Pod → Service 开始转发流量(424 题衔接)
# 排障定位: 卡在 Pending → Scheduler 事件; 卡在 ContainerCreating → kubelet/镜像拉取; 起了又挂 → 应用本身
第三步:声明式 vs 命令式
# 文件: api-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata: { name: api }
spec:
replicas: 3
selector: { matchLabels: { app: api } }
template:
metadata: { labels: { app: api } }
spec:
containers:
- name: api
image: harbor.corp.local/team/api:1.0.0
resources:
requests: { cpu: 200m, memory: 256Mi }
readinessProbe: { httpGet: { path: /health/ready, port: 3000 } }
# 命令式(ssh 上去 docker run)的问题: 状态不可审计、不可回滚、无自愈
# 声明式的纪律: YAML 进 git(464 题 GitOps), 集群只是 YAML 的投影
总结:K8s = etcd 存期望 + 控制器收敛实际 + kubelet 执行;理解 reconcile 就理解了自愈、滚动更新、HPA 的共同底座;排障按组件分工定位:kubectl describe 的 Events 就是控制器们的协作日志。
追问1:控制面组件可以跑在容器里吗? → 可以且常态:kubeadm 把控制面本身跑成静态 Pod——“K8s 管自己” 追问2:etcd 挂了会怎样? → 无法读写期望(不能部署/扩缩),存量业务继续跑;etcd 是备份重点(460 题) 追问3:为什么 kubectl apply 是”声明”而 kubectl scale 是”命令”? → scale 直接改字段也是改声明;真正的命令式是 kubectl run —restart=Never 这类一次性对象——边界在于”是否留下可 reconcile 的期望”
416. Pod:为什么最小调度单元是 Pod 而不是容器?
概念 Pod 是一组共享网络与存储上下文的容器:同 Pod 容器共享网络 namespace(同一 IP、localhost 互通)、可共享 volume、生命周期绑定。设计动机:支持”主容器 + 辅助容器”紧密协作(sidecar 模式,431 题)。调度、扩缩、删除的最小单位都是 Pod——容器只是 Pod 里的进程组。
典型场景 概念题;判断什么该放同 Pod(Nginx+Node?代理+应用?);localhost 互通的妙用与坑。
解决方案 三步:共享语义验证 → 同 Pod 判据 → 多容器的典型拓扑。
第一步:共享语义验证
# 文件: pod-share.sh
kubectl run web --image=nginx:1.25
kubectl exec web -- hostname # Pod 级主机名(所有容器相同)
# 两个容器同 Pod:
# 容器A curl http://localhost:8080 → 打到容器B 的 8080(共享 netns)
# 挂同一个 emptyDir → 两容器见同一目录(405 题 volume 的 Pod 版)
# ⚠️ 共享不共享 PID namespace: 默认不共享(各自容器独立 PID 1);
# shareProcessNamespace: true 才互相可见进程(408 题提过副作用)
第二步:同 Pod 判据
# 文件: same-pod.txt
放同 Pod 的判据: 必须同生共死 + 本地级耦合
✅ 主应用 + 日志采集 sidecar(采集器随应用生死)
✅ 主应用 + 本地代理(Envoy sidecar, 流量先过代理)
✅ 应用 + 适配器(转换输出格式)
❌ Node API + PostgreSQL: 生命周期不同(DB 不该随应用滚动重启)、资源画像不同
→ 各自成 Deployment/StatefulSet, Service 通信
❌ 前台 + 管理后台: 无耦合收益, 只带来部署绑定
一句话: 同 Pod = 一个"逻辑主机"; 两个"独立服务"永远别塞进一个 Pod
第三步:多容器典型拓扑
# 文件: pod-multi.yaml
apiVersion: v1
kind: Pod
metadata: { name: api-with-sidecar }
spec:
containers:
- name: api
image: harbor.corp.local/team/api:1.0.0
volumeMounts: [{ name: logs, mountPath: /var/log/app }]
- name: log-shipper
image: fluent-bit:2.2
volumeMounts: [{ name: logs, mountPath: /logs, readOnly: true }]
resources: { requests: { cpu: 50m, memory: 64Mi } }
volumes:
- name: logs
emptyDir: {} # 生命周期 = Pod: 两者共享的暂存区
# 原生 sidecar(initContainers + restartPolicy: Always, 1.28+)让辅助容器先起后止 —— 431 题
总结:Pod = 共享网络/存储/命运的容器组,是调度与伸缩的原子;同 Pod 的唯一理由是”同生共死的本地耦合”;两个独立服务塞一个 Pod 是把 Pod 当虚拟机用的经典错误。
追问1:一个 Pod 里容器数有上限吗? → 默认 ephemeral containers 等约束下建议 ≤3~4;容器越多,启停顺序与资源耦合越难管 追问2:Pod 的 IP 会变吗? → 会:重建即换 IP——所以服务间寻址永远走 Service/DNS(419/430 题),别硬编码 Pod IP 追问3:sidecar 挂了主容器还在,Pod 算挂吗? → 算重启:容器按各自 restartPolicy 重启;原生 sidecar 特性解决了”收尾顺序”问题(431 题)
417. Pod 生命周期与重启策略:从 Pending 到 Terminating 发生了什么?
概念 Pod 阶段:Pending(调度/拉镜像)→ Running(至少一个容器在跑)→ Succeeded/Failed(终态,Job 类)或反复重启;容器级状态:Waiting(ContainerCreating/拉镜像)、Running、Terminated(含 exit code 与原因)。重启策略:Always(默认,Deployment 强制)、OnFailure(Job)、Never。删除流程:先 Endpoint 摘除 → 宽限期内发 SIGTERM → 超时 SIGKILL。
典型场景 面试概念题;Pod 卡 Pending/ImagePullBackOff 排查;优雅停机时长与 terminationGracePeriodSeconds 配不对导致断流。
解决方案 三步:状态机全景 → 排障对照表 → 删除与优雅停机。
第一步:状态机全景
# 文件: pod-states.sh
kubectl get pod api-7d9c6b5f-x2kqp -o wide
# NAME READY STATUS RESTARTS AGE
# api 0/1 Pending 0 2m → 调度不出去(资源不足/亲和冲突, describe 看 Events)
# api 0/1 ContainerCreating 0 30s → 拉镜像/挂卷中(慢 = 镜像大或网络)
# api 0/1 CrashLoopBackOff 5 10m → 起了就崩被退避重启(455 题专讲)
# api 1/1 Running 0 5m → 就绪探针也过了
kubectl get pod api-xxx -o jsonpath='{.status.containerStatuses[0].state}'
# Waiting/Running/Terminated 三态与原因细节都在这里(exitCode/reason/message)
第二步:排障对照表
# 文件: pending-causes.txt
Pending 常见原因(describe 的 Events 一锤定音):
Insufficient cpu/memory → 资源不够: 降 request 或扩节点(448 题碎片问题)
node(s) had untolerated taint → 污点挡了(438 题)
didn't match Pod anti-affinity → 反亲和把自己锁死(437 题)
no nodes available → 节点池真的没了
ImagePullBackOff:
镜像名/标签错、没 imagePullSecrets(411 题)、registry 限流
Evicted:
节点压力驱逐(440 题): 内存/磁盘超阈值, 抢救低优先级 Pod
第三步:删除与优雅停机
# 文件: graceful.yaml
spec:
terminationGracePeriodSeconds: 30 # SIGTERM 后最多等 30s 再 SIGKILL
containers:
- name: api
lifecycle:
preStop:
exec: { command: ["sleep", "5"] } # 先等 LB/Endpoint 传播摘流, 再收 SIGTERM(249 题同款)
# 删除序: 1) Pod 标记 Terminating 2) Endpoint 控制器摘除(有传播延迟 —— preStop sleep 就是补这个洞)
# 3) kubelet 发 SIGTERM(应用做收尾, 239 题) 4) 宽限期到 → SIGKILL
# 时长设计: preStop + 应用收尾 < terminationGracePeriodSeconds, 且 > Endpoint 传播时长(实测 2~5s)
总结:Pod 状态机的每个停留点都对应一个责任组件:Pending 归 Scheduler、Creating 归 kubelet/registry、CrashLoop 归应用;删除不是瞬时的——preStop 与宽限期组成优雅停机的完整时间预算。
追问1:RESTARTS 很高但服务”看起来正常”? → OOMKill 循环或周期性崩溃重启被探针掩盖:看 restartCount 增速与 lastState(456 题) 追问2:Pod 会被”移动”到别的节点吗? → 不会:Pod 与节点绑定,只能删了重建(调度新 Pod);节点排空就是批量”删了重排”(461 题) 追问3:Job 的 Pod 重启策略为什么是 OnFailure? → 失败重跑是任务语义;Always 会变成”永远在跑”,Job 控制器会拒绝
418. Deployment:滚动更新与回滚怎么发生?
概念 Deployment 管 ReplicaSet,ReplicaSet 管 Pod 副本数;滚动更新 = 新 ReplicaSet 逐步扩、旧 ReplicaSet 逐步缩(maxSurge/maxUnavailable 控节奏),默认保留旧 RS(副本 0)用于回滚。镜像变更触发更新,其他字段变更视对象而定。回滚 = 把旧 RS 再扩回来(秒级,不重建镜像)。
典型场景 发版期间 5xx 尖刺(没有就绪门禁);回滚靠”再发一版”(应该 rollout undo);更新卡住(新 Pod 起不来,旧的缩不掉)。
解决方案 三步:滚动参数实操 → 就绪门禁(错误率不尖刺的关键)→ 回滚与诊断。
第一步:滚动参数
# 文件: deploy-roll.yaml
apiVersion: apps/v1
kind: Deployment
metadata: { name: api }
spec:
replicas: 6
strategy:
type: RollingUpdate
rollingUpdate:
maxSurge: 1 # 最多多起 1 个(7 个在跑): 有余量时用, 保容量
maxUnavailable: 0 # 最多少 0 个: 零容量损失, 配合 Surge 慢滚
selector: { matchLabels: { app: api } }
template:
metadata: { labels: { app: api } }
spec:
containers:
- name: api
image: harbor.corp.local/team/api:1.0.0
readinessProbe: { httpGet: { path: /health/ready, port: 3000 }, initialDelaySeconds: 3 }
# 对照: maxUnavailable: 2, maxSurge: 0 → 快但容量 dips(内部服务可接受);
# 0/1 组合 = 最稳最慢(对外 API 默认)—— 与 249 题压测验证的同一套思想
第二步:就绪门禁——没过探针就不进负载均衡
# 文件: rollout-watch.sh
kubectl set image deployment/api api=harbor.corp.local/team/api:1.1.0
kubectl rollout status deployment/api # 实时看: "waiting for rollout to finish: 3 of 6 updated"
# 卡住时的形态: 新 Pod 一直 NotReady(就绪探针不过) → 旧 RS 不缩 → 服务不变(这就是门禁价值)
kubectl rollout status --timeout=120s deployment/api || echo "卡住, 看新 Pod 日志"
# ⚠️ 只有 readiness 门禁还不够: 就绪 ≠ 无错误 —— 生产要叠金丝雀(467 题)看错误率再放量
第三步:回滚与诊断
# 文件: rollback.sh
kubectl rollout history deployment/api # 历史 revision(默认留 10 个旧 RS)
kubectl rollout history deployment/api --revision=3
kubectl rollout undo deployment/api # 回到上一版: 旧 RS 扩回来, 秒级
kubectl rollout undo deployment/api --to-revision=2
kubectl rollout restart deployment/api # 不换镜像的重启(配置/证书轮换场景)
# 诊断: describe deployment 看 Events;新 RS 的 Pod describe 看起不来的原因
# 回滚 ≠ 万能: 涉及 DB 迁移的版本, 回滚代码不回滚 schema —— 迁移要向后兼容设计(472 题)
总结:Deployment 的滚动 = 新旧 RS 的扩缩接力,maxSurge/maxUnavailable 定节奏;就绪探针是容量门禁,金丝雀是质量门禁;回滚是扩旧 RS,快但挡不住不兼容变更——发布设计里”可回滚”是硬指标。
追问1:改了 configMap 为什么 Pod 没重启? → ConfigMap 变更不触发滚动(除非以 envFrom 引用且 checksum 注解技巧)——464 题讲 GitOps 的联动方案 追问2:revisionHistoryLimit 设 0 的后果? → 旧 RS 被删,rollout undo 无路可回;省那点元数据不值得 追问3:滚动时 Service 怎么知道摘谁? → Endpoints 控制器按 Pod 就绪条件增删,preStop 补传播窗口(417 题)
419. Service:四种类型与流量到底怎么到 Pod?
概念 Service 是稳定的虚拟 IP(VIP)+ 负载均衡规则,把流量分发到”符合 selector 且就绪”的 Pod 集合。四类:ClusterIP(集群内互访,默认)、NodePort(每节点开端口)、LoadBalancer(云 LB 接入)、ExternalName(DNS 别名)。数据面由 kube-proxy(iptables/IPVS 规则)实现:VIP 是 iptables 规则的锚点,不是网卡。
典型场景 集群内服务互访怎么做;把服务暴露给外部;Service 存在但连不通的排查思路。
解决方案 三步:ClusterIP 与 Endpoints → 对外暴露的三段姿势 → kube-proxy 与会话保持。
第一步:ClusterIP 与 Endpoints
# 文件: svc.yaml
apiVersion: v1
kind: Service
metadata: { name: api }
spec:
selector: { app: api } # 圈选 Pod 的方式(433 题 label 语义)
ports: [{ port: 80, targetPort: 3000 }] # Service 端口 80 → 容器端口 3000
# ClusterIP 是 VIP: 没有进程监听它, 由 kube-proxy 的规则转给 Pod
---
# Endpoints(自动生成): 就绪 Pod 的实际 IP 列表
# kubectl get endpoints api → 10.244.1.13:3000, 10.244.2.7:3000, ...
# ⚠️ Pod 不就绪会被摘出 Endpoints —— Service 的负载均衡天然带健康门禁(424 题探针联动)
第二步:对外暴露三段式
# 文件: expose.txt
集群内互访: ClusterIP + DNS(api.default.svc.cluster.local, 430 题)
↓ 需要外部访问时, 依次考虑:
1) Ingress(420 题): 七层路由, 一个入口按 host/path 分发 —— 首选
2) NodePort: 每节点开 30000-32767 端口, 客户端连任一节点:端口
→ 测试/内网临时用; 生产直连的问题: 节点列表变更客户端无感知
3) LoadBalancer: 云厂商 LB 挂到 Service(底层还是 NodePort)
→ 四层直通(TCP/UDP)或云 LB 成本可接受时用; 每个 LB 都计费, 别一个服务一个
ExternalName: 返回 CNAME(如 my-db → rds.xxx.aliyuncs.com)—— 集群内引用外部资源的"别名层"
headless(clusterIP: None): 不分配 VIP, DNS 直接返回 Pod IP 列表 —— StatefulSet 标配(427 题)
第三步:kube-proxy 与会话保持
# 文件: kube-proxy.sh
# iptables 模式: 每个 Service 一组规则, 随机(按概率权重)分发 —— O(n) 规则链, 服务多时更新慢
# IPVS 模式: 内核哈希表分发, 大集群(服务上千)首选
# 会话保持: 长连接场景(WebSocket/缓存节点亲和)
spec:
sessionAffinity: ClientIP # 同客户端 IP 固定打到一个 Pod
sessionAffinityConfig: { clientIP: { timeoutSeconds: 10800 } }
# ⚠️ sessionAffinity 是"尽量"不是保证(Pod 挂了自然换); 应用不该依赖它做状态(272 题连
# 接治理的思想: 无状态化 + 注册表, 而不是靠网络层粘滞)
总结:Service = selector 圈 Pod + VIP 分流,数据面是 kube-proxy 规则;对内 ClusterIP+DNS,对外优先 Ingress;就绪探针与 Endpoints 联动是”不发流量给坏 Pod”的机制核心。
追问1:Service 的 VIP ping 得通吗? → ping 不通(没有实际网络接口响应 ICMP),但 curl 通——经典的”理解 VIP 是规则不是实体”考题 追问2:Endpoints 与 EndpointSlice 的区别? → EndpointSlice 是分片版(大 Service 性能),新版本默认;排障时 kubectl get endpointslice 追问3:externalTrafficPolicy: Local 是干嘛的? → 流量只发给本节点 Pod,保留客户端源 IP(默认 Cluster 会 SNAT 丢源 IP);代价是跨节点负载不均
420. Ingress:七层路由怎么组织?
概念 Ingress 对象声明”host/path → Service”的路由规则;Ingress Controller(nginx-ingress/traefik/云厂商) watch 这些规则并配置自己的数据面(通常自身就是一个 Deployment+Service)。TLS 终止、重写、限流、灰度权重(部分注解)都在 controller 层。Ingress 是”声明”,真正干活的是 controller——不装 controller,Ingress 对象只是摆设。
典型场景 一个入口暴露多个服务;HTTPS 证书管理;按 header 做金丝雀分流;路径重写。
解决方案 三步:基础路由与 TLS → 常用注解 → 与云 LB 的关系。
第一步:基础路由与 TLS
# 文件: ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: app-ingress
annotations:
nginx.ingress.kubernetes.io/ssl-redirect: "true"
spec:
ingressClassName: nginx # 指定 controller(可多套共存: 内部/外部)
tls:
- hosts: [app.corp.local]
secretName: app-tls # 证书存 Secret(422 题), cert-manager 自动轮换
rules:
- host: app.corp.local
http:
paths:
- path: /api
pathType: Prefix
backend: { service: { name: api, port: { number: 80 } } }
- path: /
pathType: Prefix
backend: { service: { name: web, port: { number: 80 } } }
# 流量路径: 客户端 → controller 的 Service(LoadBalancer) → controller Pod → 按 rule 转发到 api/web Service
# ⚠️ pathType: Prefix 与 ImplementationSpecific 的语义差: 精确匹配行为别想当然, 测试覆盖
第二步:常用注解工具箱
# 文件: ingress-anno.yaml
metadata:
annotations:
# 灰度: cookie/header 分流(nginx controller 特性, 467 题金丝雀的低配版)
nginx.ingress.kubernetes.io/canary: "true"
nginx.ingress.kubernetes.io/canary-header: "x-canary"
nginx.ingress.kubernetes.io/canary-weight: "10"
# 重写与超时(469 题长连接注意: WS 要加长)
nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
nginx.ingress.kubernetes.io/rewrite-target: /$2
# 限流入门(正经限流在应用层 245 题)
nginx.ingress.kubernetes.io/limit-rps: "100"
# 注解是 controller 方言: 换 controller(nginx→traefik)注解全部重写 —— 路由收敛在 values 层(465 题)
第三步:与云 LB 的分层
# 文件: ingress-lb.txt
典型分层(公网入口):
云 LB(四层, LoadBalancer Service) → ingress-controller(DaemonSet/Deployment, 428 题)
→ Ingress 规则(七层) → 各业务 Service → Pod
排障顺序(457 题决策树同源):
1) LB 到 controller 通不通(云控制台健康检查)
2) controller 到 Service(看 controller Pod 日志的 upstream 错误)
3) Service 到 Pod(Endpoints 是否有 IP)
4) 证书/域名(DNS 解析、SNI)
替代演进: Gateway API(Ingress 的继任者, CRD 化、角色分离)—— 新项目可以直接上
总结:Ingress = 规则声明,controller = 执行者;入口分层(LB→controller→Service→Pod)是排障的地图;注解是 controller 方言,迁移成本要心里有数;证书交给 cert-manager,灰度注解只配低配场景。
追问1:多个 Ingress 对象冲突吗? → 同 host+path 会被判冲突(controller 行为:拒绝或随机);规范是每团队管自己的 host 前缀 追问2:Ingress 能做 TCP/UDP 吗? → 原生不能(七层 HTTP/HTTPS);TCP 要 controller 的专门配置块或 LoadBalancer Service直通 追问3:客户端真实 IP 怎么拿? → controller 已在七层,注入 X-Forwarded-For/X-Real-IP;应用侧要信这些头(controller 前不能有不可信代理)
421. ConfigMap:配置注入的三种方式与热更新边界?
概念 ConfigMap 存非敏感配置(键值/整文件),注入方式:环境变量(简单但不热更)、命令行参数、volume 挂载文件(子路径除外可热更,kubelet 周期同步)。热更新边界:env 方式改了不生效(要重启 Pod);volume 方式约 1 分钟内同步到文件,但应用是否重读是自己的事。
典型场景 改了 ConfigMap 服务没反应;配置想热加载;多环境配置差异管理。
解决方案 三步:三种注入对照 → 热更新的真实链路 → 配置变更触发热重载的模式。
第一步:三种注入对照
# 文件: cm-inject.yaml
apiVersion: v1
kind: ConfigMap
metadata: { name: api-config }
data:
LOG_LEVEL: "info"
app.yaml: |
featureX: true
pool: 20
---
# 方式1: 环境变量 —— 最简单, 改动需重启才生效
env:
- name: LOG_LEVEL
valueFrom: { configMapKeyRef: { name: api-config, key: LOG_LEVEL } }
# 方式2: 整文件挂载 —— kubelet 周期同步(热更新到文件系统)
volumes:
- name: config
configMap: { name: api-config }
containers:
volumeMounts: [{ name: config, mountPath: /etc/app }]
# 容器内 /etc/app/app.yaml 与 LOG_LEVEL 都在; app.yaml 更新约 1 分钟内到位(symlink 原子替换)
# 方式3: subPath 挂单文件 —— 不热更(subPath 的代价), 适合"就是要固定版本"的文件
# volumeMounts: [{ name: config, mountPath: /etc/app/app.yaml, subPath: app.yaml }]
第二步:热更新的真实链路
# 文件: hotupdate.txt
ConfigMap 变更 → kubelet 同步周期(默认 ~1min)→ 挂载点的文件替换(symlink 切换, 原子)
止步于此! 之后分三种情况:
1) 应用启动时读一次(env 式心态): 文件变了它不知道 → 看似热更实则没生效
2) 应用 watch 文件(chokidar/fs.watch): symlink 切换可能不触发 inotify —— 轮询 stat 更稳
3) 应用每次请求读: 天然热更(读配置的开销要缓存)
结论: "ConfigMap 热更新"是文件层的, 不是应用层的 —— 想要生效, 应用侧设计不能缺席
第三步:变更触发热重载的工程模式
# 文件: reload-pattern.yaml
# 模式A: reloader(第三方)监测 ConfigMap 变化 → 自动滚动相关 Deployment(简单粗暴, 全量重启)
# 模式B: checksum 注解 —— CI 计算配置哈希写进 Pod 注解, 配置变 → 模板变 → 滚动更新(464 题 GitOps 常用)
spec:
template:
metadata:
annotations:
config/checksum: "${sha256(configmap内容)}" # 配置一变, 滚动重启, 行为可预期
# 模式C: 应用层真热载(pino 的 level 可运行时改, 223 题同款)—— 按配置项分级: 多数配置用 B, 少数高频开关用 C
总结:ConfigMap 注入三式中只有整文件挂载支持热更,且只到文件层;配置生效策略要么“配置即模板变更”(checksum 滚动,可审计)要么“应用真热载”(少数开关);subPath 不热更是最常被踩的暗坑。
追问1:ConfigMap 有大小限制吗? → 1MB(etcd 限制);大配置拆分或改用对象存储挂载 追问2:envFrom 一次性导入所有键好吗? → 方便但失去显式性(不知道应用用了哪些键)且 key 冲突难查——关键配置显式声明 追问3:配置和密钥的边界? → “泄露会造成损失”就进 Secret/外部密钥系统(422/470 题);ConfigMap 当“公开信息”管理
422. Secret:base64 不是加密,密钥管理的正确姿势?
概念 Secret 与 ConfigMap 同机制,差异:独立对象类型、默认仅分发到目标节点内存、base64 编码(base64 是编码不是加密,etcd 里的内容等于明文)。真安全要:etcd 静态加密(KMS provider)、RBAC 限制读取、或根本不把密钥放集群——由 external-secrets 从 Vault 拉取(470 题)。
典型场景 审计发现 etcd 里明文密钥;Secret 被 CI 日志打出来;密钥轮换要滚动全部服务。
解决方案 三步:基础用法与类型 → etcd 加密与 RBAC → 向外托管(推荐路线)。
第一步:基础用法与内置类型
# 文件: secret.yaml
apiVersion: v1
kind: Secret
metadata: { name: db-cred }
type: Opaque
stringData: # stringData 写明文, 创建时自动 base64(比手编 data 舒服)
DATABASE_URL: postgres://app:s3cret@db:5432/app
# 内置类型: kubernetes.io/tls(证书)、dockerconfigjson(拉镜像凭据, 411 题 imagePullSecrets)、basic-auth
# 注入方式与 ConfigMap 相同(env 普通变量 / volume 文件)
第二步:安全基线
# 文件: secret-baseline.txt
1) etcd 静态加密: apiserver 配置 EncryptionConfiguration(aescbc/KMS provider)
→ 否则拿到 etcd 备份 = 拿到全部密钥(460 题备份的连带风险)
2) RBAC: secrets 的 get/list 只给需要的服务账号(442 题), 默认别让任何人能读所有 ns
3) 审计: audit log 记录谁读了哪个 Secret(451 题)
4) 不进 git: Secret 对象本身永不提交 —— 提交的是 ExternalSecret 声明(下一步)
5) base64 心智: 它只是"让二进制能进 YAML", 防君子不防小人
第三步:密钥外置(推荐路线)
# 文件: external-secret.yaml(external-secrets-operator)
apiVersion: external-secrets.io/v1beta1
kind: ExternalSecret
metadata: { name: db-cred }
spec:
refreshInterval: 1h # 轮换友好: 定期从源头刷新
secretStoreRef: { kind: ClusterSecretStore, name: vault-backend }
target: { name: db-cred } # 自动生成的原生 Secret(Pod 无感)
data:
- secretKey: DATABASE_URL
remoteRef: { key: secret/data/order-api, property: DATABASE_URL }
# 价值: 密钥真身在 Vault(283 题动态密钥), 集群里只有引用声明可进 git;
# 轮换在 Vault 侧完成, refreshInterval 自动跟进 —— 470 题细讲
总结:Secret 的默认形态是“名字叫 Secret 的 ConfigMap”;安全三件套:etcd 加密、RBAC 收紧、审计留痕;现代化路线是密钥根本不落集群——ExternalSecret 声明进 git,真身在 Vault,轮换自动跟进。
追问1:Secret 的 volume 挂载更新会热更吗? → 会(与 ConfigMap 同机制,约 1 分钟);轮换后应用重读文件即可——env 注入的才是死配置 追问2:镜像拉取凭据怎么配? → dockerconfigjson 类型 Secret + ServiceAccount 的 imagePullSecrets(或 namespace 级默认)——私有 Harbor 的标准配法(411 题) 追问3:同一 Secret 被 100 个 Deployment 引用,轮换怎么滚动? → 改 Secret 本身不触发滚动;用 checksum 注解或 reloader(421 题模式),别指望平台替你想
423. requests/limits 与 QoS 等级:资源声明背后的调度逻辑?
概念 requests 是调度承诺(Scheduler 按它找节点、节点可超卖)、limits 是运行硬顶(CPU 超限节流,内存超限 OOMKill)。QoS 由声明的齐整度决定:Guaranteed(每容器 cpu/mem 的 request==limit)、Burstable(有声明但不齐)、BestEffort(完全不声明)——节点内存吃紧时驱逐顺序 BestEffort → Burstable → Guaranteed。
典型场景 Pod 被 Evicted 想知道为什么是它;CPU limit 造成 P99 毛刺;节点超卖后内存挤压。
解决方案 三步:三级 QoS 行为对照 → CPU limit 的取舍 → 超卖与容量核算。
第一步:QoS 三级行为对照
# 文件: qos.yaml
# Guaranteed: 全部容器所有资源 request == limit
resources:
requests: { cpu: "1", memory: 512Mi }
limits: { cpu: "1", memory: 512Mi }
# Burstable: 声明了但不相等(常态)
resources:
requests: { cpu: 200m, memory: 256Mi }
limits: { cpu: "1", memory: 512Mi }
# BestEffort: 什么都不声明 —— 第一个被驱逐, 别用
# 查看归属: kubectl get pod -o jsonpath='{.status.qosClass}'
第二步:CPU limit 的取舍
# 文件: cpu-limit.txt
CPU 超限 = 节流(变慢不断命, 410 题机制); 内存超限 = OOMKill(直接死)
因此生产常见策略分两派:
A) 只设 request 不设 limit: 无节流, 尾延迟平滑; 代价是节点超卖时的互相挤压(依赖内存 limit 兜底)
B) request == limit(Guaranteed): 资源隔离最强, 适合延迟敏感型; 代价是利用率低(没有 burst 空间)
折中实践(多数在线服务):
memory: request == limit(内存没有"慢"只有死, 给足锁死)
cpu: request 按实测 P50, limit 给 2~4 倍或不给
验证手段: 压测看节流指标(container_cpu_cfs_throttled_periods, 453 题)与 P99 联动(286 题)
第三步:超卖与容量核算
# 文件: overcommit.txt
节点可超卖: Scheduler 按 requests 算, 实际用量可以超过(节点 CPU request 总和 > 100%)
超卖的红线在内存: 节点内存实际用量逼近上限 → 节点压力驱逐(440 题), 按 QoS+超限比例挑牺牲者
容量核算(286 题思想的节点版):
节点可容纳 Pod 数 = (节点容量 − 系统预留) ÷ 平均 request
超卖比 = Σrequests ÷ 节点容量: CPU 建议 ≤ 2~3x, 内存 ≤ 1.1x(内存超卖 = 驱逐定时炸弹)
观测: kubectl describe node 看 Allocated resources 一栏 —— 每个节点一张账本
总结:requests 定调度、limits 定上限、QoS 定牺牲顺序;内存 limit 给足锁死、CPU limit 按延迟敏感度取舍;超卖是挣来的利用率,红线是内存——驱逐顺序永远从声明最敷衍的 Pod 开始。
追问1:为什么内存不建议超卖? → 内存没有节流语义:超了就是 OOMKill 或节点驱逐;CPU 超卖只是排队,内存超卖是事故 追问2:改 requests 会触发什么? → Pod 重建(资源声明不可原地改)——与改镜像同级的变更,发布窗口内做 追问3:Guaranteed 一定最好吗? → 不是:牺牲弹性换隔离;内部无状态服务普遍 Burstable,延迟敏感/有状态组件才上 Guaranteed
424. 三种探针:liveness、readiness、startup 怎么配才不闯祸?
概念 liveness 失败 → 重启容器(治病:进程卡死);readiness 失败 → 摘出 Service(隔离:暂时不能服务);startup → 应用启动完成前暂停前两者(保护慢启动)。闯祸模式:把慢依赖检查塞进 liveness(依赖抖动引发重启风暴)、readiness 与优雅停机不配合、探针路径有副作用。
典型场景 数据库抖动导致全 Pod 重启雪崩;Java/模型加载慢的应用被 liveness 杀循环;滚动更新时流量打到未就绪 Pod。
解决方案 三步:三种探针分工 → 参数模板 → 反模式清单。
第一步:分工与一次故障的归因
# 文件: probe-roles.txt
liveness: "这个进程还活着吗?" —— 失败 = 重启(自愈手段, 慎重)
readiness: "现在能接流量吗?" —— 失败 = 摘流(弹性手段, 放心用)
startup: "启动完成了吗?" —— 成功前不跑上面两个(慢启动保护)
经典事故归因: liveness 里检查下游 DB → DB 抖 10s → 全部 Pod"不健康" → 全部重启
→ 重启期间更慢 → DB 恢复了但应用还在重启循环 —— 用 readiness 才对: 摘流等恢复, 进程不用死
判据: "重启能解决这个问题吗?" 能 → liveness; 不能(等外部恢复) → readiness
第二步:参数模板
# 文件: probes.yaml
containers:
- name: api
readinessProbe:
httpGet: { path: /health/ready, port: 3000 } # 检查"依赖就绪": DB ping/缓存连通
periodSeconds: 5
failureThreshold: 3 # 15s 不就绪才摘 —— 容忍瞬时抖动
livenessProbe:
httpGet: { path: /health/live, port: 3000 } # 只查进程自身(事件循环活着/内存没爆)
periodSeconds: 10
failureThreshold: 3
timeoutSeconds: 2
startupProbe:
httpGet: { path: /health/live, port: 3000 }
periodSeconds: 5
failureThreshold: 60 # 最多等 300s 启动(模型加载类, 490 题)
# 端点设计配合 244 题: /health/live 轻量(进程内自检), /health/ready 可查依赖
# 探针请求要免认证 + 无副作用(别触发写操作/别进埋点统计)
第三步:反模式清单
# 文件: probe-antipatterns.txt
1) liveness 检查外部依赖(DB/MQ/第三方) → 重启风暴放大器(见上)
2) readiness 无超时或超时太长 → 挂死的 Pod 迟迟摘不掉(period×threshold 就是摘除延迟)
3) 探针路径有副作用(写日志/发指标/消耗限流配额) → 健康检查自己打挂自己
4) 滚动更新没配 readiness → 新 Pod 一起来就接流量(418 题门禁失效)
5) startup 缺失 + 慢启动应用 + 激进 liveness → CrashLoop 的假象(455 题鉴别)
6) exec 探针里塞复杂脚本 → 探针本身的故障面; 能 httpGet 就别 exec
总结:三种探针是三种不同的”不健康”处置:重启(liveness)、摘流(readiness)、等待(startup);liveness 只看自己、readiness 才看依赖,是避免重启风暴的第一纪律;period×failureThreshold 就是变更生效延迟,配参数时心里要有这笔账。
追问1:探针失败期间 Pod 状态是什么? → readiness 失败:Running 但 Ready 0/1(摘流);liveness 失败累计到阈值:重启(RESTARTS+1) 追问2:TCP 探针什么时候用? → 只有端口活性可判时(无 HTTP 端点的中间件);它证明不了”应用真的能服务”,HTTP 优先 追问3:优雅停机时探针怎么配合? → 收 SIGTERM 后应主动 fail readiness(立刻摘流)再收尾(239 题);preStop sleep 补 Endpoint 传播(417 题)
425. kubectl 排障工具箱:从”进不去容器”到”看清现场”的命令地图?
概念 排障命令按层次组织:对象层(describe/logs/events)、容器层(exec/debug/cp)、网络层(port-forward/proxy)、集群层(top/node/drain)。核心心法:先看事件(控制器的叙事)再看日志(应用的叙事),最后才进容器——大部分问题在前两层就能定位。
典型场景 线上告警”服务 5xx”,给你一个 kubectl 从何下手;distroless 镜像 exec 不进;要临时连进集群内服务调试。
解决方案 三步:标准排障序列 → 进不去容器时的替代 → 网络调试姿势。
第一步:标准排障序列
# 文件: triage.sh
# 第 1 层: 对象叙事 —— 发生了什么(调度/拉镜像/探针/驱逐, 全在 Events)
kubectl get pods -o wide | grep -v Running # 先扫全局异常
kubectl describe pod api-7d9c6b5f-x2kqp # Events 一锤定音(417 题对照表)
kubectl get events --sort-by=.lastTimestamp -A | tail -20
# 第 2 层: 应用叙事 —— 为什么崩
kubectl logs api-7d9c6b5f-x2kqp --previous # ⚠️ 上一次崩溃的日志(排查 CrashLoop 必带)
kubectl logs -l app=api --all-containers --tail=100 -f
# 第 3 层: 资源叙事 —— 是不是被限制了
kubectl top pod --containers # 实际用量 vs requests/limits(423 题账本)
kubectl describe node node-3 | grep -A8 "Allocated resources"
第二步:进不去容器时的替代
# 文件: no-shell.sh
# distroless 镜像没有 sh —— 三个替代:
# 1) 临时容器(推荐): 把带工具的容器注入同一 Pod(netns/存储共享)
kubectl debug -it api-7d9c6b5f-x2kqp --image=busybox:1.36 --target=api
# 2) 节点诊断: 在节点上起 netns 全通的排查容器(458 题细讲)
kubectl debug node/node-3 -it --image=busybox:1.36
# 3) 复制 Pod 加 shell: 复制品不带流量, 可随意折腾
kubectl debug api-7d9c6b5f-x2kqp -it --image=busybox:1.36 --copy-to=api-debug --share-processes
第三步:网络调试姿势
# 文件: net-debug.sh
# 本地直连集群内服务(不走 Ingress):
kubectl port-forward svc/api 3000:80 # localhost:3000 → Service
# 完整 DNS/网络环境内的排查 —— 起一个一次性 debug Pod:
kubectl run netcheck --rm -it --image=nicolaka/netshoot -- bash
# 里面: curl api.default.svc.cluster.local(430 题 DNS)、dig、tcpdump(481 题)、ss
# 集群外访问 K8s API 本身(排查 RBAC, 442 题):
kubectl auth can-i get secrets --as=system:serviceaccount:default:api
# 退出前清理: port-forward 的端口占用、debug Pod 的 --rm 已自动清
总结:排障三层叙事:Events(控制器)、logs(应用,记得 —previous)、top(资源);进不去容器用 kubectl debug 家族而不是给镜像开后门;网络排查用一次性 netshoot Pod 保持主镜像干净。
追问1:logs 看不到任何输出? → 应用打了 stderr 吗、日志是不是进了文件而不是 stdout(450 题采集原则)、容器是不是刚重建(用 —previous) 追问2:describe 里 Events 是空的? → 事件有时效(默认 1h),老的被清理;结合 kubectl get events 补看 追问3:kubectl cp 和 exec tar 的关系? → cp 底层就是 exec tar 流;目标容器没有 tar 二进制(distroless)时 cp 也会失败——又是 debug 容器的场景
426. Job 与 CronJob:批处理任务怎么跑才可靠?
概念 Job 跑到成功为止:completions(要几个成功)、parallelism(并行度)、backoffLimit(失败重试上限,超限标 Failed);CronJob 按 cron 调度创建 Job(时区默认 UTC、concurrencyPolicy 管重叠、startingDeadlineSeconds 管错过)。与 277 题 BullMQ 的分工:K8s Job 管”算力型任务”(训练/批处理),队列管”业务任务”(延迟/重试/优先级)。
典型场景 每晚全量重建索引;批量 embedding 生成;CronJob 没跑/跑了两次;任务卡住永不结束。
解决方案 三步:Job 模式(并行/队列)→ CronJob 的坑 → 可靠性细节。
第一步:Job 的三种模式
# 文件: job-parallel.yaml
apiVersion: batch/v1
kind: Job
metadata: { name: embed-batch }
spec:
completions: 50 # 总共 50 个成功(每项处理一条/一批)
parallelism: 5 # 同时 5 个 Pod
backoffLimit: 4 # 容忍失败重试
activeDeadlineSeconds: 3600 # ⚠️ 兜底: 1h 强制结束 —— 防"卡住永不死"吞占资源
template:
spec:
restartPolicy: OnFailure
containers:
- name: worker
image: harbor.corp.local/team/embed-worker:1.0.0
# 三种模式:
# 项数已知 → completions+parallelism(如上)
# 工作量未知但想固定并发 → completions 省略 + parallelism N(队列消费型, worker 自己拉任务)
# 单 Pod 内部多进程 → parallelism 1 + 应用自己并发
第二步:CronJob 的坑清单
# 文件: cronjob.yaml
apiVersion: batch/v1
kind: CronJob
metadata: { name: reindex-nightly }
spec:
schedule: "0 19 * * *" # ⚠️ 默认 UTC: 北京时间凌晨 3 点 = UTC 19 点(错 8 小时的经典)
timeZone: "Asia/Shanghai" # 1.27+ 直接指定时区, 别再心算
concurrencyPolicy: Forbid # 上次没跑完不重叠(Allow/Replace/Forbid)
startingDeadlineSeconds: 300 # 错过 5 分钟以上就不补(控制器停机场景)
successfulJobsHistoryLimit: 3 # 留 3 条成功历史(排障), 太少丢现场
failedJobsHistoryLimit: 3
jobTemplate:
spec:
backoffLimit: 2
activeDeadlineSeconds: 7200
template:
spec:
restartPolicy: OnFailure
containers:
- name: reindex
image: harbor.corp.local/team/reindex:1.0.0
第三步:可靠性细节
# 文件: job-reliability.txt
1) 幂等先行: Job 至少一次执行, 重试会重跑 —— 任务逻辑可重入(277 题三板斧同源)
2) 进度可见: 任务写业务台账(完成数/失败数指标), 别只看 Pod 状态(277 题台账思想)
3) 长任务加 checkpoint: 训练类任务存断点, 重试从断点续(492 题)
4) 悬挂检测: activeDeadlineSeconds + 业务侧超时告警双保险
5) 分布式锁的边界: 同一任务多集群/多 CronJob 触发时用锁互斥(238 题), 但优先靠平台去重
6) 大量小任务别打爆 API: 用 Indexed Job(完成索引)或队列聚合成批 —— etcd 对象数是有限资源
总结:Job = 补数到成功的批处理声明:completions/parallelism/backoffLimit 三件套 + activeDeadline 兜底;CronJob 三坑:时区、重叠策略、历史保留;可靠性靠幂等 + 台账 + 断点,与业务队列分工明确。
追问1:Job 的 Pod 卡 Running 不结束怎么办? → 看 activeDeadlineSeconds 是否没配;应用是否在等一个永不来的消息;加进度指标暴露卡点 追问2:CronJob 和 BullMQ repeat 怎么选? → 需要算力隔离/独立镜像/独立伸缩 → K8s CronJob;轻量业务定时 → 队列 repeat(277 题) 追问3:suspend 字段有什么用? → Job/CronJob 的暂停开关:故障时一键挂起任务不删(保留现场与配额)
427. StatefulSet:有状态应用的正确打开方式?
概念 StatefulSet 给 Pod 稳定身份:序号名(db-0/db-1)、每 Pod 专属 PVC(模板自动创建,Pod 重建重新绑回原卷)、有序启停(默认)、稳定 DNS(headless service:db-0.db.ns.cluster.local)。适用:主从复制型系统(Kafka/PG/ES/Cassandra)。反直觉:扩容是有序的、缩容从大到小、更新策略可分片(灰度)。
典型场景 数据库/消息队列上 K8s;Pod 重建后数据还在的机制;主从角色怎么约定。
解决方案 三步:身份三件套验证 → 主从拓扑模式 → 更新与运维。
第一步:身份三件套
# 文件: sts.yaml
apiVersion: apps/v1
kind: StatefulSet
metadata: { name: pg }
spec:
serviceName: pg # headless service: DNS 直达每个 Pod
replicas: 3
selector: { matchLabels: { app: pg } }
template:
metadata: { labels: { app: pg } }
spec:
containers:
- name: pg
image: postgres:16
volumeMounts: [{ name: data, mountPath: /var/lib/postgresql/data }]
volumeClaimTemplates: # 每 Pod 一个专属 PVC: pg-data-pg-0/1/2
- metadata: { name: data }
spec:
accessModes: [ReadWriteOnce]
storageClassName: fast-ssd
resources: { requests: { storage: 100Gi } }
# 稳定 DNS: pg-0.pg.default.svc.cluster.local —— 从库配置写主库地址用它, IP 变化无感
# 重建行为: pg-0 挂 → 新 pg-0 绑回 pg-data-pg-0 卷 → 数据回来(身份与存储的双稳定)
第二步:主从拓扑模式
# 文件: sts-topology.txt
角色约定: 序号即角色(pg-0 恒主, pg-1/2 恒从)——简单但主挂了要人工/-operator 提升
生产姿势: 数据库类用 operator(Patroni/CloudNativePG/Zookeeper 的 K8s 官方 chart)
operator = StatefulSet 之上的"领域专家控制器": 自动故障转移、备份、版本升级
自研有状态服务 checklist:
1) 启动时按序号发现同伴(DNS 或 API 查状态)
2) 数据目录只认自己的 PVC, 不写本地路径
3) 重新选举的脑裂防护(租约/多数派, 238 题同源)
第三步:更新与运维
# 文件: sts-update.yaml
spec:
podManagementPolicy: Parallel # 启停并行(不需要严格顺序时提速; 默认 OrderedReady)
updateStrategy:
type: RollingUpdate
rollingUpdate:
partition: 1 # 只更新序号 >= 1 的 Pod: 灰度从库
# maxUnavailable: 1 # 1.25+ 也可用数量控制
# 运维要点:
# 扩容前确认: 新副本能否自动加入集群(复制槽/分区再平衡)
# 缩容: 从最大序号开始缩 —— 先把该节点数据迁走再缩, 直接缩 = 丢副本
# PVC 不随 StatefulSet 删除: 删了 STS 卷还在(防误删设计), 清理要显式删 PVC
总结:StatefulSet 的价值 = 稳定身份(名/DNS/卷):重建不换存储、拓扑可自描述;数据库生产化的路径是 operator 而不是裸 STS;更新用 partition 从库灰度,缩容先迁数据。
追问1:Deployment + PVC 行不行? → 不行:Deployment 的 Pod 无稳定身份,N 个 Pod 抢一个 RWO 卷或各拿各的随机卷——有状态身份是 STS 存在的理由 追问2:headless Service 和普通 Service 的 DNS 差别? → 普通:解析到 VIP;kube-proxy 分发;headless:解析到全部 Pod IP(可逐个寻址)——STS 专属寻址靠它 追问3:StatefulSet 的 Pod 起不来会阻塞后续吗? → OrderedReady 模式会(序号小的 NotReady 卡住全员)——排障时看是哪个序号卡住,或改 Parallel
428. DaemonSet:节点级组件怎么部署?
概念 DaemonSet 保证”每个(符合条件的)节点跑一个 Pod”:新节点加入自动起、节点移除自动清。典型载荷:日志采集(Filebeat)、监控代理(node-exporter)、网络插件(CNI 本体)、存储插件、Ingress controller(配合 hostNetwork/NodePort)。调度上类似 nodeSelector 全选,可与污点配合选择节点子集。
典型场景 日志/监控覆盖所有节点;只想让 GPU 节点跑某组件;DaemonSet 更新策略(节点逐个滚)。
解决方案 三步:基础与节点选择 → 与 kubelet 抢资源的约束 → 更新策略。
第一步:基础与节点选择
# 文件: ds.yaml
apiVersion: apps/v1
kind: DaemonSet
metadata: { name: log-collector }
spec:
selector: { matchLabels: { app: filebeat } }
template:
metadata: { labels: { app: filebeat } }
spec:
nodeSelector: { node-type: standard } # 只在标准节点跑
# GPU 节点专属组件: nodeSelector: { nvidia.com/gpu.present: "true" } 或容忍 GPU 污点(486 题)
containers:
- name: filebeat
image: docker.elastic.co/beats/filebeat:8.12
resources:
requests: { cpu: 100m, memory: 128Mi }
limits: { cpu: 500m, memory: 512Mi }
volumeMounts:
- { name: varlog, mountPath: /var/log }
- { name: dockerlogs, mountPath: /var/lib/docker/containers, readOnly: true }
volumes:
- { name: varlog, hostPath: { path: /var/log } }
- { name: dockerlogs, hostPath: { path: /var/lib/docker/containers } }
第二步:资源与优先级的约束
# 文件: ds-constraints.txt
DaemonSet 与节点上所有业务抢资源 —— 三条纪律:
1) requests 要小而真实(日志采集 100m 级), 让节点超卖账本不歪
2) 关键节点组件(日志/监控)给高优先级(441 题): 节点挤压时业务先走, 观测后走 = 瞎
3) hostPath 挂载只读优先;容器要的权限按 414 题基线收紧
系统组件的对照: kube-proxy/CNI 本身就是 DaemonSet —— kubectl get ds -n kube-system 看原生样板
第三步:更新策略
# 文件: ds-update.yaml
spec:
updateStrategy:
type: RollingUpdate
rollingUpdate:
maxUnavailable: 1 # 一次只滚一个节点(节点数小的话)
# maxSurge: 1 # 1.22+: 先起新再停旧(节点上短暂两个, 抢资源的代价换零中断)
# 滚动语义: 按节点逐个替换该节点上的 Pod
# ⚠️ 日志/监控类更新会造成采集短暂空窗 —— 低调发布 + 关注 452 题的 self-monitoring
总结:DaemonSet = 节点维度的”每机一个”:新节点自动覆盖、节点选择靠 selector/污点;资源要克制、优先级要高(观测组件);更新逐节点走,接受采集空窗。
追问1:DaemonSet 的 Pod 被驱逐怎么办? → 非自愿驱逐(节点压力)后 DaemonSet 控制器会在节点恢复后重建;PDB 不适用于 DS(它本来就要尽量在场) 追问2:怎么让 DaemonSet 不跑在控制面节点? → 控制面节点默认带污点,DS 不容忍就不去;要去就加对应 toleration(438 题) 追问3:hostNetwork 什么时候用? → 组件要直接用节点网络(CNI/ingress controller 常见):hostNetwork: true + dnsPolicy: ClusterFirstWithHostNet——代价是端口与节点共享
429. Pod 网络与 CNI:Pod 之间到底怎么互通的?
概念 K8s 网络模型四约定:每 Pod 一 IP、Pod 间无 NAT 直通、节点上的 Agent( kubelet)能用 Pod IP 访问 Pod、跨节点也直通。实现交给 CNI 插件:负责给 Pod 分 IP、建 veth、打通跨节点隧道(Flannel VXLAN/Calico BGP 或 overlay)。Service 的 VIP 则由 kube-proxy 在每节点配 iptables/IPVS 规则实现(419 题)——两套机制分层:CNI 管 Pod 直通,kube-proxy 管 Service 抽象。
典型场景 概念题;Pod 间不通的排查;网络插件选型;跨节点性能损耗。
解决方案 三步:单 Pod 网络栈 → 跨节点路径 → 排障与选型。
第一步:单 Pod 网络栈
# 文件: pod-net.sh
# CNI 在 Pod sandbox 创建时: 建 veth pair(一端在 Pod netns, 一端在节点) + 配 IP(从插件管理的网段分配)
kubectl exec api-xxx -- ip addr # eth0 @ 10.244.x.x(Pod IP)
# 节点侧: 该 veth 接到插件网桥/路由, Pod → 节点 → 外网走 NAT(masquerade)
# 同节点 Pod 互通: 经网桥二层直通; 跨节点看插件:
第二步:跨节点路径与损耗
# 文件: cni-paths.txt
Flannel VXLAN: 包封装进 UDP 隧道 —— 通用(任何云网络), 代价是 MTU 缩小 + 封装开销(~5-10%)
Calico BGP: 节点间路由直传 —— 高性能, 要求网络环境支持 BGP(自建机房/部分云)
Calico eBPF/VXLAN 混合等: 按环境取舍
MTU 陷阱: overlay 封装占字节, 集群 MTU 不匹配 → 大包静默丢(小请求通、大 payload 卡死的经典)
排查: ping -s 1400 / curl 大 body 对比
NetworkPolicy 由插件实现(Calico 支持; Flannel 原生不支持要加伴侣)—— 443 题前提是"CNI 支持"
第三步:排障与选型清单
# 文件: net-triage.sh
# Pod → Pod 不通的排查序(457 题决策树的底层版):
kubectl exec $A -- ping $B_IP # 1) 基础连通(ICMP 可能被禁, 用 tcp)
kubectl exec $A -- curl -m2 $B_IP:3000/health # 2) TCP 层
kubectl exec $A -- nslookup api.ns.svc.cluster.local # 3) DNS(430 题)与 Service(419 题)分层
# 全部用 netshoot 一次性容器做(425 题), 主镜像别塞工具
# 4) NetworkPolicy 是否挡了(443 题): kubectl get networkpolicy -A
# 5) 节点级: conntrack 表满、iptables 规则异常(kube-proxy 日志)
总结:K8s 网络模型 = Pod IP 直通 + Service 抽象两件事:CNI 管前者(overlay 或路由),kube-proxy 管后者;排障按层走:IP 直通 → DNS → Service → 策略;MTU 是 overlay 最阴的坑。
追问1:Pod 的 IP 从哪来? → CNI 插件管理的网段(每节点一段或集中分配);IPAM 是插件的一部分 追问2:为什么 Service 不让 CNI 一起做了? → 关注点分离:CNI 是数据面直通,Service 是集群级抽象(VIP/endpoints);有些 eBPF 方案(Cilium)确实在融合两层 追问3:双栈(IPv4+IPv6)要注意什么? → 插件与应用双支持才开;多数存量系统先单栈,新集群再评估
430. 集群 DNS 与服务发现:服务名是怎么变成 IP 的?
概念 集群内 DNS(CoreDNS)为每个 Service 生成记录:name.namespace.svc.cluster.local → VIP(headless → Pod IP 列表);Pod 的 resolv.conf 自动指向集群 DNS(ndots:5 的坑)。跨命名空间访问要带全名或短名解析顺序;ExternalName 做 CNAME;Pod 级 DNS 配置可调(dnsPolicy)。
典型场景 服务互访的地址写法;ndots 导致解析慢;同名 Service 不同命名空间串台;外部域名解析失败。
解决方案 三步:解析形态与实验 → ndots 坑 → CoreDNS 排障。
第一步:解析形态
# 文件: dns-forms.sh
kubectl run probe --rm -it --image=busybox:1.36 -- sh
nslookup api # 同命名空间: 补全成 api.<ns>.svc.cluster.local
nslookup api.prod # 跨命名空间短写
nslookup api.prod.svc.cluster.local # 全名 —— 跨 ns 访问的推荐写法(显式)
nslookup pg-0.pg.default.svc.cluster.local # headless: 返回 Pod IP(427 题)
# 外部域名(corp.com)走 CoreDNS 转发上游 —— 集群内外 DNS 的统一入口
第二步:ndots 坑
# 文件: ndots.txt
Pod 默认 resolv.conf: search 列表 + options ndots:5
后果: "api"(1 个点 < 5)会依次尝试 api.ns.svc... api.svc... api.cluster.local 才轮到绝对查询
→ 集群内短名: 1 次命中, 没问题
→ 外部域名 www.example.com(2 个点 < 5): 先撞 4 次集群内的无效查询再真解析
→ 高 QPS 外部调用时, CoreDNS 压力与首字延迟上升
缓解: dnsConfig: { options: [{ name: ndots, value: "2" }] } 或应用侧用 FQDN(尾部加点)
第三步:CoreDNS 排障
# 文件: coredns-triage.sh
kubectl -n kube-system get pods -l k8s-app=kube-dns # CoreDNS 本体健康
kubectl -n kube-system logs -l k8s-app=kube-dns --tail=50 | grep -i error
# 常见故障形态:
# 全部解析失败 → CoreDNS 挂/Service 不通(它自己也是 Service: kube-dns)
# 集群内正常外部失败 → 上游 forward 配置(云厂商内网 DNS/VPN 环境)
# 新 Service 解析不到 → Endpoint 尚未生成(就绪探针没过) —— DNS 没错, 是 424 题的问题
# 间歇性超时 → conntrack 竞态(旧内核 UDP 场景)或 CoreDNS 副本不足 —— 扩副本/开 TCP 查询
总结:服务发现的心智:Service 名 → CoreDNS → VIP(kube-proxy 接力);headless 直达 Pod IP;ndots:5 是外部域名慢的隐形税;DNS 排障先分清“DNS 本身、上游转发、还是 Endpoints 未就绪”。
追问1:Pod 里能改 /etc/resolv.conf 吗? → 能但不该:重建即失效应由 dnsPolicy/dnsConfig 声明式管理 追问2:dnsPolicy 有哪几种? → ClusterFirst(默认,集群 DNS 优先)/ClusterFirstWithHostNet(hostNetwork 时仍用集群 DNS)/Default(继承节点)/None(全自定义) 追问3:为什么有的团队给 CoreDNS 换 NodeLocal DNS? → DaemonSet 化的本地缓存:消除 conntrack 竞态与跨节点查询延迟——大集群 DNS P99 优化的标准动作
431. Init 容器与原生 Sidecar:启动顺序怎么编排?
概念 Init 容器:按序运行、全部成功主容器才启动(等待依赖/初始化数据/权限准备);原生 sidecar(1.28+ 正式):initContainers 里带 restartPolicy: Always 的容器——先于主容器启动、晚于主容器退出(生命周期覆盖),解决了老式 sidecar 的两大痛点(启动顺序不保证、Pod 终止时 sidecar 先死导致主容器日志丢失)。
典型场景 等 DB 可用再起应用;挂载初始化(改 volume 权限);代理/日志 sidecar 的启停顺序;Job 的准备阶段。
解决方案 三步:经典 init → 原生 sidecar 对照 → 组合模式。
第一步:经典 init——等待与准备
# 文件: init.yaml
spec:
initContainers:
- name: wait-db
image: busybox:1.36
command: ['sh', '-c', 'until nc -z pg 5432; do echo waiting; sleep 2; done']
# 等"端口通"(不是"业务就绪"); 等就绪要探 API:
# until wget -qO- http://api/health/ready; do sleep 2; done
- name: chown-data
image: busybox:1.36
command: ['chown', '-R', '1000:1000', '/data']
volumeMounts: [{ name: data, mountPath: /data }] # 414 题非 root 的初始化姿势
containers:
- name: api
image: harbor.corp.local/team/api:1.0.0
volumeMounts: [{ name: data, mountPath: /data }]
volumes: [{ name: data, persistentVolumeClaim: { claimName: api-data } }]
# init 失败 → Pod 重启 init(按 restartPolicy)→ 主容器永远不开始: 天然的启动门禁
第二步:原生 sidecar 对照
# 文件: native-sidecar.yaml
spec:
initContainers:
- name: log-shipper # 原生 sidecar: 带 restartPolicy: Always
image: fluent-bit:2.2
restartPolicy: Always # ← 这一行让它从"一次性"变"常驻"
volumeMounts: [{ name: logs, mountPath: /logs }]
containers:
- name: api
image: harbor.corp.local/team/api:1.0.0
volumeMounts: [{ name: logs, mountPath: /var/log/app }]
# 生命周期保证: log-shipper 先启动并就绪 → api 启动; api 退出 → shipper 收完尾部日志再退出
# 老式(普通容器当 sidecar)的坑: 启动竞态(应用先跑日志丢头)+ 终止顺序随机(日志丢尾)
第三步:组合模式
# 文件: init-sidecar-patterns.txt
经典分工:
init(一次性) = 等依赖、迁移准备、权限初始化、拉配置渲染
sidecar(常驻) = 日志采集、本地代理(envoy)、TLS 终止、本地缓存预热
设计纪律:
1) init 数量克制: 每个 init 是启动延迟与故障点; "等依赖"优先用应用内重试(239 题启动逻辑)
2) sidecar 资源单独声明: 别让主容器 limit 被 sidecar 挤(423 题账本)
3) 注入式 sidecar(istio 等)与手写 sidecar 冲突审计: 谁负责网络/日志要唯一
总结:init 管启动前(有序、一次性、门禁语义),原生 sidecar 管伴生(先起后止、生命周期覆盖);老式 sidecar 的顺序问题在 1.28 后有了正解;能用应用内重试解决的依赖等待,别堆 init。
追问1:init 容器失败会怎样? → 按 Pod 的 restartPolicy 重试;Always 策略下无限重试(配 activeDeadline 兜底)
追问2:怎么查看 init 容器日志? → kubectl logs
432. Namespace、ResourceQuota 与 LimitRange:多团队怎么共用一个集群?
概念 Namespace 是软隔离边界:名字作用域、RBAC 授权对象、配额(ResourceQuota)与默认值(LimitRange)的挂载点、网络策略的作用域。ResourceQuota 限总量(ns 内 CPU/内存/PVC/对象数上限),LimitRange 兜底每个 Pod 的默认 requests/limits(不声明的 Pod 按默认值算账)。注意:namespace 不是安全边界(网络默认全通),强隔离要 NetworkPolicy(443 题)+ RBAC(442 题)。
典型场景 多团队共享集群互相挤占;某团队忘了声明资源把节点账本打歪;按环境(dev/staging)或按团队划 ns 的争论。
解决方案 三步:划分模式 → 配额落地 → 常见坑。
第一步:划分模式
# 文件: ns-models.txt
按团队: platform / trade / ai —— 配额与成本核算对齐组织, 推荐
按环境: dev / staging / prod —— 小团队起步可用; 团队多了每个环境再按团队分(两层)
混合(常见终态): <team>-<env>(trade-prod, trade-dev), 环境间用节点选择/污点再分(438 题)
配套: 每个 ns 的 label(team=xxx)进成本分摊(453 题指标带 ns 标签, 天然成本账)
第二步:配额落地
# 文件: quota.yaml
apiVersion: v1
kind: ResourceQuota
metadata: { name: team-ai-quota, namespace: ai }
spec:
hard:
requests.cpu: "40" # 该 ns 所有 Pod 的 request 总和上限
requests.memory: 80Gi
limits.cpu: "80"
limits.memory: 160Gi
persistentvolumeclaims: "20"
pods: "100" # 防对象数失控(Job 滥用场景, 426 题)
---
apiVersion: v1
kind: LimitRange
metadata: { name: defaults, namespace: ai }
spec:
limits:
- type: Container
default: { cpu: 500m, memory: 512Mi } # 不声明 limits 时的默认
defaultRequest: { cpu: 100m, memory: 128Mi } # 不声明 requests 时的默认
max: { cpu: "4", memory: 8Gi } # 单容器上限
# 效果: 忘了声明的 Pod 也有账(LimitRange 补默认), 团队总量有顶(Quota 拒绝超额创建)
# Quota 触发的报错: create forbidden: exceeded quota —— 排障时第一个看的对象
第三步:常见坑
# 文件: ns-pitfalls.txt
1) ns 不隔离网络: 默认任何 ns 的 Pod 互通 —— 敏感库要 NetworkPolicy(443 题)
2) ns 不隔离节点: 低优先环境的 Pod 可能调度到生产节点 —— 用污点/亲和分池(438 题)
3) kube-system / default 别当垃圾桶: 业务都进自己的 ns, default 里的东西要审计
4) 对象名只在 ns 内唯一: Deployment 重名于别的 ns 没关系 —— 但监控/告警按 ns 维度要配好 label
5) 删 ns 是级联删除: ns 下的 PVC/Pod/Secret 全没 —— 删之前 kubectl get all -n <ns> 过目(460 题备份)
总结:namespace 是组织与治理的挂载点而不是安全墙:配额管总量、LimitRange 管底线、label 管成本;网络与节点的真隔离要 NetworkPolicy + 污点/节点池补上;删 ns 等于删一个世界,永远先备份。
追问1:ResourceQuota 和 LimitRange 的关系? → Quota 管”这个 ns 总共能用多少”,LimitRange 管”单个容器最少/最多怎么声明”——一个总量一个下限,配套才完整 追问2:跨 ns 引用 Secret 行吗? → 不行(Secret 是 ns 内对象);跨 ns 共享用 external-secrets 各自拉同一源头(470 题),别拷贝 追问3:一个 ns 的 Quota 用满了,表现是什么? → 新 Pod 创建被拒(exceeded quota),存量不受影响——扩 Quota 或清理闲置对象
433. Label、Selector 与 Annotation:元数据的分工是什么?
概念 Label 是可查询的标识(等值/集合选择器),K8s 的关联机制全靠它:Service→Pod、Deployment→ReplicaSet→Pod、网络策略对象圈定。Annotation 是不可查询的附加信息:构建信息、checksum、负责人、工具配置(ingress/reloader 的注解)。纪律:label 少而稳(变更影响拓扑),annotation 自由扩展。
典型场景 Service 选错/漏选 Pod(label 拼错);想把元数据塞进 label 导致组合爆炸;发布工具往 annotation 写哈希。
解决方案 三步:label 关联链验证 → 命名规范 → annotation 用法。
第一步:label 关联链验证
# 文件: label-chain.sh
# Service 圈 Pod 的真相: selector 匹配 Pod 的 label(不是名字!)
kubectl get svc api -o jsonpath='{.spec.selector}' # app=api
kubectl get pods -l app=api --show-labels # 实际被圈中的 Pod
# 排障: Service 没后端 → 90% 是 selector 与 Pod label 不一致(tier=api vs app=api)
kubectl get endpoints api # 有没有 IP 一目了然
# Deployment → RS → Pod 的标签继承链: 模板 label 变更 = 新 RS(滚动), selector 变更 = 不合法(immutable)
第二步:命名规范
# 文件: labels-standard.yaml
metadata:
labels:
app: api # 应用名(核心关联键, Service/RS 都靠它)
team: trade # 归属团队(成本/告警路由)
tier: backend # 层级(前端/后端/数据)
env: prod # 环境(多环境混部时)
version: 1.1.0 # 版本(金丝雀按它分流, 467 题)
# 规范纪律:
# label 值只能 [a-zA-Z0-9_-], 短、小写、无空格
# 核心四件套(app/team/env/version)全公司统一, 业务自定义从简
# 别把易变数据(实例 UUID/时间戳)放 label —— 那是 annotation 的事
第三步:annotation 用法
# 文件: annotation-uses.yaml
metadata:
annotations:
config/checksum: "a3f5..." # 配置哈希: 变更触发滚动(421 题模式B)
kubernetes.io/change-cause: "release 2026-10-17 feature-x" # rollout history 的说明
owner: "team-trade@corp.local" # 负责人(不可查询但人能看)
prometheus.io/scrape: "true" # 发现配置(453 题注解发现)
nginx.ingress.kubernetes.io/proxy-read-timeout: "3600" # controller 方言(420 题)
# 判据: 需要被"选择/查询"→ label; 只是"记录/配置"→ annotation
总结:K8s 的一切关联都是 label selector:改 label 等于改拓扑,要像改代码一样谨慎;annotation 是自由字段,工具链的配置面;核心 label 集合全公司统一,是成本核算与告警路由的地基。
追问1:改 Pod 的 label 会发生什么? → Pod 立刻脱离原 Service 的圈选(摘流)或被新 selector 圈中——紧急摘流的手法之一,也是误操作事故源 追问2:selector 是 immutable 吗? → Service 的 selector 可改(重圈 Pod),Deployment 的 selector 不可改(创建后锁死)——写错了只能删重建 追问3:label 和 annotation 的存储差异? → 都进 etcd 且都有索引开销;label 有倒排索引支持高效查询,annotation 不索引——所以”高频查询的字段才配当 label”
434. 从 docker-compose 到 K8s:迁移怎么对照着做?
概念 概念映射:service→Deployment(无状态)/StatefulSet(有状态)、environment→ConfigMap/Secret、ports+depends_on→Service+探针、volumes→PVC/hostPath、healthcheck→探针、restart→restartPolicy+Deployment 自愈。迁移的本质变化:从“单机进程管理”到“声明式集群编排”——镜像不用变,组织方式全变。
典型场景 本地 compose 跑通的服务要上集群;迁移后“行为不对了”(健康检查/依赖顺序/存储);团队要从 compose 心智切换到 K8s 心智。
解决方案 三步:对象对照表 → 行为差异清单 → 迁移路径建议。
第一步:对象对照表
# 文件: compose-to-k8s.txt
compose → K8s
service (无状态 web/api) → Deployment + Service(ClusterIP)
service (数据库, 单实例) → StatefulSet + headless Service + PVC(427 题)
environment / env_file → ConfigMap / Secret 的 env 注入(421/422 题)
ports: "3000:3000" → Service port + targetPort(集群内互访不需要映射端口)
depends_on (condition:healthy) → init 容器等待 / 应用内重试(431 题)
healthcheck → liveness/readiness 探针(424 题)
volumes: (named) → PVC(444 题)
volumes: (bind mount 配置) → ConfigMap 挂载
restart: always → Deployment 的自愈(副本控制)
deploy.resources → requests/limits(423 题)
deploy.replicas → spec.replicas
profiles / 多 compose 文件 → Kustomize overlay / Helm values(465/466 题)
第二步:行为差异清单
# 文件: behavior-diff.txt
迁移后"感觉不对"的高频差异:
1) 服务名解析变了: compose 的服务名 → <svc>.<ns>.svc.cluster.local(430 题); localhost 互访彻底失效
2) 健康检查语义变了: compose 只查"活着"; K8s 分 liveness/readiness —— 配错引发重启风暴(424 题)
3) 存储生命周期变了: named volume 挂在 docker 上; K8s 的 PVC 独立于负载(删 Deployment 卷还在)
4) 发布方式变了: compose 是"替换容器"; K8s 是滚动新副本 —— preStop/优雅停机必须补(239/417 题)
5) IP/主机名变了: Pod 重建换 IP —— 一切写死地址的配置要改 Service 名
6) 日志去处变了: docker logs → 节点文件 + 采集器(450 题), 应用必须打 stdout
第三步:迁移路径建议
# 文件: migrate-path.txt
1) 镜像体检: 无状态化(状态外置)、非 root(414 题)、信号处理(408 题)、stdout 日志
2) 无状态服务先行: Deployment+Service+探针 三件套上线, compose 里对应项照抄改写
3) 数据库后行: 先用云托管 DB(最低风险), 自建需求再上 StatefulSet/operator(427 题)
4) 配置搬家: env → ConfigMap/Secret;敏感项直接上 external-secrets(470 题)
5) 本地保留 compose 开发流(407 题): 开发用 compose 的拓扑文件, 生产用 K8s manifest,
两者用同一份"服务拓扑清单"生成(kompose 起步 / 自研模板) —— 防两套拓扑漂移
总结:迁移是心智切换:进程管理→声明式编排;对象有对照表但行为差异(解析/健康/存储/发布)才是坑点;路径上无状态先行、数据库托管优先、双编排共享拓扑清单防漂移。
追问1:kompose 转换工具能用吗? → 能起步(compose → YAML 自动转),但产物要人工审:探针/资源/优雅停机这些 compose 里没有的语义必须补 追问2:compose 和 K8s 长期共存行吗? → 行且常见:开发 compose、生产 K8s;关键是共享“拓扑真相”,别让两边各自长出第四套环境定义 追问3:迁移后怎么做等价验证? → 冒烟清单(路由/健康/发布滚动/停机收尾/日志可见)+ 双跑影子流量对比(有条件时),对齐 286 题压测基线
三、K8s 进阶与稳定性(435–449)
435. HPA:自动扩缩容怎么配才不震荡?
概念 HPA 周期(默认 15s)对比”当前指标 ÷ 目标指标”得到期望副本数(与当前副本相乘),按扩缩策略平滑调整。指标来源:资源 CPU/内存(requests 百分比)、自定义指标(QPS/队列深度)。震荡根源:指标噪声 + 扩缩对称 + 冷却缺失;解法:目标值留余量、缩容慢于扩容(stabilizationWindow)、指标选”领先信号”。
典型场景 流量高峰扩容不及时;副本数一会儿 4 一会儿 20(震荡);扩了副本 CPU 反而没降(瓶颈在别处)。
解决方案 三步:基础 CPU HPA → 策略防震荡 → 自定义指标(业务驱动)。
第一步:基础 CPU HPA
# 文件: hpa.yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata: { name: api }
spec:
scaleTargetRef: { apiVersion: apps/v1, kind: Deployment, name: api }
minReplicas: 3
maxReplicas: 20
metrics:
- type: Resource
resource:
name: cpu
target: { type: Utilization, averageUtilization: 65 } # 目标: request 的 65%
# 语义: 当前所有 Pod 平均 CPU 用量是 request 的 130% → 期望副本 ≈ 2 倍
# ⚠️ 前提: Pod 必须声明了 cpu request(百分比的分母), 没声明 HPA 直接失明
# ⚠️ maxReplicas 的上限来自压测容量(286 题), 不是拍脑袋 —— HPA 不能超过没验证过的规模
第二步:策略防震荡
# 文件: hpa-stable.yaml
spec:
behavior:
scaleUp:
stabilizationWindowSeconds: 0 # 扩容要快: 立即响应
policies: [{ type: Percent, value: 100, periodSeconds: 30 }] # 每 30s 最多翻倍
scaleDown:
stabilizationWindowSeconds: 300 # 缩容要慢: 观察 5 分钟稳定低负载才缩
policies: [{ type: Pods, value: 2, periodSeconds: 60 }] # 每 60s 最多缩 2 个
# 震荡场景复现: 目标 80%+无冷却 → 流量脉冲扩容 → 扩完指标掉 → 立刻缩 → 再脉冲再扩
# 修法三件: 目标降到 65%(余量)、缩容窗口 300s、缩容步长限制
第三步:自定义指标(业务驱动)
# 文件: hpa-custom.yaml
spec:
metrics:
- type: Pods # 每 Pod 自带指标(应用暴露)
pods:
metric: { name: http_requests_per_second }
target: { type: AverageValue, averageValue: "200" } # 每 Pod 扛 200 QPS
- type: External # 外部全局指标(与 Pod 数无关)
external:
metric: { name: queue_depth, selector: { matchLabels: { queue: doc-ingest } } }
target: { type: AverageValue, averageValue: "100" } # 积压 100 条/副本
# 价值: CPU 是"滞后信号"(先忙再升); QPS/队列深度是领先信号
# 推理服务场景: 用并发请求数或 GPU 利用率扩(489 题细讲), CPU 对 IO/等待型负载几乎无意义
# 依赖: metrics-server(资源指标)+ prometheus-adapter(自定义指标, 453 题栈内组件)
总结:HPA 的数学很简单(比例放大),工程在选信号与调行为:目标留余量、扩快缩慢、冷却窗口;资源指标起步,业务指标进阶;max 上限用压测数据背书,HPA 永远不该扩进未验证区。
追问1:HPA 和 VPA 能同时对 CPU 生效吗? → 不能:同时管同一资源会打架(436 题),要么分对象要么关 VPA 的该资源建议 追问2:扩容了但延迟没降? → 瓶颈不在应用层:查 DB 连接池(229 题)/下游限流(245 题)/锁竞争——扩副本只解决算力不够 追问3:minReplicas 也要设的理由? → 保底容量(突发缓冲+滚动更新余量),夜里缩到 0 的在线服务是自找的冷启动事故
436. VPA 与 HPA 的配合:自动调资源怎么不出冲突?
概念 VPA 自动推荐/调整容器的 requests:三种模式——Off(只推荐,读建议值)、Initial(只在 Pod 创建时应用)、Auto(重建 Pod 应用,与 HPA 同用必冲突)。与 HPA 的正解:HPA 管副本数(自定义指标),VPA 管单 Pod 规格(Off/Initial 模式或关掉 CPU 维度),两者错开控制面。
典型场景 request 全靠拍脑袋(过大浪费过小驱逐);想知道”该给多少资源”的依据;VPA Auto 模式与 HPA 打架的现象。
解决方案 三步:推荐模式起步 → 与 HPA 错峰组合 → 落地节奏。
第一步:推荐模式起步(最安全)
# 文件: vpa-reco.sh
kubectl apply -f https://.../vpa.yaml # 部署 VPA(含 recommender)
kubectl get vpa api -o jsonpath='{.status.recommendation.containerRecommendations[0]}'
# 输出示意: target: {cpu: 350m, memory: 420Mi}, lowerBound/upperBound
# Off 模式价值: 把"拍 request"变成"读周报调 request" —— 资源账本(423 题)的数据来源
# 周报节奏: 每周 review 推荐值, 人工改 manifest(GitOps 可审计, 464 题), 而不是让机器直接改
第二步:与 HPA 错峰组合
# 文件: vpa-hpa.txt
冲突机理: HPA 按 CPU 利用率(request 百分比)扩副本; VPA Auto 改大 request
→ 利用率瞬间"下降" → HPA 缩容 → VPA 又推荐调小 → 死循环震荡
正解组合:
方案A(主流): HPA(自定义指标 QPS/并发)+ VPA(Off/Initial 管内存与 CPU request)
—— HPA 的分母不是 CPU 时, 两者控制面不相交
方案B: 只用 HPA, request 靠 VPA 推荐值人工定期调 —— 最保守
方案C(新): HPA + EHPA/cluster-proportional 类按外部信号扩, 规格固定分档(小/中/大 Pod)
死守一条: 同一维度(副本数 or 单实例规格)永远只有一个控制器做主
第三步:落地节奏
# 文件: vpa-rollout.txt
1) 第 1-2 周: Off 模式观察推荐值 vs 实际(453 题指标对照), 建立直觉
2) 季度调 request: 按推荐值 + 余量改 manifest, 走 PR(可回滚)
3) 特殊场景才 Initial/Auto: 长尾小服务太多管不过来时, Auto 限定在无 HPA 的对象上
4) 别忘了节点侧: request 变化影响调度与超卖账本(423/448 题) —— 调完后看节点 Allocated
总结:VPA 的核心价值是”推荐”而不是”自动改”:Off 模式把拍脑袋变成读数据;与 HPA 并存的铁律是控制面错开(HPA 用非 CPU 信号或 VPA 只推荐);request 调整走 PR 节奏,和代码一样可审计。
追问1:VPA 的 Auto 模式重建 Pod 有什么代价? → 每次 evict 重建(中断/滚动)、与 PDB/HPA 交互复杂——这是它难以默认开启的根本原因 追问2:内存推荐为什么通常比峰值小? → VPA 看 P95+目标的分位策略;突发型内存(缓存预热)要人工加余量或用 lowerBound 追问3:KEDA 和 HPA 什么关系? → KEDA 是 HPA 的”信号扩展前端”(把队列长度/cron/云指标换算成 HPA 可用信号),还能缩到 0——事件驱动场景的事实标准
437. 亲和性与反亲和性:调度位置怎么控制?
概念 nodeSelector(硬匹配节点 label)是入门;主力是 affinity 三类:nodeAffinity(挑节点:SSD/GPU/区域)、podAffinity(与某类 Pod 同节点:就近部署)、podAntiAffinity(与某类 Pod 不同节点:高可用打散)。软硬两档:required(必须,不满足 Pending)与 preferred(尽量,打分加权)。拓扑域 topologyKey 决定”打散的粒度”(hostname=每节点一副本)。
典型场景 副本全调度到一个节点(节点挂全挂);数据库想调度到 SSD 节点;前端要和后端就近(同节点省一跳)。
解决方案 三步:节点亲和 → 反亲和打散(HA 核心)→ 就近部署与常见坑。
第一步:节点亲和——挑硬件
# 文件: node-affinity.yaml
spec:
affinity:
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution: # 硬性: 不满足不调度
nodeSelectorTerms:
- matchExpressions:
- { key: node-type, operator: In, values: [ssd] }
preferredDuringSchedulingIgnoredDuringExecution: # 软性: 加权偏好
- weight: 80
preference:
matchExpressions:
- { key: topology.kubernetes.io/zone, operator: In, values: [cn-east-1a] }
# 解读: 必须落在 ssd 节点; 同 zone 优先(降跨可用区延迟)
# ⚠️ IgnoredDuringExecution: 已运行的 Pod 不因节点 label 变化被驱逐 —— 亲和是"调度时"的决策
第二步:反亲和打散——高可用的正确姿势
# 文件: anti-affinity.yaml
spec:
affinity:
podAntiAffinity:
preferredDuringSchedulingIgnoredDuringExecution: # 生产推荐: 软打散
- weight: 100
podAffinityTerm:
topologyKey: kubernetes.io/hostname # 粒度: 每节点
labelSelector:
matchLabels: { app: api }
# 效果: api 的副本尽量分散到不同节点; 节点不够时仍可调度(软性兜底)
# 硬性(required)的代价: 节点数 < 副本数时直接 Pending —— 集群扩节点前会"假死"
# 多可用区部署: topologyKey 换成 topology.kubernetes.io/zone → 副本跨 AZ 打散(机房级容灾)
# ⚠️ 打散规则要配 PDB(439 题)才有"运行时"保护: 调度打散防创建聚集, PDB 防驱逐时团灭
第三步:就近部署与常见坑
# 文件: co-locate.yaml
spec:
affinity:
podAffinity:
preferredDuringSchedulingIgnoredDuringExecution:
- weight: 100
podAffinityTerm:
topologyKey: kubernetes.io/hostname
labelSelector:
matchLabels: { app: cache } # 前端 Pod 尽量和 cache 同节点(省一跳)
# 常见坑:
# 1) anti-affinity 的 labelSelector 圈到了自己以外的对象(条件写错 → 打散失效)
# 2) preferred 权重叠加后互相抵消(两个冲突偏好的权重没拉开)
# 3) 超大集群上反亲和计算开销大: selector 圈的集合越大, 调度越慢 —— 圈选要精确
总结:调度控制三板斧:节点亲和挑硬件、反亲和做打散(HA 的调度侧)、podAffinity 做就近;生产用 preferred 软规则留活路,硬规则只在“绝对不容忍”时上;调度期打散 + 运行期 PDB 才是完整的高可用组合。
追问1:为什么反亲和推荐软性而不是硬性? → 硬性在节点不足/维护时直接卡 Pending,把“尽量分散”升级成“不能运行”——可用性反而变差 追问2:topologyKey 写 zone 和 hostname 的区别? → zone:跨机房打散(容灾);hostname:跨节点打散(单机故障)——按故障域选择粒度 追问3:已运行的 Pod 会因节点加污点被踢走吗? → 污点只影响“新调度”;已在跑的 Pod 不容忍新污点时,要看 NoExecute 效果才驱逐(438 题)
438. 污点与容忍:节点专属怎么实现?
概念 污点(taint)打在节点上,排斥不容忍它的 Pod;容忍(toleration)写在 Pod 上,允许调度到带对应污点的节点。专用节点 = 节点打污点 + 专属 Pod 带容忍(+nodeSelector 圈定)。三种效果:NoSchedule(不再调度新的)、PreferNoSchedule(尽量不)、NoExecute(连已有的也驱逐)。控制面节点默认带污点,这就是业务 Pod 不上去的原因。
典型场景 GPU 节点只跑推理;大数据节点不许在线服务混部;节点要维护先“隔离”。
解决方案 三步:专用节点池 → 控制面污点与系统组件 → NoExecute 的驱逐语义。
第一步:专用节点池
# 文件: taint-node.sh
# 给 GPU 节点打污点: 普通Pod(不带容忍)不会调度上来
kubectl taint nodes gpu-node-1 workload=gpu:NoSchedule
kubectl label nodes gpu-node-1 nvidia.com/gpu.present=true
# 文件: gpu-pod.yaml
spec:
nodeSelector: { nvidia.com/gpu.present: "true" } # 圈定节点
tolerations: # 容忍污点(两把钥匙一起用)
- { key: workload, operator: Equal, value: gpu, effect: NoSchedule }
# 反向隔离(可选): 普通节点打 workload=standard:NoSchedule, 普通服务都带这条容忍 —— 专属池互相排他
第二步:控制面污点与系统组件
# 文件: cp-taint.sh
kubectl describe node master-1 | grep -i taint
# node-role.kubernetes.io/control-plane:NoSchedule ← 控制面默认污点
# 系统组件凭什么能跑: 它们的 manifest 带对应 toleration(kube-system 里全是样板)
# 给控制面跑轻量负载(小集群省机器): 给特定 Deployment 加这条容忍 —— 但控制面稳定性优先, 慎重
第三步:NoExecute 的驱逐语义与维护场景
# 文件: noexecute.txt
NoExecute: 不容忍的"存量" Pod 也会被驱逐(带 tolerationSeconds 的可以宽限一阵)
维护隔离的标准动作(461 题配套):
1) kubectl cordon node → NoSchedule: 新 Pod 不来
2) kubectl drain node → 驱逐存量(Eviction API, 受 PDB 439 题节制)
3) 维护完 kubectl uncordon
紧急"隔离嫌疑节点"(故障但还没定位):
kubectl taint node bad-node quarantine=true:NoExecute → 上面 Pod 全部迁走, 节点留现场排查
tolerationSeconds: 200 的含义: 带 NoExecute 容忍但只撑 200s —— 网络插件常见写法(短暂断连自愈窗口)
总结:污点是节点的“门禁”,容忍是 Pod 的“钥匙”:专用池 = 污点 + 容忍 + selector 三件套;NoExecute 连存量一起赶,是维护与紧急隔离的杠杆;cordon/drain 是它的安全封装,永远配合 PDB 用。
追问1:为什么污点要配 nodeSelector? → 只靠容忍:Pod 能去“所有不带其他污点”的节点(包括普通节点);selector 圈定才真正双向专属 追问2:drain 为什么会卡住? → PDB 不允许(minAvailable 挡)或 Pod 是裸 Pod/不受控制器管理 —— 加 —disable-eviction 或处理 PDB 追问3:污点能当“降级开关”吗? → 能但别滥用:给节点打 PreferNoSchedule 让调度器自然绕开——灰度摘节点的轻量手法
439. PDB:自愿驱逐时怎么保住法定副本数?
概念 PDB(PodDisruptionBudget)声明“可容忍的自愿驱逐损失”:minAvailable(至少留几个/百分比)或 maxUnavailable(最多挂几个)。作用域是自愿驱逐(drain/节点维护/autoscaler 缩节点);对节点宕机等非自愿故障无效(那是副本数+反亲和的事)。drain 时驱逐控制器会等 PDB 满足,不满足就排队重试。
典型场景 维护节点时把服务副本全赶下线;滚动更新与 HPA 缩容叠加时的容量保护;单副本服务忘了配 PDB。
解决方案 三步:PDB 语义 → 与滚动/HPA 的叠加 → 反模式。
第一步:PDB 语义
# 文件: pdb.yaml
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata: { name: api }
spec:
minAvailable: 2 # 任何自愿驱逐后, Ready 的 api Pod 至少 2 个
selector: { matchLabels: { app: api } }
# 或 maxUnavailable: 1 # 至多 1 个不在(等价于"每次自愿操作只动一个")
# 验证: kubectl get pdb → ALLOWED DISRUPTIONS 列(当前允许的驱逐额度, 0 = drain 会等)
第二步:与滚动/HPA 的叠加
# 文件: pdb-compose.txt
三层容量保护各管一段:
反亲和(437 题) → 创建时打散: 别把副本挤在一个节点
PDB(本题) → 驱逐时保底: drain/缩节点时留法定数量
maxUnavailable(418 题) → 滚动更新时的容量损失上限
叠加注意: 滚动更新(maxUnavailable: 0)+ PDB(minAvailable: 100%)同时苛刻时,
drain 一个节点可能永久等待(更新占着额度) —— 发布窗口与维护窗口错开
HA 计算示例: 3 副本 → maxUnavailable: 1; 5 副本跨 3 AZ → minAvailable: 4(允许一次驱一个)
第三步:反模式
# 文件: pdb-antipatterns.txt
1) 单副本服务配 minAvailable: 1 → ALLOWED DISRUPTIONS 永远 0: 任何 drain 卡死 —— 先加副本再谈 PDB
2) PDB selector 圈不到 Pod(label 拼错) → 形同虚设, get pdb 看 SELECTED 为 0 一眼识破
3) 用 PDB 对抗节点宕机 → 无效: 非自愿驱逐不咨询 PDB; 容灾靠副本数+跨 AZ 打散(437 题)
4) maxUnavailable 设成副本数(全容忍) → 等于没设; PDB 是"愿意为维护付多少容量"的显式声明
总结:PDB 是自愿驱逐的容量合同:drain/缩节点时保住法定副本;它管维护不管宕机;selector 圈对、阈值合理、单副本先扩再配——ALLOWED DISRUPTIONS 是日常巡检的免费健康指标。
追问1:PDB 对 HPA 缩容有约束吗? → 没有:HPA 缩的是“副本目标”(删 Pod 不走驱逐 API);PDB 只约束 Eviction API(drain) 追问2:百分比和整数怎么选? → 固定规模用整数直观;HPA 动态规模用百分比(随副本数自适应) 追问3:drain 卡在 PDB 上怎么办? → 看是维护急需还是额度真的不够:等 HPA 扩上来/临时放宽 PDB(改回要记得)/分批 drain
440. 节点压力驱逐:内存磁盘吃紧时谁先被杀?
概念 kubelet 盈利式驱逐:节点内存/磁盘越过软硬阈值时,按”驱逐评分”挑牺牲者:超出 request 的比例(用得比承诺多的先走)、优先级(低的先走)、QoS(BestEffort 先走)。被驱逐的 Pod 标记 Evicted,由上层控制器(Deployment)在别处重建。与 OOMKill 的区别:OOMKill 是 cgroup 边界的内核行为(410 题),驱逐是 kubelet 的节点级行为。
典型场景 节点 Evicted 一串 Pod;磁盘 imagefs 满;想知道“为什么是我被驱逐”。
解决方案 三步:阈值与信号 → 驱逐评分规则 → 防御配置。
第一步:阈值与信号
# 文件: evict-signals.sh
kubectl describe node node-3 | grep -A5 "Conditions"
# MemoryPressure: True DiskPressure: False ImageGCFailed: ...
# 常见触发:
# memory.available < 100Mi(硬阈值默认) → 立刻驱逐
# nodefs.available < 10%(磁盘) → 删死 Pod/镜像, 再驱逐
# imagefs.available < 15% → 先 GC 镜像层
# ephemeral-storage 超限的 Pod(可写层/日志写爆自己的限额)也会被单独驱逐
kubectl get pods -A --field-selector=status.phase=Failed | grep Evicted # 全局看被驱逐名单
第二步:驱逐评分规则
# 文件: evict-order.txt
kubelet 挑牺牲者的顺序(内存压力):
1) 超出 request 最多的优先(用了 800Mi 但只声明 100Mi → 评分最高)
2) 同分看优先级(441 题): priority 低的先走
3) QoS 兜底: BestEffort(没声明)永远排在最前
解读"为什么是我": describe pod 看 Last State 的 reason: Evicted + 节点当时 Conditions
防御性结论: request 声明真实用量 = 降低被驱逐评分; 关键服务加高优先级 + Guaranteed(423 题)
第三步:防御配置
# 文件: evict-defense.yaml
# 1) 应用侧: 可写层限额(乱写文件的 bug 显性化)
resources:
limits: { ephemeral-storage: 2Gi }
# 2) 节点侧(kubelet 配置, 平台层): 抬高软阈值留缓冲
# evictionSoft: { memory.available: { value: 500Mi } } + evictionSoftGracePeriod
# 3) 系统预留: kube-reserved/system-reserved 留给组件(别让业务挤死 kubelet 自己)
# 4) 日志治理: 容器 stdout 日志有上限(logs 滚动), 应用写文件要挂 volume 别堆可写层(450 题)
总结:节点压力驱逐是 kubelet 的自保:评分 = 超用比例 + 优先级 + QoS;声明真实的 request、给关键服务优先级、管住可写层与日志,就把自己从“牺牲名单”前排挪走;MemoryPressure 的 True/False 是节点健康的第一眼指标。
追问1:Evicted 的 Pod 会自己恢复吗? → Deployment 管的会(别处重建);裸 Pod/Job 裸跑的不会——又一个“别用裸 Pod”的理由 追问2:驱逐和 OOMKill 的现象差异? → OOMKill: 容器退出码 137, Pod 在原节点可能重启;驱逐: Pod 对象状态 Evicted, 整体换地方重建 追问3:ephemeral-storage 的限额包含什么? → 可写层 + emptyDir + 容器日志——三大“隐形写盘”都算在 Pod 头上
441. 优先级与抢占:重要任务能不能”抢”资源?
概念 PriorityClass 定义优先级(数值越大越重要),Pod 引用之。抢占(preemption):高优先级 Pod 调度不了时,Scheduler 找出低优先级 Pod“杀掉腾位”(被抢占 Pod 收到优雅删除,由控制器在别处重建)。系统类 critical(系统优先级)保障 CNI/CSI 等组件先活;业务侧用于“交易优先于报表”“在线优先于离线”。
典型场景 GPU 被离线任务占满,在线推理上不来;节点挤压时想保核心链路;抢占引发的连锁重排。
解决方案 三步:PriorityClass 定义 → 抢占行为与代价 → 使用纪律。
第一步:PriorityClass 定义
# 文件: priority.yaml
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata: { name: online-critical }
value: 100000
preemptionPolicy: PreemptLowerPriority # 默认: 允许抢低的
globalDefault: false
description: "在线核心链路"
---
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata: { name: offline-batch }
value: 1000
preemptionPolicy: Never # 批任务永不抢别人(可以被别人抢)
# Pod 引用: priorityClassName: online-critical
# 内置: system-cluster-critical / system-node-critical —— 别占用这个量级
第二步:抢占行为与代价
# 文件: preempt-behavior.txt
触发: 高优 Pod Pending 且集群无资源 → Scheduler 挑"能腾出足够资源的最小受害者集合"
受害者视角: 收到正常的删除流程(SIGTERM+宽限期, 417 题)→ 控制器别处重建
代价与连锁:
1) 被抢的低优 Pod 重排可能再抢更低优的(级联)
2) 有状态负载被抢占 = 数据迁移级代价(StatefulSet 慎给低优先级)
3) 抢占只看"调度资源", 不看业务(PDB 不约束抢占 —— 这是它比驱逐更危险的地方)
观测: 被抢 Pod 的 Events 有 Preempted; 高优 Pod 的 Events 有 Preempted 3 个 Pod 的记录
第三步:使用纪律
# 文件: priority-discipline.txt
1) 优先级是"故障时的牺牲顺序", 不是"日常插队权" —— 稳态下毫无作用
2) 配合资源分层: 在线 pool 高优 + 离线任务跑在 spot/低优池(438 题污点分池)
3) 抢占关掉(preemptionPolicy: Never)给"只想保命不想惹事"的服务
4) system-node-critical 给 CNI/日志/监控(428 题 DaemonSet 的纪律): 观测组件必须最后死
5) 值要拉开数量级(100000 vs 1000), 避免微差值难解释
总结:PriorityClass 声明“谁值得活”,抢占是它硬的一面:杀低优腾位给高优;工程上优先保观测与核心链路、离线可牺牲;抢占不看 PDB、不看业务身份,用之前想清楚代价链。
追问1:抢占会考虑反亲和/PDB 吗? → 反亲和会(受害者集合要满足高优 Pod 的约束),PDB 不会——这是 PDB 文档明说的盲区,关键服务要靠副本数自保 追问2:同优先级会互相抢吗? → 不会:只在“更高”之间发生;同级 Pending 排队等资源 追问3:spot/抢占式实例与这个什么关系? → 云层抢占(实例 2 分钟通知)与 K8s 抢占是两层;spot 上只跑低优+可重试负载,两层叠加就是“省钱的代价可承受”
442. RBAC:权限模型怎么设计与审计?
概念 RBAC 四对象:Role(命名空间内权限规则)/ClusterRole(全局)、Subject(谁:User/Group/ServiceAccount)、RoleBinding/ClusterRoleBinding(把角色绑给人)。动词是最小单元(get/list/watch/create/update/patch/delete);K8s 的“用户”主要是 ServiceAccount(集群内身份)。默认 SA 权限:什么都不给(除了自动挂 token 的新版本默认不投影)。
典型场景 CI 的部署权限怎么给;应用 Pod 被攻破后能干什么;审计“谁能读 Secret”。
解决方案 三步:最小权限模板 → ServiceAccount 与应用权限 → 审计与防提权。
第一步:最小权限模板
# 文件: rbac.yaml
apiVersion: v1
kind: ServiceAccount
metadata: { name: api, namespace: trade }
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata: { name: api-config-reader, namespace: trade }
rules:
- apiGroups: [""]
resources: ["configmaps"]
resourceNames: ["api-config"] # 收窄到具体对象: 只能读这一个 CM
verbs: ["get", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata: { name: api-read-config, namespace: trade }
subjects: [{ kind: ServiceAccount, name: api, namespace: trade }]
roleRef: { kind: Role, name: api-config-reader, apiGroup: rbac.authorization.k8s.io }
# Deployment 引用: spec.template.spec.serviceAccountName: api
# ⚠️ 别用 default SA 干事(共用身份=审计灾难), 每应用一个 SA
第二步:CI/运维权限设计
# 文件: rbac-ci.txt
CI 部署权限(GitOps 视角, 464 题): 推荐收紧到"只 apply 自己命名空间"
Role: trade ns 内 deployments/configmaps/services 的 get/list/patch
❌ 不要给: secrets 的 create(用 external-secrets 代替, 470 题)、pod 的 create(exec 插马)
运维分级:
只读排障组: get/list/watch + pods/logs(455 题排障够用)
值班组: + rollout restart/scale(应急处置)
变更走 GitOps PR —— 集群里"人肉 apply"只在 break-glass 例外(有审计)
第三步:审计与防提权
# 文件: rbac-audit.sh
# 我(或某个 SA)能干什么:
kubectl auth can-i --list --as=system:serviceaccount:trade:api
kubectl auth can-i get secrets -n trade --as=system:serviceaccount:trade:api
# 防提权要点:
# 1) rolebindings/clusterrolebindings 本身是敏感资源: 能改绑定 = 能给自己提权
# → bindings 与 escalate/impersonate 动词绝不外发
# 2) audit log(451 题)盯: 谁在什么时间对 secrets 做了 get
# 3) 定期扫: 谁有 cluster-admin(kubectl get clusterrolebindings -o json | jq ...)
总结:RBAC 的工程要点:每应用独立 SA、规则收窄到具体资源与动词、CI 与运维分级、绑定本身当敏感对象;kubectl auth can-i --list 是权限审计的瑞士军刀。
追问1:Role 和 ClusterRole 的绑定组合? → Role+RoleBinding(ns 内)、ClusterRole+ClusterRoleBinding(全局)、ClusterRole+RoleBinding(把全局角色授予 ns 内——常用模式:一套通用只读角色到处绑) 追问2:Pod 里的 token 怎么来的? → 投影 SA token(有期的),挂在 /var/run/secrets/…;应用拿它调 K8s API——被攻破时这就是攻击者的身份,所以权限要最小 追问3:User 和 ServiceAccount 的区别? → User 是集群外身份(人/CI 证书),SA 是集群内资源;审计里统一按 Subject 追
443. NetworkPolicy:Pod 网络隔离怎么做?
概念 默认全通:任何 Pod 能连任何 Pod。NetworkPolicy 给 Pod(按 label 选择)声明流量白名单:ingress(谁能连我)/egress(我能连谁),一旦某 Pod 被策略覆盖,未允许的一律拒绝。前提:CNI 插件支持(Calico/Cilium;Flannel 原生不支持)。策略是加法(多个策略的并集为允许集),没有 deny 规则。
典型场景 数据库只允许 API 层连;前端 Pod 限制出网(防数据外传);租户间隔离。
解决方案 三步:基础白名单 → 默认拒绝的分层设计 → 排障。
第一步:基础白名单
# 文件: netpol.yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: { name: pg-only-from-api, namespace: data }
spec:
podSelector: { matchLabels: { app: pg } } # 作用对象: pg Pod
policyTypes: [Ingress]
ingress:
- from:
- namespaceSelector: { matchLabels: { env: prod } } # 来自 prod ns
podSelector: { matchLabels: { app: api } } # 且是 api Pod(ns+pod 双选)
ports: [{ protocol: TCP, port: 5432 }] # 只开 5432
# 未覆盖的流量不受影响; 被 pg 选择器覆盖后, 不匹配的 ingress 全拒
第二步:默认拒绝的分层设计
# 文件: netpol-default-deny.yaml
# 先全拒(给 ns 内所有 Pod 立规矩), 再按需开白名单 —— 唯一可维护的模式
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: { name: default-deny-ingress, namespace: data }
spec:
podSelector: {} # 空 = 圈中 ns 内所有 Pod
policyTypes: [Ingress]
# ⚠️ 配套三张通用白名单: DNS(53 到 kube-dns)、监控抓取(prometheus)、探针来源(kubelet 节点网段)
# —— 忘了 DNS 白名单是"上了策略后服务集体解析失败"的头号原因
# egress 版同理: 敏感命名空间默认拒绝出网, 白名单放行指定依赖
第三步:排障
# 文件: netpol-triage.txt
连不通时的分层定位(429 题的上一层):
1) policy 是否覆盖了目标 Pod: kubectl get netpol -n <ns> -o wide(看 POD-SELECTOR 圈中谁)
2) 源是否在白名单: label 是否匹配(namespaceSelector 与 podSelector 是 AND)
3) 端口与协议: policy 只放 5432 时 ping 不通是正常的(ICMP 没放)
4) CNI 是否真的执行: calicoctl 的策略端点状态; 插件不支持时对象存在但不生效(最阴的坑)
观测: Cilium Hubble/Calico 流日志看 DROP 记录 —— 452 题栈的网格可视化
总结:NetworkPolicy 把网络从“全通的局域网”变成“白名单城堡”:默认拒绝 + 按需放行是唯一可维护模式;DNS/监控/探针三张通用白名单先备好;生效前提是 CNI 支持——对象存在不等于规则执行。
追问1:为什么没有 deny 规则? → 设计如此:白名单并集模型,简单可推理;“黑名单”需求(封单个 IP)用更细的 label 或 CNI 扩展(Cilium 的 deny 规则) 追问2:policy 能限制外部进来的流量吗? → ingress 策略对 NodePort/LB 进来的流量按源 IP 判断(externalTrafficPolicy 相关,419 题);纯 IP 的 ipBlock 字段可用但 NAT 后源不可信 追问3:跨命名空间的通用策略怎么管理? → 全局默认拒绝用“给每个 ns 打标签 + 全局策略选择”;策略即代码进 git,变更走 PR(464 题)
444. 存储体系:PV、PVC 与 StorageClass 怎么协作?
概念 PVC 是应用的“存储申请”(容量/访问模式/类别),PV 是“已就位的卷”,StorageClass 是“动态供给的配方”(provisioner+参数):声明 sc 后 PVC 自动触发创建 PV 并绑定。访问模式:RWO(单节点读写,最常用)、ROX(多节点只读)、RWX(多节点读写,NFS 类)。PV 独立于 Pod 生命周期,回收策略(Delete/Retain)决定 PVC 删除后数据命运。
典型场景 StatefulSet 的数据怎么持久化;扩容 PVC;卷绑定不上/挂载等待;多 Pod 共享数据。
解决方案 三步:动态供给链路 → StatefulSet 存储模板(与 427 题衔接)→ 扩容与故障形态。
第一步:动态供给链路
# 文件: storage.yaml
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata: { name: fast-ssd }
provisioner: ebs.csi.aws.com # CSI 驱动: 各云/存储厂商的"施工队"
parameters: { type: gp3, iops: "3000" }
reclaimPolicy: Delete # PVC 删 → 卷删(测试用); 生产重要数据 Retain
volumeBindingMode: WaitForFirstConsumer # 等 Pod 调度后再建卷(同可用区, 避免跨 AZ 挂载)
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata: { name: api-data }
spec:
accessModes: [ReadWriteOnce]
storageClassName: fast-ssd
resources: { requests: { storage: 50Gi } }
# 链路: PVC → StorageClass 选 provisioner → 云端建盘 → PV 生成并绑定 → Pod 挂载(scheduler
# 还会按 PV 的拓扑约束挑节点 —— WaitForFirstConsumer 的意义)
第二步:StatefulSet 存储模板
# 文件: sts-storage.yaml
spec:
volumeClaimTemplates: # 每 Pod 一个专属 PVC(427 题): pg-data-pg-0/1/2
- metadata: { name: data }
spec: { accessModes: [ReadWriteOnce], storageClassName: fast-ssd,
resources: { requests: { storage: 100Gi } } }
# RWO 的约束: 卷同时只能挂给一个节点 —— 所以"同 Pod 多容器共享"可以, "多副本共享一个 PVC"不行
# 多 Pod 真要共享: RWX(NFS/EFS 类 sc)或改架构(对象存储+同步, 224 题)
第三步:扩容与故障形态
# 文件: pvc-ops.sh
# 在线扩容(1.23+ 多数 CSI 支持): 改 PVC 的 requests.storage 即触发
kubectl patch pvc api-data -p '{"spec":{"resources":{"requests":{"storage":"100Gi"}}}}'
# 只能扩不能缩;扩容中状态 FileSystemResizePending → 节点上 resize 完成转 Bound
# 常见故障形态:
# Pending(没绑定) → sc 不存在 / WaitForFirstConsumer 在等 Pod / 配额不够(432 题)
# FailedAttachVolume → 节点与卷不同可用区(拓扑没对齐)
# Multi-Attach 报错 → RWO 卷还被旧节点持有: 等旧 Pod 完全终止(kubelet 确认detach)
kubectl get pvc -w # 观察状态流转
总结:存储三件套 = 申请(PVC)/供给配方(StorageClass)/实体(PV),CSI 是施工队;RWO 是常态、RWX 是特例;WaitForFirstConsumer 保拓扑对齐;回收策略生产用 Retain,删 PVC 前先想清楚数据命运。
追问1:PV 和 PVC 谁先谁后? → 静态供给人工建 PV 等绑定;动态供给 PVC 触发建 PV——现代集群几乎全是动态 追问2:快照怎么做? → VolumeSnapshot(CSI 快照):备份的基础(460 题),但要验证可恢复才算备份 追问3:emptyDir 和 PVC 怎么选? → 生命周期跟 Pod(缓存/暂存)用 emptyDir;数据要比 Pod 活得久用 PVC——405 题判据的集群版
445. 数据库该不该上 K8s:有状态数据的实践决策?
概念 决策矩阵:有状态数据在 K8s 的三个层级——托管服务外置(云 RDS/ES 服务,最低运维)、operator 自管(StatefulSet 之上的领域控制器,自动故障转移/备份)、裸 StatefulSet(只给愿意自己扛运维的团队)。核心约束:存储故障域、故障转移复杂度、备份恢复演练成本。结论倾向:核心交易数据外置;有运维能力时中间件层用 operator;纯缓存类可上集群。
典型场景 “我们要不要把 MySQL 搬进 K8s”;团队想自建 Redis/ES 集群省云费用;数据库上了 K8s 后的备份与容灾怎么做。
解决方案 三步:决策矩阵 → operator 路线要点 → 上与不上的对照清单。
第一步:决策矩阵
# 文件: db-on-k8s.txt
问题四连:
1) 数据丢了睡得着吗? 睡不着(交易/用户数据) → 外置托管(云 RDS), 集群重装不能带走它
2) 有领域运维能力吗? 有(DBA + 熟悉该软件的 HA) → operator 路线(CloudNativePG/Redis Operator)
3) 是缓存/可重建数据吗? 是(缓存/倒排索引) → 集群里跑, 重建成本可接受
4) 团队规模? <3 人平台组 → 别自管有状态, 外置是唯一正确答案
反模式: 裸 StatefulSet 跑生产 MySQL(没有自动故障转移 = 单点手动救火),
"省钱"驱动的决定(运维成本远超许可费用)
第二步:operator 路线要点
# 文件: cnpg.yaml(CloudNativePG 示意)
apiVersion: postgresql.cnpg.io/v1
kind: Cluster
metadata: { name: pg, namespace: data }
spec:
instances: 3
storage: { size: 200Gi, storageClass: fast-ssd }
backup:
barmanObjectStore: # 对象存储连续归档(WAL)
destinationPath: s3://corp-pg-backup/pg
wal: { compression: gzip }
replicationSlots: { highAvailability: { enabled: true } }
# operator 提供: 主从自动切换(租约防脑裂)、按时间恢复(PITR)、证书轮换、版本升级编排
# 你的责任没有消失: 存储性能、备份演练(460 题)、容量规划(286 题)、监控接入(452 题)
第三步:上与不上的对照清单
# 文件: db-checklist.txt
上 K8s 的收益: 声明式管理、与业务同套工具链(IaC/RBAC/监控)、环境复制容易、测试库秒起
外置的收益: 云厂商兜底 SLA、内核参数/备份/容灾开箱、故障有客服
无论哪边都要自己做的: 备份演练、容量、慢查询治理(158 题)、密钥轮换(283 题)
连接形态注意: 集群内访问外置 DB 用 ExternalName/endpoint 服务化(419 题), 别把 IP 写死在配置里
总结:有状态上不上 K8s 是运维责任分配问题:托管外置买安心、operator 自管买一致性与弹性、裸 StatefulSet 只属于有充分运维能力的团队;决策四问(丢数据/能力/可重建/人力)比技术选型表更管用。
追问1:Redis 上 K8s 的特殊注意? → 持久化卷 IO 延迟(RWO 块存储 vs AOF fsync)、主从切换的哨兵/operator 选型、maxmemory 与容器 limit 对齐(410 题) 追问2:有状态服务的升级怎么做才安全? → operator 分片滚动(从库先升)+ 版本兼容矩阵 + 回退预案;裸 STS 的 partition 灰度(427 题)是底线 追问3:怎么验证“备份真的可用”? → 定期恢复演练到临时集群 + 数据校验(行数/抽样)——没演练过的备份等于没有(299 题同源纪律)
446. etcd 与控制面运维:集群的”命根子”怎么守护?
概念 etcd 存集群全部状态对象,一致性基于 Raft;写路径的唯一持久层。运维要点:磁盘 fsync 延迟是 etcd 的生命线(建议 SSD,fsync <10ms)、默认 2GB(-–quota-backend-bytes 可到 8GB)、快照备份 + 恢复、defrag 碎片整理。控制面其他组件无状态化(从 etcd 重建认知),所以”备份 etcd = 备份集群身份”。
典型场景 etcd 磁盘慢导致整个集群“卡”(API 超时、Pod 创建慢);对象太多撑爆配额;灾难恢复演练。
解决方案 三步:健康检查与指标 → 备份恢复 → 容量与性能治理。
第一步:健康检查与指标
# 文件: etcd-health.sh
etcdctl endpoint status -w table # 关键列: DB SIZE, RAFT TERM/INDEX, LEADER
etcdctl endpoint health
etcdctl member list
# 三个高优指标(452 题栈采集):
# etcd_disk_wal_fsync_duration_seconds(P99 < 10ms) ← 磁盘慢 = 一切慢的根因
# etcd_server_slow_apply_total / proposals_committed ← 提交速率
# db_size / quota ← 撑到配额 = 集群只读
第二步:备份与恢复
# 文件: etcd-backup.sh
# 快照(定时任务, 460 题与 velero 衔接):
ETCDCTL_API=3 etcdctl snapshot save /backup/etcd-$(date +%F).snap \
--endpoints=https://127.0.0.1:2379 --cacert=... --cert=... --key=...
etcdctl snapshot status /backup/etcd-2026-10-17.snap # 校验(哈希/revision)
# 恢复 = 灾难演练: 停 apiserver → etcdctl snapshot restore(到新数据目录)→ 起 etcd → 验证对象
# 每季度真演一次; 快照没验证过恢复 = 没有备份
第三步:容量与性能治理
# 文件: etcd-tuning.txt
对象数治理: etcd 限额是字节不是对象数, 但海量小对象(events!)是主凶
1) events 分离: 独立 etcd 实例(apiserver --etcd-servers-overrides)—— 最有效的一招
2) TTL 类对象自动清; successfulJobsHistoryLimit 收敛(426 题)
3) 别把 etcd 当数据库: 大 JSON 注解/超大 ConfigMap(1MB 上限, 421 题)都是反模式
性能基线: 控制面节点独占(污点, 438 题)、SSD、--heartbeat-interval/election-timeout 按
跨机房延迟调(单机房默认即可)
defrag: 碎片整理有锁风险, 低峰逐成员做(db_size 与 in_use 比值失衡时才需要)
总结:etcd 是集群的身份:磁盘 fsync 是生命线、快照+恢复演练是保命符、events 分离与大对象治理是容量秘诀;控制面无状态可重建,但 etcd 的数据丢了集群就是“失忆的新生儿”。
追问1:apiserver 卡和 etcd 慢怎么区分? → apiserver 自身指标(request_duration)正常但 etcd fsync 高 = etcd 的锅;反之查 apiserver(准入 webhook 慢也是常见根因) 追问2:etcd 能跑 5 副本吗? → 能(奇数成员,容 2 故障);一般 3 够,跨 AZ 分布即可 追问3:velero 和 etcd 快照什么关系? → 互补:etcd 快照救“整个集群”;velero 按命名空间/资源导出(对象存储),救“误删某服务”——两者都做(460 题)
447. Pod 安全准入(PSS):把 414 题的基线变成集群强制?
概念 Pod Security Standards 三档:Privileged(不限制)、Baseline(禁最危险:privileged 宿主网络/宿主 PID 等)、Restricted(最严:非 root、 dropped ALL、seccomp 必须)。在 namespace 上用 label 启用(enforce 拒绝/warn 警告/audit 记录),取代了旧 PodSecurityPolicy。与 414 题的关系:414 是镜像与 Pod spec 的手动基线,PSS 是 admission 层的集群强制。
典型场景 想禁止 privileged 容器上线;渐进收紧不炸存量;审计现有违规。
解决方案 三步:namespace 级启用 → 渐进 rollout 三步法 → 与镜像层基线协同。
第一步:namespace 级启用
# 文件: pss-label.sh
kubectl label ns trade pod-security.kubernetes.io/enforce=baseline
kubectl label ns trade pod-security.kubernetes.io/enforce-version=v1.29 # 锁定版本语义
# 三通道可同时用:
# enforce=baseline 违规直接拒绝创建
# warn=restricted 违规给出警告(CI/开发反馈)
# audit=restricted 违规记事件(451 题审计流, 只记不拦)
# 特权例外走专门 ns: monitoring(要 hostPath)/storage-plugin(要特权)单独 baseline+白名单评审
第二步:渐进 rollout 三步法
# 文件: pss-rollout.txt
1) audit+warn 全开(Restricted): 收集违规清单(kubectl get events 里的 PolicyViolation)
2) 存量整改: 应用侧改(非 root/414 题)/该豁免的挪专用 ns; CI 加 preflight 检查(kubectl
--dry-run=server 创建即校验, 293 题流水线门禁)
3) enforce 开闸: 先新 ns 后存量 ns; 每一步观察一周
雷区: init 容器也要过 PSS(它在 Pod spec 里); Job/CronJob 模板同样受管
第三步:与镜像层基线协同
# 文件: pss-defense.txt
纵 deep 防线:
镜像(401/414 题): distroless/非 root —— 让"合规"成为默认, 而不是每次 spec 手写
PSS(本题): admission 拦截 —— 挡住手滑与恶意 manifest
运行时(412 题签名+准入): 只跑签名镜像 —— 挡住"合法创建的恶意内容"
分工心法: 镜像层决定"能不能合规", PSS 决定"敢不敢违规", 签名决定"是不是自己人"
总结:PSS 把安全基线从文档变成准入闸门:三档标准、三通道(enforce/warn/audit)、ns 级生效;渐进式(audit 先行→整改→enforce)是不炸存量的唯一路径;与镜像基线、签名验证组成三层纵深。
追问1:旧 PodSecurityPolicy 和 PSS 的区别? → PSP 是逐对象的准入(可绕过:有权限创建 PSP 的人自己豁免自己),PSS 是 ns 级标签声明、不可被工作负载绕过 追问2:豁免机制? → 基于 ns 划分(特权专用 ns);系统 ns(kube-system)默认豁免 —— 所以“混进 kube-system”是攻击目标,442 题 RBAC 要锁死 追问3:Restricted 档最常见的违规是什么? → 没 dropped ALL 的 capabilities、runAsUser 非 0 但 allowPrivilegeEscalation 没设 false——414 题的清单就是为它准备的
448. 大节点 vs 小节点、资源碎片:集群形态怎么选?
概念 节点规格的两难:大节点(64C/256G)单价优、运维少,但故障域大、 bin-packing 碎片绝对值大;小节点碎片小、故障域小,但固定开销(kubelet/系统预留/日志 agent)占比高、要管更多节点。碎片 = 节点上”装不下任何新 Pod”的闲置资源;调度是装箱问题,request 粒度决定碎片率。
典型场景 节点 Allocated 90% 但每个节点都剩 2C4G(没人要得上);节点池选型;扩容成本优化。
解决方案 三步:碎片观测 → 规格选型 → 治理手段。
第一步:碎片观测
# 文件: fragmentation.sh
kubectl describe nodes | grep -A6 "Allocated resources" | head -40
# 逐节点看 requests 账本; 碎片 = (Capacity − Allocated) 中"无法容纳典型 Pod 规格"的部分
# 快速诊断: 对每节点算 max(C−alloc_cpu, C−alloc_mem 换算), 都小于典型 request(如 1C2G) → 纯碎片
# 指标化(452 题): node_allocatable_resources vs pod_requests 的分布 —— 碎片率进看板
第二步:规格选型
# 文件: node-size.txt
通用在线池: 中等规格(16C/64G)是甜点 —— 故障域可控 + 固定开销占比低(~5-8%)
大规格(64C+)适合: 单 Pod 就很大的负载(推理实例, 487 题) —— 别无选择时才用
小规格(4C)适合: 边缘/专用池(跑 DaemonSet 密集的小节点, 428 题)
混合池是常态: 通用中规格 + 大规格专用池(GPU/内存型) + spot 池(离线)
固定开销清单(每节点): kubelet+容器运行时 ~0.5C, 日志/监控 agent ~0.3C, 系统预留 ——
小节点上这些能吃掉 15-20%: "节点越小浪费越多"的数学根源
第三步:治理手段
# 文件: frag-fix.txt
降碎片率:
1) request 规格化: 引导服务用标准档位(0.5C1G / 1C2G / 2C4G), 装箱效率暴增 —— 436 题推荐值的工程化
2) 超卖: CPU request 超卖 2-3x(423 题) —— 用"统计复用"填补碎片
3) 重调度(descheduler): 周期性把"钉子户 Pod"挪走合并低水位节点, 再缩容
4) 节点自动伸缩(Karpenter/CA): 按Pending需求选"最合适的规格"而不只是加同款 —— Karpenter
的核心价值就是碎片感知选型
容量复盘节奏(286 题集群版): 月度看碎片率/超卖比/节点利用率三张图, 决定池子调整
总结:节点形态是故障域×固定开销×碎片的三角:中规格通用池+专用大规格池+离线 spot 是常见解;碎片治理靠 request 规格化、超卖、descheduler 与弹性伸缩的选型智能;节点账本(Allocated)月度复盘。
追问1:为什么大节点碎片绝对值大? → 剩 10% 的 64C 节点 = 6C 闲置,而典型 Pod 1~2C 理论塞得下——真正碎片来自“形状不合”(CPU 剩 5C 内存剩 2G);规格越杂越明显 追问2:Karpenter 比 Cluster Autoscaler 强在哪? → CA 只扩既定节点组;Karpenter 按 Pending Pod 直接选云上最优规格(可拼零头),碎片与成本双优 追问3:节点数多小的管理成本在哪? → 每节点的 DaemonSet 副本数(×节点数)、镜像分发量(411 题预热/P2P)、升级批次数(449 题)——都是线性增长的税
449. K8s 版本升级:怎么升才不翻车?
概念 升级对象两层:控制面(小版本逐级升,etcd 数据原地)与节点(滚动替换, Pods 迁移)。API 弃用是最大风险:每版本淘汰旧 API(如 policy/v1beta1 → policy/v1),用已弃用 API 的清单/CRD/operator 会在升级后直接失败。方法论:升级前 deprecation 扫描 → 先升从集群/测试环境 → canary 节点池 → 全量,并确认回退路径(控制面升级不可回退,只能靠 etcd 快照)。
典型场景 集群落后三个版本不敢动;升级后老 Deployment apply 报 no matches for kind;节点池滚动期间容量不足。
解决方案 三步:升级前检查清单 → 升级路径 → 弃用 API 的治理。
第一步:升级前检查清单
# 文件: pre-upgrade.sh
# 1) API 弃用扫描: 集群里在用的旧 API 版本(apiserver 的 --removed-apis 或工具 pluto)
kubectl get deployments -A -o json | jq -r '.items[].apiVersion' | sort -u
pluto detect-all-in-cluster --target-version v1.30 # 社区标准工具
# 2) 组件兼容矩阵: CNI/CSI/ingress/监控 agent 的版本支持范围(升级顺序可能要求先升它们)
# 3) 容量余量: 节点滚动要 1/N 的 buffer(448 题), PDB 已配(439 题)
# 4) etcd 快照新鲜(446 题) + velero 备份(460 题)
# 5) 变更窗口与回退预案: 控制面升级 = 单行道
第二步:升级路径
# 文件: upgrade-path.txt
1) 测试集群先行(同版本同配置), 全量回归(289 题E2E套件 + 冒烟)
2) 控制面: 托管集群点升级(云厂商编排); 自建 kubeadm upgrade(逐控制面节点)
3) 节点池: 新版本节点组 + 滚动迁移(cordon/drain 旧节点, 461 题) —— 比原地升级干净,
顺手换镜像/补丁; canary 池先走(1-2 个节点观察一天)
4) 升级后验证: 全组件健康/PVC 可挂载/网络策略生效/核心链路冒烟
节奏: 每年 2-3 个小版本, 跟着上游 N-2 策略 —— 落后越多, 弃用与安全债越重
第三步:弃用 API 的治理
# 文件: api-deprecation.txt
1) 清单仓库全面显式 apiVersion(别依赖默认), CI 里 pluto/kubeval 按"目标版本"校验(293 题门禁)
2) CRD 与 operator 的兼容: operator 升级常落后于 K8s —— 升集群前先升 operator 到兼容版
3) beta API 慎用于核心对象: policies/deployment 曾多次 v1beta1→v1 迁移; 核心生产用 stable API
4) 存量改造: kubectl convert 或手动改写 + 在低版本集群验证(双写期)
升级当天也要看 events: 弃用 API 的报错第一现场是 create/apply 的 410 Gone
总结:K8s 升级是流程工程:弃用扫描(pluto)先行、测试集群验证、节点池滚动替代原地、etcd 快照垫底;跟上 N-2 节奏比“攒一次大的”安全得多;API 弃用治理要进 CI,别让升级日的 410 Gone 教你做人。
追问1:控制面升级失败了怎么办? → 托管集群云厂商回滚支持有限;自建只能 etcd 快照恢复重建——所以快照必须“升级前 10 分钟内”的新鲜度 追问2:能不能跳版本升? → kubeadm 不支持跳小版本;托管集群部分支持——统一按逐级走,别赌 追问3:节点原地升级和替换升级怎么选? → 替换(新节点组滚动)是主流:干净、可回退(旧组保留一会)、顺带标准化;原地快但状态残留风险高
四、可观测与运维(450–461)
450. 日志采集架构:容器日志怎么集中化?
概念 K8s 日志事实标准:应用打 stdout/stderr → 容器运行时落到节点文件(/var/log/pods/…,按大小滚动)→ 节点上的采集器(DaemonSet:Filebeat/Fluent Bit)读文件 → 发后端(Loki/ES)。两条铁律:应用只管打 stdout(写文件的日志采集器看不到,除非挂载约定路径);多行日志(堆栈)要在采集器配置合并。Pod 删除后节点上的日志文件随之清理——“先采集后删除”是排障窗口的来源。
典型场景 Pod 删了日志也没了;kubectl logs 有但 Loki 里查不到;多行堆栈被拆成 N 行;日志量把存储打爆。
解决方案 三步:采集链路与配置 → 应用侧纪律 → 存量与成本治理。
第一步:采集链路(Fluent Bit DaemonSet)
# 文件: fluentbit-config.yaml(ConfigMap 节选)
data:
fluent-bit.conf: |
[INPUT]
Name tail
Path /var/log/pods/*/*/*.log
Docker_Mode On # 多行合并(CRI 日志格式的续行拼接)
Mem_Buf_Limit 50MB
Skip_Long_Lines On
[FILTER]
Name kubernetes # 注入元数据: ns/pod/label —— Loki 里按它们检索的前提
Match *
[OUTPUT]
Name loki
Match *
Host loki-gateway.observability.svc.cluster.local
Labels ns={{''}} # 结构化标签由 k8s filter 带出
# DaemonSet 挂载 hostPath /var/log/pods + /var/log/containers(428 题样板)
# CRI 格式注意: containerd 的日志是带前缀的 JSON 流, 需要 parser 解析日志等级/时间
第二步:应用侧纪律
# 文件: app-logs.txt
1) stdout/stderr 是唯一通道(223 题结构化 JSON 更佳: 采集器零解析成本)
2) 别写 /tmp 或工作目录 —— 那些文件在可写层, 采集器不认, Pod 删除即蒸发(405 题)
确实要文件日志: emptyDir + sidecar 采集(431 题)或约定 hostPath —— 都属于例外, 走评审
3) 多行堆栈: JSON 单行天然免疫; 文本日志靠采集器规则(Java 堆栈的续行模式)
4) kubectl logs --previous 的意义: 上一次容器的日志文件还没被清 —— 崩溃排障第一入口(425 题)
第三步:存量与成本治理
# 文件: logs-cost.txt
量治理三件(223 题同源):
1) 分级保留: error 30d / info 7d / debug 不采集(生产默认关)
2) 采样与截断: 高频日志(Nginx access)采样; 单行截断(64KB 上限防脏日志)
3) 后端选型: Loki(索引 label 不索引正文, 便宜)vs ES(全文索引, 贵但检索强)——
常见组合: 应用日志 Loki + 审计/安全日志 ES
节点侧兜底: 日志文件本身有 rotation(xkB/份 × 5 份), 采集积压时节点磁盘不爆(440 题)
总结:日志链路 = stdout → 节点文件 → DaemonSet 采集 → 后端;应用侧只做一件事:结构化打 stdout;多行、元数据、成本都是采集层与后端的工程;排障窗口来自”先采集后清理”。
追问1:kubectl logs 和采集到 Loki 的时间差? → 秒级(实时链路);差很多时查采集器积压(Mem_Buf_Limit 打满会丢)与后端写入 追问2:为什么不让应用直接发后端? → 断连重试/背压都是应用负担;批量与缓冲在采集层做;应用保持”傻输出”最稳 追问3:大集群日志量怎么估? → QPS × 平均日志行数 × 行字节;容量规划(286 题)要给日志链路单独留账
451. K8s 事件与审计日志:排障与合规的两类”系统日志”?
概念 Events 是资源对象的”状态变更推特”(调度决策/拉镜像失败/探针失败/驱逐),默认存 etcd 1 小时,是排障第一现场;audit log 是 apiserver 的访问记录(谁在何时对什么对象做了什么),可配规则过滤与分level(Request/Response/Metadata),是合规与安全溯源的依据。两者互补:Events 讲”系统对你做了什么”,audit 讲”谁对系统做了什么”。
典型场景 describe 的 Events 为什么是空的;要查”上周谁改了 Deployment”;安全团队要 API 访问留痕。
解决方案 三步:Events 实战 → audit 配置 → 两者在排障中的组合。
第一步:Events 实战
# 文件: events.sh
kubectl get events -n trade --sort-by=.lastTimestamp | tail -20
# 按类型过滤: Warning 是信号(FailedScheduling/ImagePullBackOff/Unhealthy/evicted)
kubectl get events --field-selector type=Warning -A | tail -30
# ⚠️ 默认 etcd 事件只留 ~1h 且新版本 events 走独立 apiserver 存储 ——
# 要"回看"就得采集: event-exporter 把 events 转指标/日志进 452 题的栈
# 常用映射: 417 题的排障表里每类故障都对应一类 event, 它们是自动告警的原料
第二步:audit 配置
# 文件: audit-policy.yaml(apiserver 启动参数 --audit-policy-file)
apiVersion: audit.k8s.io/v1
kind: Policy
rules:
- level: RequestResponse # 敏感对象的读写全记(含请求体/响应体)
resources: [{ group: "", resources: ["secrets", "configmaps"] }]
- level: Metadata # 其余只记元数据(谁/何时/什么动作)
users: ["system:serviceaccount:trade:ci"]
- level: None # 高频无害的降噪(kubelet 的状态上报)
users: ["system:kube-proxy"]
verbs: ["get", "watch"]
# 输出: --audit-log-path 文件(采集器收走)或 webhook
# 容量: RequestResponse 很肥 —— 只给 secrets 级敏感对象; 默认 Metadata 起步
第三步:排障中的组合拳
# 文件: events-audit-flow.txt
故障溯源的组合用法:
"副本数怎么变成 1 了?"
1) audit: 谁在何时 patch 了 deployment 的 replicas(人? HPA? CI?) —— subject 一目了然
2) events: HPA 的 ScalingReplicaSet 事件序列(为什么缩: 指标掉)
3) 指标(453 题): 当时 CPU/QPS 曲线
→ 三层拼出完整因果链; 缺 audit 就是"罗生门"
合规联动: audit 里的 secret get 记录 ↔ 442 题 RBAC 审计; 告警规则盯非常规时间段的敏感读
总结:Events 是排障第一现场(1 小时时效,要采集留存);audit 是责任溯源与合规底座(策略分层控制肥瘦);“系统行为 + 人为行为”两类系统日志与指标配合,才能拼出故障的完整因果链。
追问1:Events 存哪里?新版本变化? → 旧版 etcd(1h TTL);新版独立 events API 存储(可挂后端),采集方案要跟着版本走 追问2:audit 日志怎么防”记日志的人删日志”? → 输出到集群外的 syslog/webhook( append-only 存储),集群内权限再大也够不着 追问3:Events 能做告警源吗? → 能(event-exporter → 指标/日志 → 告警规则),如 FailedScheduling 持续出现 = 容量预警——454 题路由
452. kube-prometheus-stack:监控栈怎么部署与配置?
概念 社区事实标准的全家桶(Helm chart):Prometheus(采集与存储)+ Alertmanager(告警路由)+ Grafana(可视化)+ node-exporter(DaemonSet 主机指标)+ kube-state-metrics(对象状态指标)+ operator(ServiceMonitor/Rule 的声明式管理)。两层发现:kubernetes_sd(Pod/Service 自动发现)+ relabel 按注解筛。
典型场景 新集群监控从零到一;服务怎么被自动采集;Prometheus 自身挂了谁监控(self-monitoring)。
解决方案 三步:栈部署 → 两层发现的机制 → 存储与高可用。
第一步:栈部署
# 文件: prom-stack.sh
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm install mon prometheus-community/kube-prometheus-stack -n observability --create-namespace \
--set grafana.adminPassword.createSecret=true \
--set prometheus.prometheusSpec.retention=30d \
--set prometheus.prometheusSpec.storageSpec.volumeClaimTemplate.spec.storageClassName=fast-ssd
# 装完即得: 集群/节点/Pod 三级基础面板 —— 大盘(Dashboard)先看"整体健康四件":
# 节点资源水位 / Pod 重启次数 / API server 延迟 / 集群事件速率
第二步:两层发现的机制
# 文件: podmonitor-sample.yaml
apiVersion: monitoring.coreos.com/v1
kind: PodMonitor
metadata: { name: api, namespace: trade }
spec:
selector: { matchLabels: { app: api } } # 圈 Pod(433 题label)
podMetricsEndpoints: [{ port: metrics, interval: 30s }]
# 另一条路: 注解发现(Pod 注解 prometheus.io/scrape: "true" + relabel 规则)—— 轻量无 CRD
# kubernetes_sd + relabel 的价值: 新 Pod 上线自动进采集, 无需改 Prometheus 配置
# 298 题应用侧指标暴露(/metrics, prom-client)在 K8s 的"最后一公里"就是这题
第三步:存储与高可用
# 文件: prom-ha.txt
1) 本地盘 TSDB(retention 30d)起步; 长期存储加 Thanos/VictoriaMetrics 远端 —— 指标分级:
高频详细 7d / 聚合长期 1y(298 题预算思想的栈版)
2) 高可用: Prometheus 双副本(相同目标各自抓) + Alertmanager 集群(gossip 去重)
3) self-monitoring: 监控 Prometheus 自己的 up/采集失败/时间序列数 —— 它瞎了你要知道
4) 指标爆炸治理: 高基数 label(userId 当 label)会撑爆 TSDB —— 298 题纪律在监控层同样成立
总结:监控栈一条 Helm 装齐全家桶:operator 把采集规则变成 CRD(ServiceMonitor/PodMonitor),发现靠 kubernetes_sd 自动跟随;存储分级 + 双副本 + self-monitoring 是生产三件套;应用侧只管暴露 /metrics。
追问1:kube-state-metrics 和 node-exporter 的分工? → 前者报“对象状态”(副本数/重启次数/Pod 状态),后者报“机器资源”(CPU/内存/磁盘)——一个看 K8s 一个看节点 追问2:Prometheus 抓不到目标的排查? → targets 页面看 up 与 last error;常见:端口名不匹配(monitor 指 port 名而非数字)/网络策略挡了(443 题白名单)/路径不是 /metrics 追问3:告警规则写在哪? → PrometheusRule CRD(随 chart/应用仓库管理, GitOps 分发)——298 题的规则文件在 K8s 的家
453. 服务指标接入:从应用到面板的完整链路?
概念 完整链路四段:应用暴露 /metrics(298 题 prom-client,RED 指标)→ PodMonitor/注解发现接入(452 题)→ 指标带 K8s 元数据(ns/pod 名,采集器注入)→ Grafana 按 label 聚合出面板。K8s 环境的特殊红利与纪律:自动发现免配置;但 Pod 名是高基数(面板按 Deployment 聚合,别按 Pod 建图例)。
典型场景 应用指标在 Prometheus 里查得到但面板没数;想知道每副本和每服务的指标怎么聚合;指标对了但 Pod 重启后图断裂。
解决方案 三步:应用指标规范 → PromQL 的 K8s 聚合姿势 → 面板组织。
第一步:应用指标规范
// 文件: metrics.ts(Nest 侧, 与 298 题同一套 counter/histogram)
import { Counter, Histogram, collectDefaultMetrics } from 'prom-client';
collectDefaultMetrics(); // 进程级: 堆/事件循环(214 题)
export const httpDuration = new Histogram({
name: 'http_request_duration_seconds',
help: 'duration',
labelNames: ['method', 'route'], // route 用模板(/orders/:id)防基数爆炸
buckets: [0.01, 0.05, 0.1, 0.3, 1, 3],
});
// 暴露路由: @Controller() getMetrics(@Res() res) { res.type(contentType).end(register.metrics()); }
第二步:PromQL 的 K8s 聚合姿势
# 文件: promql-k8s.txt
服务级 P99(滚动更新不断裂 —— 按 deployment 聚合而不是 pod):
histogram_quantile(0.99,
sum by (le, deployment) (rate(http_request_duration_seconds_bucket[5m])))
# deployment 标签来自 kube-state-metrics 或 relabel 注入(452 题 k8s 元数据)
错误率按命名空间维度的对比(团队账):
sum by (ns) (rate(http_requests_total{status=~"5.."}[5m]))
/ sum by (ns) (rate(http_requests_total[5m]))
Pod 维度只用于"个体排障"视图(Debug 面板), 不进常态大盘 —— Pod 名是高基数
第三步:面板组织
# 文件: dashboards.txt
分层看板(Grafana 文件夹结构, 随应用仓库走 JSON, 464 题 GitOps):
全局 SLO 层: 各服务错误率/P99/SLO 预算消耗(286 题)
服务层(每服务一板, 变量选 ns/deployment):
RED 三图 + 实例数(HPA 联动) + 重启次数 + 资源用量 vs limit(423 题)
排障层: 单 Pod 下钻(日志链接 → Loki, trace 链接 → 279 题后端) —— 面板互链是效率倍增器
dashboard as code: JSON 进 git, 改面板走 PR —— 手工改的面板是"孤儿资产"
总结:指标链路的 K8s 段 = 发现自动化 + 元数据注入 + 按工作负载聚合;应用侧沿用 298 题的 RED 规范与基数纪律;面板分 SLO/服务/排障三层且全部进 git。
追问1:为什么按 deployment 聚合能防图断裂? → Pod 重建换名,按 pod 聚合的序列就断线;deployment 标签稳定跨版本 追问2:指标和 trace 怎么联动? → exemplars(指标采样点带 trace_id)或面板互链;279 题的 trace 后端与 452 题栈同屏是目标形态 追问3:metrics 端口要不要对全集群暴露? → 用注解发现 + NetworkPolicy(443 题)限制只有 Prometheus 抓取——指标里也有信息量
454. Alertmanager:告警路由与值班体验怎么设计?
概念 Alertmanager 接收 Prometheus 的 firing 告警,负责三件事:分组(同类合并)、抑制(高级别压制低级别)、静默(维护窗口);路由树按 label 分流到值班渠道(IM/电话/ticket)。值班体验三原则:每条告警有 runbook 链接(299 题)、按响应动作分级(298 题纪律)、避免风暴(分组+抑制)。
典型场景 一次节点故障触发 200 条告警刷屏;告警发到没人看的群;维护窗口被告警骚扰。
解决方案 三步:路由树设计 → 分组抑制静默 → 值班体验清单。
第一步:路由树设计
# 文件: alertmanager.yaml
route:
receiver: default-im
group_by: [alertname, ns] # 分组: 同名告警按命名空间合并成一条
group_wait: 30s # 首条等 30s 攒批
group_interval: 5m # 组内新告警的合并间隔
repeat_interval: 4h # 未解决的重复提醒
routes:
- match: { severity: page }
receiver: oncall-phone # 电话级: 单独通道
- match: { team: trade }
receiver: trade-im # 团队自治: 按团队标签分流
- match: { alertname: Watchdog }
receiver: blackhole # 死信告警(本身是"告警链路活着"的心跳)
第二步:分组、抑制、静默
# 文件: silence-inhibit.yaml
inhibit_rules: # 抑制: 节点挂了就别再报"节点上的 Pod 挂"
- source_match: { alertname: NodeDown }
target_match_re: { alertname: KubePodCrashLooping|PodNotReady }
equal: [node]
# 静默(维护窗口, 命令行创建):
# amtool silence add --duration=2h node=node-3 --comment "449 题升级维护"
# 静默要有 owner 与到期时间 —— 永久静默等于删告警
第三步:值班体验清单
# 文件: oncall-xp.txt
1) 告警消息三要素: 症状一句话 + 当前值/阈值 + runbook 链接(299 题) —— 缺 runbook 的告警是甩锅
2) 分级即通道: page=电话 / ticket=工单 / silent=只留痕(298 题纪律的落地)
3) 演练触发: 每月人为触发一条 page 验证链路(299 题演练的告警版)
4) 复盘治理: 月度过一遍"上周每条告警的处理动作" —— 没动作的降级, 有动作但没告警的补
5) 双栈心跳: Watchdog 永久 firing 告警 → 收不到它 = 告警链路本身挂了
总结:Alertmanager 的价值在“最后一公里体验”:分组防风暴、抑制防级联刷屏、静默保维护窗口;路由按团队/严重度分流;每条告警配 runbook、分级到通道,是 298 题告警治理在 K8s 栈的落地。
追问1:repeat_interval 设短的后果? → 未处理告警反复轰炸 → 值班免疫(狼来了);4h~12h 起步,真正催人靠 page 级通道 追问2:告警风暴怎么应急? → amtool 紧急静默(按 label 批量)+ 事后补根因;而不是把 Prometheus 关了 追问3:P1 事故时告警反向丢失? → 检查 Alertmanager 分组把不同 ns 的同 sym 合并过猛;按 alertname+ns 分组是平衡点
455. CrashLoopBackOff:崩溃循环怎么系统性诊断?
概念 容器反复崩溃 → kubelet 按指数退避重启(10s→20s→…→5min 上限),状态 CrashLoopBackOff。诊断铁律:第一件事看上一次的日志(—previous),Exit Code 是第一分类器(1 应用异常 / 137 OOMKill / 126 权限 / 1+配置错)。常见五类根因:配置错(启动即抛)、依赖不可达、OOM、探针/启动过慢被误杀、镜像/入口命令错。
典型场景 发布后服务进入 CrashLoop;环境差异导致测试好好的生产崩;容器起来 10 秒就退。
解决方案 三步:诊断流程(exit code 分诊)→ 五类根因对照 → 止血与修复分离。
第一步:诊断流程
# 文件: crashloop-triage.sh
kubectl get pod api-7d9c6b5f-x2kqp
# STATUS: CrashLoopBackOff RESTARTS: 7
kubectl describe pod api-7d9c6b5f-x2kqp | grep -A4 "Last State"
# Exit Code: 137 ← 第一分类器(下表)
kubectl logs api-7d9c6b5f-x2kqp --previous --tail=50 # ⚠️ 永远看上一次的
kubectl logs api-7d9c6b5f-x2kqp -c <init名> # 别漏 init 容器(431 题)
第二步:五类根因对照
# 文件: crashloop-causes.txt
Exit Code 分诊:
1 应用异常 → 看日志: 常见配置错(连不上 DB/密钥无效, 421/422 题注入的值对不对)
137 OOMKilled → 内存 limit 太小或泄漏(456 题专门讲); --previous 日志可能为空(被杀没来得及打)
126/127 → 命令/权限错: 入口命令打错、镜像里没这个二进制(exec 形式写错, 402 题)
143 → 收到 SIGTERM 退出: 检查谁在停它(liveness 失败重启的循环)
五类根因速查:
A 配置错 : 日志有明确堆栈(fail-fast 的 241 题设计让这类最易诊断)
B 依赖不可达: 连接超时 → 网络策略(443 题)/服务名(430 题)/依赖本身挂
C OOM : 456 题流程
D 被误杀 : liveness 太激进/无 startup 探针(慢启动被当死, 424 题)
E 镜像/命令 : describe 的 command/args 与镜像 entrypoint 是否冲突
第三步:止血与修复分离
# 文件: crashloop-stabilize.sh
# 止血(先恢复流量, 后修根因):
kubectl rollout undo deployment/api # 回滚到上一版(418 题, 秒级)
# 无法回滚的场景(配置类):
kubectl set env deployment/api BAD_CONFIG=x # 紧急改配置项
# 调试态(不接流量的现场): 副本缩到 0 会丢现场 —— 用同镜像起一个 command 改成 sleep 的调试 Pod:
kubectl run api-debug --rm -it --image=harbor.corp.local/team/api:1.2.0 \
--overrides='{"spec":{"containers":[{"name":"api","command":["sleep","3600"],"image":"..."}]}}' -- bash
# 修复: 走 PR + 流水线, 别让"线上手改"成为根因的下一层
总结:CrashLoop 诊断三步:Exit Code 分诊 → —previous 日志 → 五类根因对照;止血(回滚)与修根因分离,保留调试现场用 sleep 入口复制 Pod;OOM 类接着走 456 题。
追问1:为什么有时 —previous 也没日志? → OOMKill 来不及刷缓冲/应用在打印前就崩;改用 exit code+内存指标(456 题)定位 追问2:CrashLoop 和镜像拉取失败怎么区分? → ImagePullBackOff/ErrImagePull 是独立状态(还没起容器);CrashLoop 是起了又崩 追问3:BackOff 上限后还会再试吗? → 会:5 分钟封顶后继续按间隔重试——但依赖它“自愈”不如修根因,长期 CrashLoop 在浪费节点资源
456. OOMKilled:容器内存问题在 K8s 里怎么定位?
概念 两级内存约束:cgroup limit(容器级,410 题:超→OOMKill,exit 137)与节点压力驱逐(节点级,440 题:按评分挑牺牲者)。K8s 里定位内存问题的链路:确认死亡方式(容器 137 vs Pod Evicted)→ 内存增长曲线(heap 还是 external,219 题)→ 对齐 V8 堆与 limit → 定责(泄漏/配额小/突发)。
典型场景 Pod 频繁 137 重启;内存曲线只涨不降;“本地好好的,上 K8s 就 OOM”(本地没 limit)。
解决方案 三步:确认死亡方式 → 曲线归因 → 修复选项。
第一步:确认死亡方式
# 文件: oom-confirm.sh
kubectl get pod api-xxx -o jsonpath='{.status.containerStatuses[0].lastState}'
# reason: OOMKilled, exitCode: 137 → 容器级: 超了自己的 memory limit
kubectl get pods -A | grep Evicted → 节点级驱逐(440 题): 节点整体吃紧
# 两者治理路径完全不同: 前者看单容器账, 后者看节点账(423 题超卖)
第二步:曲线归因
# 文件: oom-curves.txt
看三根线(452 题栈, 容器视角):
container_memory_working_set_bytes(≈ cgroup 计费口径, OOM 的判定基准)
node_namespace_pod_container:container_memory_heap(应用 heap, 298/214 题暴露)
..._memory_external(堆外: Buffer/线程栈, 219 题)
形态判读:
working_set 阶梯涨, heap 平稳 → 堆外泄漏(Buffer 流未释放, 219 题排查)
heap 持续爬升不回落 → 堆泄漏: 堆快照对比(205 题)
平稳但贴近 limit, 突发尖刺过线 → limit 太紧: 加余量或治突发(缓存预热/批量任务)
只在滚动更新/双倍流量时发生 → 发布期内存翻倍(in-flight + 新旧并存), preStop/容量设计
第三步:修复选项
# 文件: oom-fix.txt
1) 对齐三层数字(410 题铁律): limit ≥ --max-old-space-size + 堆外预算(~30-40%)
2) limit 提升 ≠ 万能: 先确认是"配额不足"还是"泄漏" —— 泄漏加 limit 只是把爆炸推迟到深夜
3) 突发治理: 大任务挪 Job(426 题)/批量分片(277 题队列削峰)/缓存加上限(LRU)
4) 驱逐类(节点级): 治超卖(423 题)、抬 request 降评分(440 题)、节点扩容
5) 验证: 修复后看 7 天曲线 + 137 计数归零 —— 不是"今天没炸"就算好
总结:K8s 的 OOM 定位先分“怎么死的”(容器 137 vs 驱逐),再看三根内存曲线归因(heap/external/突发);修复从对齐 limit 与堆上限开始,但泄漏必须走 219/205 题的排查链;节点级问题治超卖而不是治单个 Pod。
追问1:working_set 和 RSS 的区别? → working_set ≈ RSS − 不活跃文件页,cgroup OOM 判定与 K8s 指标都以它为准——面板统一看它 追问2:为什么“本地没事”? → 本地没有 cgroup limit:同样的泄漏/峰值在本地只是“多用点内存”,容器里是死刑——limit 是本地与生产的本质差异 追问3:内存 limit 该设多大? → 压测峰值 × 1.5(286 题)+ V8 堆对齐;周期性 review 用 VPA 推荐值(436 题)
457. Service 不通:网络排障的决策树?
概念 Service 链路五段:客户端 DNS → Service VIP(kube-proxy 规则)→ Endpoints(就绪 Pod 列表)→ Pod(CNI 直通)→ 应用监听。排障按段走:每一段都有专属验证命令,别跳步。90% 的“不通”出在前三段(DNS 解析、Endpoints 空、就绪探针没过)。
典型场景 新部署的服务连不上;本地能通集群内不通;升级后部分流量 5xx。
解决方案 三步:决策树命令化 → 分段验证 → 高频根因速查。
第一步:决策树命令化
# 文件: svc-decision-tree.sh
# 段1 DNS: 名字解析得到 VIP 吗?
kubectl run p --rm -it --image=nicolaka/netshoot -- dig api.trade.svc.cluster.local
# 段2 Service/Endpoints: 有 VIP 且有后端吗?
kubectl get svc api -n trade
kubectl get endpoints api -n trade # ⭐ 空后端 = 最常见根因
# 段3 Pod: 就绪吗? 直接连 Pod IP 通吗?
kubectl get pods -n trade -l app=api # READY 1/1?
kubectl run p --rm -it --image=nicolaka/netshoot -- curl -m2 <PodIP>:3000/health
# 段4 应用: 端口/监听地址对吗?
kubectl exec api-xxx -- sh -c 'netstat -tlnp || ss -tlnp' # 监听 0.0.0.0 还是 127.0.0.1?
# 段5 策略: NetworkPolicy 挡了吗?
kubectl get networkpolicy -n trade # 443 题白名单核对
第二步:分段验证的通灵命令
# 文件: svc-verify.txt
半分段的快速二分:
Service VIP 通 + Pod IP 不通 → kube-proxy 规则问题(429 题)/iptables 异常
Pod IP 通 + Service 不通 → Endpoints 空(就绪探针)或 selector 不匹配(433 题)
DNS 不通 + IP 直连通 → 430 题 CoreDNS 排障节
间歇性不通 → conntrack 表满 / 某几个后端 NotReady(Endpoints 抖动)
工具: netshoot 一次性容器做以上全部(425 题), 别污染业务镜像
第三步:高频根因速查
# 文件: svc-top-causes.txt
1) Endpoints 空: readiness 没过(424 题)/ selector 与 Pod label 不匹配(433 题)
2) 应用监听 127.0.0.1: 容器里必须 0.0.0.0(Pod 外谁都连不上 loopback)
3) targetPort 写错: Service 的 targetPort 是容器端口, 写成了 port 自己
4) DNS: ndots/搜索域(430 题)、跨 ns 没带 ns 名
5) NetworkPolicy 默认拒绝上线忘了放行(443 题三张白名单)
6) UDP/长连接: Service 的会话与 conntrack(419 题 sessionAffinity)
总结:Service 排障 = 五段链路逐段验证:DNS → Endpoints(最高频)→ Pod 直连 → 应用监听 → 策略;工具用 netshoot 一次性容器;Endpoints 空这一条先查,能省一半时间。
追问1:为什么 curl Service VIP 有时 connection refused? → Endpoints 为空时 kube-proxy 无后端可转,拒绝快——先看 endpoints 再看别的 追问2:滚动更新期间部分 5xx? → preStop 缺失(417 题 Endpoint 摘除传播窗)或应用收尾不支持优雅停机(239 题) 追问3:跨命名空间访问的完整地址? → api.trade.svc.cluster.local;同一 ns 内短名即可(430 题解析顺序)
458. kubectl debug:临时容器与节点诊断怎么用?
概念 kubectl debug 的三种形态:临时容器(注入运行中的 Pod,共享网络与进程命名空间,不重启业务)、复制 Pod(带调试工具的克隆体,不接流量)、节点调试(在目标节点起 netns 全通的特权容器)。价值:把“带工具的调试”从镜像里解耦——镜像保持最小(401/403 题),工具按需注入,用完即销。
典型场景 distroless 镜像没有 shell;要看 Pod 视角的网络(连不上某个依赖);节点级排查(iptables/CNI)。
解决方案 三步:临时容器 → 复制 Pod → 节点调试。
第一步:临时容器(最常用)
# 文件: debug-ephemeral.sh
kubectl debug -it api-7d9c6b5f-x2kqp -c netdebug --image=nicolaka/netshoot --target=api
# --target=api: 与目标容器共享进程命名空间(能看它的进程/proc)
# 进入后的动作:
# ss -tnp # 它的连接(229 题连接池视角)
# curl -v http://db:5432 # 依赖连通性(457 题段验证)
# ls /proc/1/root/app # 走 /proc 看目标容器文件系统(484 题同源)
# 特性: 临时容器不占业务重启计数, Pod 删除即消失 —— 排障零侵入
第二步:复制 Pod(需要折腾不影响流量)
# 文件: debug-copy.sh
kubectl debug api-7d9c6b5f-x2kqp -it --image=nicolaka/netshoot \
--copy-to=api-debug --share-processes -- sleep 1h
# 复制体: 同镜像同参数但 command 覆盖为 sleep(不接流量, 随便折腾)
# 用途: 改动复制品的入口做实验(比如手动跑迁移/起 profiling), 原 Pod 安然无恙
# ⚠️ 复制体可能抢 PVC(RWO 锁, 444 题)—— 带卷的服务复制前先解绑或确认
第三步:节点调试
# 文件: debug-node.sh
kubectl debug node/node-3 -it --image=busybox:1.36
# 实际效果: 在该节点起一个 hostNetwork+hostPid 的特权 Pod, chroot /host 进入宿主文件系统
# 能干: 看 kubelet 日志(/host/var/log/)、检查 CNI 状态、抓包(tcpdump 装到该镜像)、
# 验证节点侧 conntrack/iptables —— 429/457 题链路的"最后一公里"现场
# 清理: 退出后删 Pod(node-debugger-node-3-xxxxx)
总结:kubectl debug 是“按需注入工具箱”的正规军:业务镜像保持最小、临时容器进 Pod、复制体做实验、节点模式查底层;用完即删的纪律让它成为 425 题排障地图的火力增强。
追问1:临时容器和 sidecar 的区别? → sidecar 是声明的常驻(Pod spec 一部分);临时容器是运行时注入的附加品(不进 spec,不可重启策略管理) 追问2:为什么 curl 通但业务日志说连不上? → 环境变量差异(临时容器不继承业务的 env)/DNS 搜索域不同——用 —target 共享视角后仍要以业务进程的 /proc 环境为准(484 题) 追问3:生产允许 debug 特权容器吗? → RBAC(442 题)把 debug 权限给值班组;节点调试是特权操作,审计(451 题)记录谁在何时开的
459. 本地调试三件套:port-forward、exec 与 proxy 的边界?
概念 port-forward:把本地端口转发到 Pod/Service(个人调试隧道,不经 Ingress);exec:在容器里执行命令(交互 shell/一次性命令);proxy:本地起一个到 apiserver 的代理(用本地权限访问 K8s API 与 Dashboard 类服务)。边界纪律:全是“个人级”工具,不构成对外暴露方案;exec 受镜像工具限制(401/403 题),复杂排障升级到 458 题。
典型场景 本地想直连集群里的数据库调试;本地起的前端连集群后端;临时看看 Dashboard。
解决方案 三步:port-forward 实战 → exec 的边界 → proxy 与安全注意。
第一步:port-forward 实战
# 文件: pf.sh
kubectl port-forward svc/pg 5432:5432 -n data # 本地 5432 → Service
kubectl port-forward pod/api-xxx 3000:3000 # 直接到 Pod
# 用途: 本地 GUI 连集群 DB / 本地前端调集群后端(开发联调, 407 题compose外的补充)
# 特性: 走 kubectl 与 apiserver 的 SPDY 隧道, 不占节点端口、不需要 Ingress 暴露
# 断线重连: --retries; 长期使用封装成脚本(连上后自动打开本地服务)
# ⚠️ 它是"你个人"的通道: 别拿它当对外暴露(没有认证/审计, 断了就没了)
第二步:exec 的边界
# 文件: exec.sh
kubectl exec -it api-xxx -- sh # 有 shell 的镜像
kubectl exec api-xxx -- node -e "console.log(process.memoryUsage())" # 一次性命令(distroless 也能跑 node)
# 边界:
# 1) 镜像里没有的命令跑不了(403 题的代价)→ 458 题临时容器补位
# 2) 生产 exec 全部留痕(451 题审计)—— 排障只读优先, 改状态走 PR
# 3) exec 进行的变更不进 git: "我在容器里改了个配置然后好了"= 不可复现的事故隐患
第三步:proxy 与安全注意
# 文件: proxy.sh
kubectl proxy --port=8001
# 然后本地访问 http://localhost:8001/api/v1/namespaces/trade/services/...
# 用途: 用本地 kubeconfig 权限直接调 K8s API(看对象/调 Dashboard/调试 operator CRD)
# 安全三条:
# 1) proxy 绑 127.0.0.1(默认)—— 别改成 0.0.0.0 把 apiserver 权限广播出去
# 2) 三件套的会话都是"你的身份": 权限多大责任多大(442 题最小化的反面提醒)
# 3) 团队共享的调试入口(多人要用)→ 正式做: Ingress + 认证 + 451 题审计, 别人手 port-forward 挂后台
总结:三件套是个人调试的瑞士军刀:port-forward 打洞、exec 进程内操作、proxy 代理 API;共同边界是“个人级、临时性、有审计”——要团队共享或长期暴露就走 420 题的正式入口。
追问1:port-forward 到 Service 和到 Pod 的差异? → Service 方式:kubectl 自己选一个后端(不经 kube-proxy 负载均衡);Pod 方式:直达指定实例——排障时指名道姓用 Pod 追问2:exec 和 debug 怎么选? → 镜像里有工具+只跑一条命令 → exec;没有 shell/要看网络/要装工具 → 458 题 debug 追问3:本地连集群服务的正规长期方案? → telepresence 类工具(把本地进程“接进”集群网络)或 VPN+内网 Ingress;port-forward 是应急不是架构
460. 备份与恢复:velero 与 etcd 快照怎么配合?
概念 两层备份:etcd 快照(446 题)保“整个集群身份”(控制面级,恢复=换集群);velero 按 Kubernetes 对象(命名空间/Deployment/ConfigMap…)+ 关联 PV 卷快照做选择性备份与跨集群恢复。组合使用:etcd 兜底灾难,velero 做“误删恢复/环境迁移/合规归档”。铁律:没有演练过恢复的备份等于没有。
典型场景 有人删错了命名空间;合规要求应用配置与数据可归档;跨集群/跨区域迁移。
解决方案 三步:velero 部署与备份计划 → 恢复实战(含坑)→ 演练节奏。
第一步:velero 部署与备份计划
# 文件: velero-setup.sh
velero install \
--provider aws --bucket corp-velero-backup --backup-location-config region=cn-east-1 \
--snapshot-location-config region=cn-east-1 \
--use-node-agent # 文件级备份(FSB)需要节点 agent
# 定时备份(全集群对象 + 带 PV 的卷快照):
velero schedule create daily-all --schedule="0 19 * * *" --include-resources="*" --ttl 720h
# 选择性备份(某 ns 每小时): velero schedule create trade-hourly --include-namespaces trade
# 三种内容: 对象(manifest)/卷(CSI 快照)/文件(FSB 走对象存储, 兼容性强)
第二步:恢复实战(含坑)
# 文件: velero-restore.sh
# 场景: trade ns 被误删
velero restore create --from-backup daily-all-20261017 --include-namespaces trade
velero restore describe daily-all-20261017-xxxx # 看 Completed 与 skipped 资源
# 坑清单:
# 1) 对象能恢复, Service 的 ClusterIP 会变(依赖方按 DNS 名访问就没事, 430 题纪律的价值)
# 2) Secret/CRD 若被集群级排除(velero 默认排除 kube-system)—— 自定义 include
# 3) 卷快照的区域性: 快照在同区域可用, 跨区要 FSB 或复制
# 4) 运行中集群恢复到"过去" = 时间旅行悖论: 恢复到新 ns/新集群验证后再切流
第三步:演练节奏
# 文件: backup-drill.txt
季度演练日历(299 题精神):
Q1: velero 恢复 trade ns 到临时集群, 应用冒烟 + 数据抽样校验
Q2: etcd 快照恢复(446 题流程)到备用控制面, 验证对象完整
Q3: 跨区域恢复演练(FSB 路径), 记录 RTO
Q4: "删库演练": 测试环境真删真恢复, 更新 runbook
产出: 每次演练的 RTO/RPO 实测数字 + 修复项(备份没覆盖的对象/过久的流程)
总结:备份是两层:etcd 保集群身份、velero 保业务资产(对象+卷);恢复的三坑(ClusterIP 变、排除项、跨区)要提前踩;季度演练出真实 RTO——没演练的备份是心理安慰。
追问1:RTO/RPO 怎么定? → 业务侧倒推:RPO=可容忍丢多少数据(备份频率),RTO=可容忍停多久(恢复路径演练实测)——286 题容量之外的两个 SLA 数字 追问2:数据库的备份归谁管? → 数据层自己管(operator 的连续归档, 445 题)——velero 管对象与卷的粗粒度;细粒度 PITR 是数据库工具的职责 追问3:velero 能做迁移吗? → 能(备份→新集群恢复);注意 IP/DNS/存储类替换, 演练先行(464 题多环境的极端版)
461. 节点维护:cordon 与 drain 的标准动作?
概念 维护三步:cordon(封锁:不再调度新 Pod)→ drain(驱逐:按优雅停机把存量 Pod 迁走,受 PDB 节制)→ 维护完成后 uncordon。与 438 题污点的关系:drain 的实现就是打不可容忍的污点+调用 Eviction API。配套纪律:维护窗口公告、PDB 先行检查、节点回来后验证调度恢复。
典型场景 节点内核补丁/硬件更换;449 题升级的节点池轮换;故障节点隔离。
解决方案 三步:标准流程 → 卡住时的处理 → 大规模滚动。
第一步:标准流程
# 文件: drain-flow.sh
kubectl cordon node-3 # 1) 封锁: NoSchedule(新 Pod 不来)
kubectl drain node-3 --ignore-daemonsets --delete-emptydir-data \
--grace-period=60 --timeout=10m # 2) 驱逐: DaemonSet 不动(Spot/DS 是节点属性)
# 内部动作: 逐 Pod 走 Eviction API → PDB 校验(439 题)→ 优雅停机(417 题)→ 控制器别处重建
kubectl uncordon node-3 # 3) 解封: 恢复调度
# 维护前检查: kubectl get pdb -A | grep -v ALLOWED.*0 # 有额度才不会卡
第二步:卡住时的处理
# 文件: drain-stuck.txt
drain 卡住的三个来源与对策:
1) PDB 拒绝(ALLOWED DISRUPTIONS=0): 等副本恢复/临时调 PDB(改回要记得)/分小批
2) 裸 Pod / 不受控制器管理: 加 --force(裸 Pod 直接删, 没有重建 —— 先确认它不重要)
3) PVC 单挂(RWO 被钉在这节点): 新 Pod 等卷 detach(444 题 Multi-Attach)
紧急场景(节点要挂了): kubectl drain --disable-eviction --force --grace-period=0
—— 直接删不走 Eviction: 绕过 PDB, 只在"节点马上要死"时用
第三步:大规模滚动(节点池轮换)
# 文件: pool-rotate.txt
节点池整体轮换(449 题升级/镜像更新的标准姿势):
1) 新节点组起(新版本/新镜像), 验证加入集群
2) 旧组节点逐个 cordon+drain(并发 2-3 个, 控制爆炸半径)
3) PDB 与容量检查: 滚动期集群容量降 N 分之一(448 题余量)
4) 每批验证: 服务错误率曲线无尖刺(418 题同款验收)再下一批
5) 旧组缩容删除
自动化: 云厂商节点池 API/自研流水线 —— 但第一批永远手动验证
总结:节点维护的标准动作就是“封锁-驱逐-验证-解封”,PDB 是流程里的红绿灯;卡住先看 PDB 与裸 Pod;大规模轮换按批走,拿错误率曲线当验收单。
追问1:cordon 后 Pod 还会重启到该节点吗? → 不会(新调度不来);但已在跑的 Pod 崩溃重启是 kubelet 行为,仍在原节点——cordon 不等于“节点冻结” 追问2:DaemonSet 为什么默认跳过? → 它是节点属性(log/监控),节点维护期恰恰需要它们在场——除非节点要下线 追问3:维护窗口谁说了算? → 变更流程:公告(451 题审计可查)+ 业务确认 + PDB 保障;紧急维护走 break-glass 并事后复盘
五、CI/CD 与交付(462–473)
462. 镜像流水线:从代码合并到生产,一条链路长什么样?
概念 完整交付链:PR(测试+构建)→ merge 到 main(构建镜像→ 扫描+签名 → 推 registry)→ 更新部署仓库的镜像 tag(GitOps 的”发射”动作,464 题)→ 集群侧拉取并滚动(418 题)。关键设计:镜像 tag 语义(可追溯:git sha/版本号,不用 latest)、每一步产物带指纹(镜像 digest、SBOM)、构建一次到处运行(测试环境与生产用同一个 digest)。
典型场景 发布链路散落在三个平台没人说得清;测试与生产的镜像”应该一样但不敢保证”;回滚时找不到当时的镜像。
解决方案 三步:PR 与 main 两级流水线 → 镜像身份设计 → 产物指纹链。
第一步:两级流水线
# 文件: release-ci.yml(main 分支触发)
name: release
on: { push: { branches: [main] } }
jobs:
build-push:
runs-on: ubuntu-latest
permissions: { id-token: write, contents: read } # keyless 签名要 OIDC
steps:
- uses: actions/checkout@v4
- uses: docker/setup-buildx-action@v3 # BuildKit(400 题缓存)
- uses: docker/login-action@v3
with: { registry: harbor.corp.local, username: ${{ secrets.HARBOR_ROBOT } , password: ${{ secrets.HARBOR_TOKEN }} }
- uses: docker/build-push-action@v5
with:
push: true
tags: harbor.corp.local/team/api:${{ github.sha }}
cache-from: type=gha
cache-to: type=gha,mode=max
- run: trivy image --exit-code 1 --severity HIGH,CRITICAL harbor.corp.local/team/api:${{ github.sha }} # 412 题门禁
- run: cosign sign --yes harbor.corp.local/team/api@${{ steps.img.outputs.digest }} # 412 题签名
# PR 流水线(293 题)只测不推 —— 推 registry 是 main 的特权
第二步:镜像身份设计
# 文件: image-tag.txt
tag 规范(可追溯三要素):
harbor.corp.local/team/api:<git-sha-12位> ← 主标识: 提交级追溯(git log 直接对上)
同 digest 再打: :2026-10-17.1 / :semver ← 人读的别名
❌ latest: 不可追溯、不可回滚、缓存陷阱(411 题)
发布引用用 digest 还是 tag? 464 题的部署仓库写 sha tag(人可读)+ CI 保证 tag 不覆盖
(registry 开 immutable tag)—— tag 的信任来自"没人能改它"
第三步:产物指纹链
# 文件: provenance.txt
每次发布留档四件套(审计与回滚的本钱):
1) 镜像 digest
2) git commit sha(tag 已绑定)
3) SBOM(syft 生成入库, 412 题)
4) 流水线 run id(构建日志与环境的快照)
回滚动作因此变成: 找回任意历史指纹 → 按它重发布(469 题) —— 不需要"重新构建当年的代码"
总结:交付链的价值在“每个产物有身份、每次变更有指纹”:PR 测/main 推、镜像用 sha tag 且不可覆盖、扫描签名作为推送后的门禁;GitOps 仓库的更新只是链路的最后一环。
追问1:为什么测试和生产要用同一个 digest? → “测试过的东西就是上线的东西”——测试环境单独 build 一次,验证对象就变了(供应链的基本盘) 追问2:构建缓存跨分支共享吗? → GHA 的 gha 缓存按 scope;自建集群用 BuildKit 远程缓存(470 题之外的可选项,registry 缓存后端)全团队共享 追问3:镜像构建放 PR 还是 main? → PR 只做“能构建”的验证(—push=false 的 build 或 build 到 PR 专属 tag),main 才推正式仓库
463. 部署方式总览:kubectl apply、Helm 与 Kustomize 怎么选?
概念 三种部署形态:裸 YAML + kubectl apply(简单直接,但无模板能力,多环境靠复制文件);Helm(chart 模板 + values 渲染,包管理与依赖,适合第三方应用与复杂参数化);Kustomize(overlay 叠加:base + patch,无模板语言,适合自家应用的 env 差异)。趋势:第三方用 Helm 装,自家应用用 Kustomize 或纯 YAML,GitOps 统一分发(464 题)。
典型场景 团队为“用哪个”吵架;多环境配置三份 YAML 各自漂移;升级第三方 chart 的参数地狱。
解决方案 三步:三种形态对照 → 组合实践 → 反模式。
第一步:三种形态对照
# 文件: deploy-forms.txt
裸 YAML + apply:
✅ 零魔法、diff 友好、学习成本零 ❌ 无参数化: 多环境=复制文件
适合: 单环境小项目、教学
Helm:
✅ 模板{{ .Values.x}}、版本化 release、依赖复用 —— 装第三方(prometheus-stack, 452 题)事实标准
❌ 模板语言复杂、渲染结果不直观、release 状态漂移(手改后 helm diff 一片红)
Kustomize:
✅ base + overlays patch: env 差异显式、无模板、kubectl 原生
❌ 复杂逻辑(循环/条件)表达不了 —— 但这通常是优点(逼你保持简单)
实践主流: 第三方 Helm 装, 自家服务 Kustomize 管环境差异, 都进 git
第二步:组合实践
# 文件: repo-layout.txt
应用仓库(team-api/):
src/… 应用代码
deploy/base/ 基础 manifest(Deployment/Service/Ingress)
deploy/overlays/staging/ staging 的 patch(副本/域名/资源)
deploy/overlays/prod/ 生产 patch
CI 只负责构建镜像(462 题) —— 镜像 tag 的更新由部署仓库/CD 完成
部署仓库(gitops-repo/, 464 题): 环境目录引用 app 仓库的 overlay 或集中放 chart values
第三步:反模式
# 文件: deploy-antipatterns.txt
1) Helm 模板里塞业务逻辑(if 嵌套五层) → chart 没人敢改; 参数收敛+分层 values
2) 环境差异藏在 CI 变量里(kubectl set image --set) → 集群状态与 git 不一致, 464 题 GitOps 失效
3) 同一服务 Helm 与 Kustomize 混管(一半 chart 一半 patch) → 工具统一按团队规范
4) apply -f 指向本地文件上生产 → 集群状态无来源; 一切变更走部署仓库(破窗从这条开始)
总结:部署形态按对象选:第三方用 Helm(生态与参数化)、自家环境差异用 Kustomize(显式 patch)、小项目裸 YAML 起步;真正的纪律只有一条——集群状态的唯一来源是 git。
追问1:helm upgrade —install 和 GitOps 冲突吗? → 冲突:GitOps(ArgoCD)以 git 为准,手工 helm 改动会被“纠偏”回滚——二选一,别混 追问2:Kustomize 的 patch 有哪几种? → strategic-merge(局部改)与 JSON6902(精准路径);新式还有 components(可插拔功能块) 追问3:为什么“集群状态唯一来源是 git”这么重要? → 可审计(451 题)、可回滚(469 题)、可重建(460 题恢复有基准)——git 是这三件事的共同前提
464. GitOps 与 ArgoCD:声明式的发布怎么运作?
概念 GitOps 四原则:git 是唯一事实源、声明式描述、自动同步(控制器把集群拉向 git 状态)、持续校正(漂移自动纠偏或告警)。ArgoCD 是主流实现:Application 对象指向 git 路径与目标集群/namespace,持续 diff 并同步。发布动作 = 改部署仓库(git PR 合并即“发射”),回滚 = git revert——发布的全部历史就是 git 历史。
典型场景 想要“合并即发布”的自动化;集群配置被手改后悄悄漂移;多环境发布流程不透明。
解决方案 三步:ArgoCD Application 起步 → 发布流(PR 即发布)→ 漂移治理与权限。
第一步:ArgoCD Application
# 文件: argocd-app.yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata: { name: api-prod, namespace: argocd }
spec:
project: trade
source:
repoURL: https://git.corp.local/k8s/gitops.git
targetRevision: main
path: env/prod/api # 部署仓库里的路径(463 题布局)
destination: { server: https://k8s.corp.local, namespace: trade }
syncPolicy:
automated: { prune: true, selfHeal: true } # 自动同步+漂移纠偏+删孤儿资源
syncOptions: [CreateNamespace=true]
# 界面三态: Synced(=git)/OutOfSync(git 领先)/Degraded(健康检查失败)
# App-of-apps: 一个"根 Application"管理 N 个 Application —— 环境批量注册的姿势
第二步:发布流(PR 即发布)
# 文件: gitops-flow.txt
发布 = 两步 git 操作:
1) CI 构建镜像(462 题) → 2) 自动 PR: 部署仓库 env/prod/api/kustomization.yaml 的
images: [digest: harbor.corp.local/team/api@sha256:abc...] 更新
合并(或 auto-merge 规则放行)→ ArgoCD 3 分钟内同步 → 集群滚动(418 题)
价值:
发布审计 = git log(谁/何时/什么 sha) —— 451 题审计的应用层闭环
回滚 = git revert 该 PR(469 题的丝滑版)
环境 diff = 部署仓库两个目录的 diff
人工卡点: prod 目录 PR 要审批(282 题灰度纪律的入口); staging 可 auto-merge
第三步:漂移治理与权限
# 文件: drift.txt
漂移 = 集群实际状态 ≠ git(有人手改/控制器自动改了字段)
治理三姿势:
selfHeal: true → 自动纠回 git(适合不被控制器管理的字段)
ignoreDifferences → 声明知难而退的字段(HPA 的 replicas 这类控制器所有的)
漂移告警 → OutOfSync 持续存在 = 有人绕过流程, 推给负责人
权限配套: 集群凭证进 ArgoCD(它有写权限)→ ArgoCD 自身的访问控制 + 442 题约束;
破窗通道(kubectl 应急)要在 runbook 声明 + 事后补 git(461 题精神)
总结:GitOps 把发布变成 git 操作:PR 合并即发布、revert 即回滚、diff 即环境对比;ArgoCD 的 automated+prune+selfHeal 三开关按对象配;漂移不是敌人,没人管的漂移才是。
追问1:镜像 tag 更新的 PR 谁来提? → CI 提(机器人账号);ArgoCD 的 Image Updater 能直接改镜像——但“PR 走仓库”留痕更完整 追问2:ArgoCD 挂了发布会停吗? → 停的是“同步”,不是业务;存量继续跑——GitOps 控制面也是无状态可重建的(415 题思想) 追问3:secrets 怎么进 GitOps? → 仓库里只放 ExternalSecret 声明(422/470 题),密钥真身永不进 git
465. Helm chart 的组织:values 分层与依赖怎么管?
概念 chart 的复用单元:templates(渲染逻辑)+ values(参数)。参数化的工程化 = values 分层(defaults 兜底 → 环境文件覆盖 → 命令行注入,优先级右高);依赖(subchart)是复用第三方能力的机制,umbrella chart 组合多服务。判定一个 chart 健康的指标:参数数量(越少越好)、模板可读性(render 出来是人能看的 YAML)。
典型场景 同一服务多集群参数差异;升级第三方 chart 后参数失效;umbrella chart 越长越乱。
解决方案 三步:values 分层 → 依赖管理 → chart 的质量纪律。
第一步:values 分层
# 文件: chart-values.yaml
# chart 的 values.yaml(默认值, 保守):
replicas: 2
resources: { requests: { cpu: 100m, memory: 128Mi } }
# 环境覆盖 values-prod.yaml(只写差异):
replicas: 6
resources: { requests: { cpu: 500m, memory: 512Mi } }
# 渲染: helm upgrade --install api ./chart -f values-prod.yaml -n trade
# 纪律: 默认值必须"随时可跑且安全"(小规格) —— 大配置只能显式给
# 验证渲染结果(不安装): helm template api ./chart -f values-prod.yaml | less
第二步:依赖管理
# 文件: Chart.yaml
apiVersion: v2
name: data-platform
dependencies:
- name: postgresql
version: 13.2.0
repository: https://charts.bitnami.com/bitnami
- name: redis
version: 18.6.0
repository: https://charts.bitnami.com/bitnami
# 子 chart 参数用前缀覆盖(values.yaml 里 postgresql.xxx / redis.xxx)
# 版本锁: Chart.lock + vendored charts(chart/ 目录提交) —— 可复现构建(293 题同源)
第三步:质量纪律
# 文件: chart-quality.txt
1) 参数收敛: >50 个 value 的 chart 没人理解 —— 分文件(values/resources.yaml)并写注释
2) 模板可读: 渲染结果 review(helm template)是 PR 的一部分; helper 模板收敛重复
3) 升级路径: chart 版本化语义(大改升 minor); prod 升级先 helm diff
(helm-diff 插件: 改动清单一目了然, 464 题 ArgoCD 里也有 diff 视图)
4) 不装不相关的东西: chart 只管"这个应用的 K8s 资产", CRD/集群级资源单独走
5) helm test 定义冒烟(helm test 跑钩子 Pod)—— 发布后自动验证的钩子位
总结:chart 的工程化 = values 分层(默认保守、环境显式)+ 依赖锁版本 + 渲染结果可 review;chart 是“应用的安装包”,参数越少越健康。
追问1:helm get values 和 values 文件不一致说明什么? → 有人 —set 过(绕过 git)——GitOps 环境下这是要复盘的事件(464 题漂移) 追问2:umbrella chart 和 App-of-apps 怎么选? → umbrella 在“必须原子部署一组服务”时用;一般用 ArgoCD 的多 Application(独立发布、故障隔离更好) 追问3:chart 里的 hook 是什么? → 特殊注解的 Job(pre-install 迁移/post-install 校验)——472 题会讲它的适用边界
466. Kustomize:多环境 overlay 怎么组织?
概念 Kustomize 的模型:base(完整的基础 manifest)+ overlay(patch + 额外资源)。patch 两式:strategic merge(贴片段,按字段合并)与 JSON patch(精准路径操作)。无模板语言是刻意设计——环境差异必须是“看得见的 diff”,而不是渲染出来的惊喜。
典型场景 dev/staging/prod 三份配置的漂移治理;环境差异只有副本数和域名;给所有环境统一加一个标签/注解。
解决方案 三步:标准布局 → patch 实战 → 常见组织难题。
第一步:标准布局
# 文件: kustomize-layout.txt
deploy/
base/
kustomization.yaml (resources: [deployment.yaml, service.yaml, ingress.yaml])
deployment.yaml ...
overlays/
staging/
kustomization.yaml (resources: [../../base]; patches: [...])
prod/
kustomize.yaml (+ 副本/资源/域名 patch + image 更新位)
# 渲染检查: kubectl kustomize overlays/prod | less
# ArgoCD 原生支持: source.path 指向 overlay 目录(464 题)
第二步:patch 实战
# 文件: overlays/prod/kustomization.yaml
apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources: [../../base]
namespace: trade-prod
patches:
- path: replica-and-resources.yaml # strategic merge: 副本与资源
images:
- name: harbor.corp.local/team/api # 464 题: CI 只改这里的 digest
newTag: 9f3e2d1c0b7a
replicas: [{ name: api, count: 6 }]
commonLabels: { env: prod } # 全环境差异统一注入(433 题标签纪律)
第三步:常见组织难题
# 文件: kustomize-q.txt
Q: 两个环境差异巨大(不同资源集合)怎么办?
A: base 里只放真正共同的; 环境特有资源放各自 overlay —— 别用 patch 硬掰
Q: 十几个环境都有同一小改(加注解)?
A: components(kustomize component)或中间层 base(base -> mid -> env)
Q: 谁保证 overlay 渲染合法?
A: CI 里 kubectl kustomize + kubeconform/dry-run 校验(293 题门禁的 manifest 版)
Q: secret 呢?
A: overlay 里放 ExternalSecret(470 题) —— Kustomize 不生成密钥, 只引用
总结:Kustomize 的价值是“环境差异 = 可 review 的 patch diff”:base 承载共同真相、overlay 只写差异;无模板的克制让它成为自家应用多环境管理的主流;渲染校验进 CI,渲染结果进 PR。
追问1:kustomize 和 helm 能组合吗? → 能(helm chart 作为 kustomize 的资源/helmCharts 内建),但组合的复杂度要值回票价——通常是“第三方 chart 单独 ArgoCD Application”更清晰 追问2:strategic merge 和 JSON patch 怎么选? → 默认 strategic(可读);要删字段/改列表元素顺序这种精细活用 JSON patch 追问3:namePrefix 有什么用? → 同一集群跑多套同名应用(app-qat- 蓝绿共存的命名隔离,468 题相关)
467. 金丝雀发布:Argo Rollouts 怎么落地?
概念 金丝雀 = 新版本先接小比例真实流量,按指标决定推进/回退。Argo Rollouts 用 Rollout 资源替换 Deployment:steps 定义放量序列(10%→pause→20%→pause…),AnalysisRun 对接 Prometheus 指标做自动门禁(错误率超阈值自动回滚)。与 282 题应用层灰度的区别:这里是流量层按 Pod 权重放量,指标门禁自动化。
典型场景 想要“发版不用半夜盯屏”;新版本 5% 流量试跑 10 分钟自动放行;错误率抬升自动回退。
解决方案 三步:Rollout 骨架 → Analysis 指标门禁 → 流量层配合。
第一步:Rollout 骨架
# 文件: rollout.yaml
apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata: { name: api }
spec:
replicas: 10
strategy:
canary:
canaryService: api-canary # 独立 Service 指向金丝雀 Pod(流量层钩子)
stableService: api-stable
steps:
- setWeight: 10 # 10% 流量到新版本
- pause: { duration: 10m } # 观察窗口
- setWeight: 30
- pause: { duration: 10m }
- setWeight: 60
- pause: {}
maxSurge: 1
maxUnavailable: 0 # 418 题同款容量纪律
selector: { matchLabels: { app: api } }
template: /* 与 Deployment 的 podTemplate 相同 */
第二步:Analysis 指标门禁
# 文件: analysis.yaml
apiVersion: argoproj.io/v1alpha1
kind: AnalysisTemplate
metadata: { name: error-rate }
spec:
metrics:
- name: error-rate
interval: 1m
count: 10
successCondition: result[0] < 0.02 # 错误率 < 2%
failureLimit: 2 # 连续 2 次超标 → 回滚
provider:
prometheus:
address: http://prometheus.observability:9090
query: |
sum(rate(http_requests_total{service="api",version="canary",status=~"5.."}[2m]))
/ sum(rate(http_requests_total{service="api",version="canary"}[2m]))
# 挂进 Rollout: canary.steps 里 analysis 引用 —— 指标自动推进, 超标自动 abort(回滚到 stable)
# 这就是 286/282 题的"发布即实验": 错误率/P99/业务指标都可以当门禁
第三步:流量层配合
# 文件: canary-traffic.txt
流量按权重到金丝雀的两种实现:
1) Service 权重(默认): stable/canary 两个 Service, 按 Pod 数近似权重 —— 朴素但有舍入误差
2) Ingress/网格权重(nginx ingress 或 istio 注解): 真按百分比分流, 精确且支持 header 路由
(420 题的 canary 注解 / istio VirtualService)
选型: 要求"千分之一级精确"或"内部员工先行"用流量层; 一般场景 Service 权重够
观测配套: 指标带 version 标签(453 题), 金丝雀期专看 canary 版本的曲线 —— 没标签就没法对比
总结:金丝雀的工业实现 = Rollout 的 steps(放量节奏)+ Analysis(指标门禁自动推进/回滚)+ 流量层(精确分流可选);发布从“信仰之跃”变成“带刹车的斜坡”。
追问1:pause: {} 无 duration 是什么意思? → 手动确认步:等人工点 promote——关键版本留一道人工闸(282 题渐进与人为判断的平衡) 追问2:abort 之后呢? → 权重归零、金丝雀 Pod 缩掉,流量全回 stable;根因修复走新版本重来(git 历史里能看到这次尝试) 追问3:金丝雀期间数据库不兼容变更怎么办? → 金丝雀挡不住 schema 类不兼容——必须先做向后兼容迁移(472 题),金丝雀只验证行为不验证结构
468. 蓝绿部署:流量一次切换的价值与代价?
概念 蓝绿:两套完整环境(蓝=当前,绿=新版)并存,验证绿后把流量一次性切到绿(Service selector 或网关切权重)。与金丝雀对比:蓝绿是“整体切换+秒回退”,金丝雀是“渐进放量+指标驱动”。代价:双倍资源(切换窗口期)、共享状态类系统(DB)只能一套,蓝绿的“绿”必须兼容同一份数据。
典型场景 需要秒级回退的发布;整环境级变更(基础镜像/运行时升级);流量层不想做细粒度权重时。
解决方案 三步:Service selector 切换实现 → 资源与状态约束 → 与金丝雀的选型。
第一步:Service selector 切换实现
# 文件: blue-green.yaml
# 蓝(当前): Deployment api-blue, label { app: api, slot: blue }
# 绿(新版): Deployment api-green, label { app: api, slot: green }
apiVersion: v1
kind: Service
metadata: { name: api }
spec:
selector: { app: api, slot: blue } # 流量现在指向蓝
# 切换 = 把 selector 的 slot 改成 green(一次 kubectl patch / ArgoCD 同步)
# 回退 = 改回 blue: 秒级, 不重新调度任何 Pod —— 蓝绿的核心价值
# 进阶: 切换前的"绿验证"用 459 题姿势 —— 临时 Service 只给测试流量, 或网关带内测域名指绿
第二步:资源与状态约束
# 文件: bg-constraints.txt
1) 双倍容量窗口: 绿起满副本才切 —— 切换期集群要扛两套(448 题容量余量/432 题配额)
省法: 绿用降配副本(只验证功能)→ 切换前扩满 —— 但扩容也要时间, 权衡切换速度
2) 有状态依赖只有一份: DB/队列蓝绿共用 —— 472 题兼容性是蓝绿的地基
3) 切换后的"蓝保活期": 保留蓝 1-2 小时观察, 之后再缩 —— 真回退窗口就这么长
4) 定时任务/消费者: 蓝绿的消费者会双活消费! 切换顺序: 先切消费者(kafka group 再平衡)
再切 HTTP 流量, 或用 leader 选举保证单活(238 题锁)
第三步:与金丝雀的选型
# 文件: bg-vs-canary.txt
蓝绿: 切换快回退快; 成本双倍; 风险"整包切换"(没放量观察)
金丝雀: 风险渐进可控; 回退要缩掉金丝雀(稍慢); 需要指标门禁建设(467 题)
选型速查:
常规业务迭代 → 金丝雀(默认)
运行时/基础镜像级变更 → 蓝绿(新旧行为差异大, 全量验证更直观)
低频重要发布(大重构) → 蓝绿 + 长保活观察
都要 → Argo Rollouts 的 blueGreen 策略(与 canary 同一套控制器管理)
总结:蓝绿的杠杆是“两套环境换秒级切换与回退”:Service selector/网关是开关,双倍资源与共享数据的兼容性是代价;选型上它是金丝雀的互补面——整包切换的场景用蓝绿,渐进验证用金丝雀。
追问1:切换瞬间在途请求怎么办? → 旧 Pod 优雅停机兜底(417 题):切 selector 后蓝的存量请求做完才退;零中断 = preStop+宽限期+连接排空 追问2:蓝绿期间配置(ConfigMap)怎么管? → 蓝绿各用各的 CM(名字带 slot 后缀)——共享 CM 会让“绿的验证”被蓝污染 追问3:能不能蓝绿数据库? → 能但极少(双写/同步复制成本爆炸);常规是“应用蓝绿 + 数据单套 + 兼容迁移(472 题)”
469. 回滚策略:不可变发布与”可逆性”怎么设计?
概念 回滚的前提是发布物不可变:镜像 digest 不变、配置在 git 有历史、数据库兼容新旧两版——回滚 = 回到旧引用,不重建旧物。三段回滚体系:自动(金丝雀指标 abort,467 题)、半自动(git revert → GitOps 同步)、应急(kubectl rollout undo / Service selector 切回)。设计期要回答:什么能回滚、多快能回滚、什么不能回滚。
典型场景 发布后 30 分钟发现问题;紧急回滚要不要动数据库;回滚后数据怎么办的争论。
解决方案 三步:三段回滚体系 → 不可变性的保障 → 不可回滚清单与设计。
第一步:三段回滚体系
# 文件: rollback-layers.txt
L1 自动(分钟内): 金丝雀 Analysis 超阈值 abort(467 题)—— 无人值守, 覆盖发布窗口期
L2 半自动(3-5 分钟): git revert 发布 PR → ArgoCD 同步(464 题)
—— 一切"代码回滚"的标准路径: 有审计、集群与 git 不脱钩
L3 应急(秒-分钟): kubectl rollout undo deployment/api(418 题)
Service selector 切回蓝(468 题)
—— 绕过 git, 事后必须补 git 同步(resync), 否则漂移埋雷
选择顺序: 能 L1 不 L2, 能 L2 不 L3; L3 是救火, 用完要"还账"
第二步:不可变性的保障
# 文件: immutable.txt
回滚快的三个来源:
1) 镜像不删: registry 保留全历史(411 题 GC 策略留余量) —— "回滚镜像 404"是最蠢的故障
2) 配置在 git: 环境 overlay 的每个历史版本可 checkout(466 题)
3) 集群状态可重建: 460 题备份 + git 基准
演练: 季度"回滚计时"—— 从发现到恢复实测多久, 数字进 runbook(299 题)
第三步:不可回滚清单与设计
# 文件: irreversible.txt
默认不可回滚(要按"前滚修复"设计):
数据库 schema 变更 → 472 题的兼容策略(rename 类操作不可逆)
已发出的外部副作用(支付/短信/邮件) → 幂等与补偿(280 题), 不是回滚能救
用户数据迁移/清洗 → 双向脚本? 不存在的: 变更前备份 + 前滚修复
密钥轮换(283 题双读) → 半可逆: 保留旧钥验证期
设计期的"可逆性评审": 每个 PR 自问 —— 这个变更回滚需要什么? 有没有不可逆动作?
发布 checklist 的固定一项(293 题门禁的发布版)
总结:回滚是设计出来的:不可变的产物(digest/git/备份)+ 三段体系(自动 abort → git revert → 应急命令);数据库与外部副作用属于不可回滚世界,要用兼容迁移与幂等前滚兜住。
追问1:rollout undo 之后 git 里是什么状态? → 部署仓库还是新版本(漂移):必须补 revert 或手动同步——464 题 selfHeal 甚至会把它“纠回新版本”,L3 之后立刻处理 git 追问2:回滚比前滚更安全吗? → 不总是:回滚到旧版可能丢掉热修复/放大 schema 差异;决策树:兼容且快 → 回滚;不兼容 → 前滚修复 追问3:回滚也要演练哪几步? → 触发决策(谁拍板)、执行路径(L1/L2/L3 选型)、事后对账(数据/流量/配置三者一致)
470. external-secrets:密钥怎么从 Vault 流到 Pod?
概念 ESO(External Secrets Operator)的模型:SecretStore(后端连接:Vault/AWS SM)声明”去哪取”,ExternalSecret 声明”取什么映射成什么”——控制器定时 reconcile 把远端密钥同步成集群内原生 Secret(应用无感,仍是 env/volume 注入)。价值:密钥真身只在 Vault(283 题)、git 里只有引用声明、轮换自动跟进。
典型场景 密钥轮换要滚动全部服务;开发把真密钥提交进了 git;多集群密钥分发的管理成本。
解决方案 三步:Store 与 ExternalSecret → 轮换与刷新 → 权限与审计闭环。
第一步:Store 与 ExternalSecret
# 文件: eso.yaml
apiVersion: external-secrets.io/v1beta1
kind: ClusterSecretStore
metadata: { name: vault-backend }
spec:
provider:
vault:
server: https://vault.corp.local
auth:
kubernetes: # 用 K8s SA 到 Vault 的认证(每集群一个角色)
mountPath: kubernetes
role: cluster-prod
---
apiVersion: external-secrets.io/v1beta1
kind: ExternalSecret
metadata: { name: api-db, namespace: trade }
spec:
refreshInterval: 1h # 定期重取: 轮换自动跟进
secretStoreRef: { kind: ClusterSecretStore, name: vault-backend }
target: { name: api-db-secret } # 生成的原生 Secret 名
data:
- secretKey: DATABASE_URL
remoteRef: { key: secret/data/trade/api, property: db_url }
- secretKey: LLM_API_KEY
remoteRef: { key: secret/data/trade/api, property: llm_key }
# 应用照常: envFrom secretRef api-db-secret —— 422 题注入方式零改动
第二步:轮换与刷新
# 文件: eso-rotation.txt
轮换链路: Vault 侧换值 → refreshInterval 到点 → Secret 更新 → 应用感知:
env 注入: 感知不到(启动期快照) → 要滚动: 配 421 题 checksum 模式(ESO 状态变化触发)或 reloader
volume 注入: kubelet 同步文件(约 1min), 应用 watch 文件可热载
动态数据库密钥(283 题Vault 动态凭据): ESO 直接对接 database/creds 类路径,
短 TTL 凭据 + 应用侧连接重建(229 题池的 drain/rebuild) —— 完整闭环
第三步:权限与审计闭环
# 文件: eso-security.txt
1) Vault 侧策略最小化: 每个 ns 的 SA 角色只能读自己路径(trade/*) —— 集群内拿不到别人的
2) 集群侧: ExternalSecret 是普通资源 → RBAC(442 题)控制谁能创建(防止有人引用敏感路径外泄)
3) 审计三链: Vault 审计(谁取过)+ ESO 事件(Secret 同步记录)+ 451 题 K8s audit(Secret 读取)
4) 灾备: Vault sealed/unseal 流程演练 —— ESO 让集群"每小时都依赖 Vault 可用",
Vault 故障 → 存量 Secret 还在(应用不死), 但轮换停摆 —— 监控 ESO 的 Sync 条件
总结:ESO 把密钥管理从“复制粘贴”升级为“引用同步”:真身在 Vault、声明在 git、Pod 看到的还是原生 Secret;轮换由 refreshInterval 自动跟进,应用侧配合滚动或热载;安全边界在 Vault 策略与 RBAC 两层。
追问1:ESO 和 Sealed Secrets 怎么选? → Sealed:密文可以进 git(无外部依赖,单集群);ESO:接 Vault/云 SM(轮换、审计、多集群)——有密钥基础设施就 ESO 追问2:refreshInterval 到了但 Vault 挂了? → Secret 保持旧值(Ready 转 False 告警)——降级可用,修复后自动追上 追问3:怎么防止有人把 ExternalSecret 指到敏感路径? → admission 校验(策略引擎限制 remoteRef 前缀按 ns 隔离)+ Vault 侧策略双保险
471. 多环境晋升:dev → staging → prod 怎么设计?
概念 晋升(promotion)的本质:同一个不可变产物(镜像 digest,462 题)在不同环境的配置层(466 题 overlay)上依次落地。三种模式:同分支多目录(GitOps 主流:部署仓库 env/ 目录)、PR 式晋升(合并 dev 目录 → PR 到 staging → PR 到 prod)、流水线触发式(CD 工具按环境依次调).核心纪律:晋升的是“引用”,不是重新构建;每个环境有自己的验证门禁。
典型场景 staging 验过的和 prod 上线的不一样;环境晋升全靠人肉复制 tag;prod 配置漂移没人发现。
解决方案 三步:目录布局与晋升流 → 各环境的门禁 → 环境隔离配套。
第一步:目录布局与晋升流
# 文件: env-promotion.txt
部署仓库(gitops):
env/dev/api/kustomization.yaml # image: digest@abc...
env/staging/api/kustomization.yaml
env/prod/api/kustomization.yaml
晋升 = 把 dev 验证过的 digest 复制到 staging 目录(PR + merge)
= staging 验证后复制到 prod 目录(PR + 审批 + merge)
CI 只写 dev 目录(机器人); staging/prod 的 PR 人工审批 —— 464 题的分级
工具化: ArgoCD Promotion / Flux 的 image automation / 自研小脚本 —— 本质都是"复制引用"
铁律: 三个目录的 digest 永远相同或 prod 更旧, 绝不能"prod 比 dev 新"
第二步:各环境的门禁
# 文件: env-gates.txt
dev: 自动部署(merge 即发), 冒烟测试(289 题E2E套件)自动跑
staging: 自动部署 + 数据仿真(脱敏数据/影子流量), 完整回归 + 性能基线对比(286 题)
prod: 金丝雀(467 题)+ 指标门禁, 高危变更加人工 pause
环境间验证传递: dev 的测试结论跟随 PR 描述(测试报告链接)—— 晋升 PR 里能看到"它经历过什么"
第三步:环境隔离配套
# 文件: env-isolation.txt
命名空间/集群分层: dev/staging 不同 ns(小团队)或不同集群(合规要求)
配置差异最小化: 只有 overlay 允许的差异(域名/副本/配额) —— 出现逻辑差异 = 环境失真, 要治理
数据策略: staging 用脱敏副本或合成数据(292 题纪律); 绝不直连 prod 库"借用数据"
依赖真实性权衡: staging 用真 SMTP 还是 mock? 原则: 决定发布质量的依赖必须是真的(支付沙箱),
边缘依赖可 mock —— 每条 mock 都是"staging 验证不到的盲区清单"的一行
总结:晋升设计三要素:产物不可变(digest 复制而非重建)、门禁按环境递进(自动→回归→金丝雀)、配置差异收敛在 overlay;“三个环境的 digest 单调性”是流程健康的一眼指标。
追问1:为什么要“晋升”而不是每环境独立构建? → 独立构建=每次都是新产物,staging 的验证作废——供应链一致性的根基(462 题) 追问2:紧急修复(hotfix)怎么走? → 分支从 prod 的 tag 拉 → 构建 → 跳级晋升(直进 prod 的 PR,标注 hotfix + 补回 dev)——流程允许快,但不允许绕过 git 追问3:staging 和 prod 的容量差异导致问题发现不了? → 用 286 题压测补:staging 上做等比缩放的负载测试,容量类问题靠压测不靠碰运气
472. 数据库迁移与部署协同:schema 变更怎么不卡发布?
概念 迁移与发布的解耦原则:schema 变更必须向后兼容(新旧版本代码都能跑在新 schema 上),应用发布与迁移分两步走(扩展现 → 迁移 → 发新代码 → 收缩)。K8s 的标准姿势:迁移作为独立 Job(pre-deploy,465 题的 pre-install hook 或 CI 里的 migrate 步骤),带锁防并发,幂等可重跑。
典型场景 滚动更新时新旧代码同时写同一个表;迁移跑了 10 分钟把发布卡死;回滚代码但 schema 已经改了。
解决方案 三步:兼容性分层 → 执行链路 → 回滚与紧急处理。
第一步:兼容性分层
# 文件: migrate-compat.txt
兼容性四类(按风险排序):
加列(可空/带默认) → 安全: 新旧代码都兼容 —— 常规发布随迁
加索引 → 注意锁(大表 CREATE INDEX 不带 CONCURRENTLY 会锁写)
改列类型/rename → 不兼容! 拆成多版本: 双写期 → 迁数据 → 切读 → 删旧列(每步一个发布)
删列/删表 → 最后一步: 确认旧代码没了再删(等 N 个版本)
铁律: 一次迁移只做兼容的一步; "大爆炸式"重构 schema = 回滚地狱(469 题不可逆清单)
第二步:执行链路
# 文件: migrate-job.yaml(发布前独立 Job)
apiVersion: batch/v1
kind: Job
metadata: { name: api-migrate-1f2a, namespace: trade }
spec:
backoffLimit: 2
activeDeadlineSeconds: 900 # 15min 上限: 防长事务挂死发布
template:
spec:
restartPolicy: Never
containers:
- name: migrate
image: harbor.corp.local/team/api@sha256:abc... # 用"同一个 digest"(462 题)
command: ["node", "dist/migrate.js", "up"]
envFrom: [{ secretRef: { name: api-db-secret } }] # 470 题注入
# 链路: CI 发布序列 = migrate Job(等完成)→ 改部署仓库 digest → ArgoCD 滚动
# 并发防护: 迁移工具的 advisory lock(如 pg_advisory_lock)—— 两个流水线同时迁只有一个能跑
# 幂等: 迁移记录表(version 已应用则跳过)—— Job 重试安全(426 题同源)
第三步:回滚与紧急处理
# 文件: migrate-rollback.txt
回滚语义分层:
迁移失败(Job 挂) → 发布中止, 不动应用 —— 修迁移再走(最常见的"安全失败")
新代码有问题, 回滚应用 → 兼容迁移下旧代码能跑(第一步的设计保证) —— 不回滚 schema
需要真回滚 schema → down 脚本(有则跑); 没有则前滚修复(新迁移纠正) —— 默认心态是前滚
紧急处理: 大表迁移锁库 → pg_stat_activity 看 blocking, 取消会话评估;
预防: 变更评审带"预计行数与锁行为"分析(158 题慢查询治理的同源纪律)
演练: 迁移在生产副本(影子库)先跑一遍计时 —— 超过发布窗口就改造(分批/在线 DDL 工具)
总结:迁移与发布的协同 = 兼容性设计(一步一兼容)+ 执行解耦(migrate Job 先行、锁与幂等)+ 回滚语义明确(应用可回、schema 前滚);大表变更是架构任务不是发布任务。
追问1:为什么迁移用独立 Job 而不是应用启动时自迁? → 启动自迁在多副本下并发打架、慢迁移拖住就绪探针(424 题)——小项目可用,规模化必拆 追问2:双写期的数据一致性怎么保证? → 触发器或应用层双写 + 对账任务(差异报警)——468 题蓝绿、281 题outbox 的同款纪律 追问3:谁能执行生产迁移? → 只有流水线(CI 的 migrate 步骤)—— 人手跑迁移 = 绕过审计(451 题)与版本记录
473. 发布门禁与渐进交付:怎么把 293 题的门禁延伸到部署侧?
概念 渐进交付(Progressive Delivery)= 把 CI 门禁(测试/扫描)延伸到 CD:每一步放量前有指标检查,异常自动刹车。门禁四层:构建门禁(测试/扫描,293/412 题)、部署前门禁(can-i-deploy 契约、迁移成功、容量余量)、运行时门禁(金丝雀 Analysis,467 题)、事后门禁(发布后回归+告警值守)。核心思想:发布不是瞬间动作,是一段带检查点的过程。
典型场景 想把“人工看一眼监控再放行”自动化;发布纪律散落在 wiki;周五发版的恐惧。
解决方案 三步:四层门禁清单 → 自动化落点 → 例外与破窗治理。
第一步:四层门禁清单
# 文件: gates.txt
L1 构建: 单测/覆盖率(293 题)+ 镜像扫描+签名(412 题)+ manifest 校验(kubeconform)
L2 部署前: 契约 can-i-deploy(下游兼容, 291 题 Pact)+ 迁移 Job 成功(472 题)
+ 容量检查(HPA 余量/PDB 额度非零, 439 题)+ 密钥就绪(ESO Synced, 470 题)
L3 运行时: 金丝雀各步的 Analysis(错误率/P99/业务指标, 467 题)+ 手动 pause 点(关键版本)
L4 事后: 发布标记(metadata 注入 version 标签, 453 面板可按版本切片)+ 24h 告警值守窗
+ 发布复盘模板(自动收集: 这次门禁拦过什么/放过了什么)
第二步:自动化落点
# 文件: gates-impl.txt
L1 → CI 的 jobs(GitHub Actions/自建): 不绿不合并, 不绿不推镜像
L2 → 发布流水线的预检步骤(脚本化: kubectl get pdb / velero 备份新鲜度 / pact-broker)
—— 全部脚本化后, "发版前 checklist" 从 wiki 变成代码(293 题精神的 CD 版)
L3 → Argo Rollouts Analysis(467 题): 无人工的自动刹车
L4 → 告警规则带 version 标签 + 值班日历联动(454 题路由)
度量发布健康: 发布成功率/回滚率/门禁拦截数 —— 月度回顾, 门禁太多误伤也要修剪
第三步:例外与破窗治理
# 文件: gates-exception.txt
紧急发布(hotfix): 快车道 = 跳过 L3 的观察期(L1/L2 永不跳) + 事后补复盘(471 题hotfix流程)
破窗(手改集群应急): 允许但留痕 —— 451 题审计 + 事后 resync git(464 题) ——
"破窗"与"流程"的差别只在"事后是否还账"
门禁的敌人是形式主义: 每条门禁要能说出"它拦过什么真实事故"(296 题规则的战绩纪律)
说不出的门禁删掉, 说得出的写进 runbook
总结:渐进交付把发布从“一次跳跃”变成“带刹车的斜坡”:四层门禁各司其职、全部脚本化进流水线与 Rollout;紧急路径允许快但不允许盲;门禁与规则一样,要有战绩、能复盘、可修剪。
追问1:门禁会不会拖慢发布? → 每层门禁的耗时是发布预算的一部分;自动化后多数门禁是秒级检查——真正拖慢发布的从来是“人工确认”,把人的判断固化成指标门禁才是提速 追问2:业务指标能当门禁吗? → 能且应该(转化率/下单量的金丝雀对比);注意统计显著性——流量小时波动大,用更长窗口或加大最小放量 追问3:多服务同时发布怎么协调? → 发布窗口错峰+契约门禁兜底(291 题);一次大促前冻结窗口(除 hotfix 外停发)是运维纪律的经典
六、Linux 与进程基础(474–485)
474. 进程状态与负载:R、S、D 到底什么意思?
概念 进程状态:R(running/runnable,在跑或在等 CPU)、S(interruptible sleep,可中断睡眠:等 IO/事件,信号能唤醒)、D(uninterruptible sleep,不可中断:通常在等磁盘/NFS,kill 不动)、Z(zombie,已死等回收)、T(stopped)。负载(load average)统计 R + D 的进程数——所以”负载高但 CPU 空闲”的元凶常是 D 状态(IO 等待)。
典型场景 load 20 但 CPU 利用率 30%;进程 kill -9 杀不死;容器视角看进程状态(408 题)的宿主侧根因。
解决方案 三步:状态观测 → D 状态案例 → 负载的 правиль解读。
第一步:状态观测
# 文件: proc-state.sh
ps -eo pid,stat,wchan:30,comm --sort=stat | head -20
# STAT 列: R/S/D/Z/T + 附加(s 进程组领导、< 高优先级、N 低优先级、l 多线程)
top 里按 R 与 D 过滤: 按 f 选列, 或:
ps -eo stat,pid,comm | awk '$1 ~ /^D/ {print}' # 抓所有 D 状态
# wchan(内核等待点)是 D 状态的线索: 如 io_schedule / nfs_* → 磁盘或网络存储
第二步:D 状态案例
# 文件: d-state.sh
# 现象: 容器内 ffmpeg 转码任务 kill -9 无效, Pod Terminating 卡住(417 题的对偶面)
ps -eo pid,stat,wchan:30,comm | grep -E "ffmpeg|D"
# 4321 D io_schedule ffmpeg ← 在不可中断的磁盘 IO 里
# 处置:
# 1) 只能等: IO 完成后 D 自动退出, SIGKILL 随即生效
# 2) 治根: 底层存储慢(NFS 超时/磁盘故障) → iostat(478 题)定位
# 3) K8s 侧后果: Pod 卡 Terminating → 宽限期后 kubelet 强删, 节点上进程残留时
# 最终手段重启节点(461 题排空的极端版)
第三步:负载的正确解读
# 文件: load.sh
uptime # load average: 8.2, 7.9, 8.0 (1/5/15min)
# 解读三步:
# 1) 与核数比: 8C 机器 load 8 = 刚好排队 1 个/核; load 4 = 空闲一半
# 2) 拆 R 与 D: vmstat 1 看 r(运行队列)与 b(阻塞队列, D 状态数)
# r 高 → CPU 不够(477 题); b 高 → IO 不够(478 题)
# 3) 趋势: 15min > 1min = 正在缓解; 1min 远高 = 突发
vmstat 1 5
# procs r=9 b=0 → CPU 型负载; r=1 b=12 → IO 型负载(load 高但 CPU 闲)
总结:进程五态里 D 是排障关键词:kill 不动、拖高负载、指向底层 IO;负载要拆 R/D 两个来源(vmstat 的 r/b),CPU 型与 IO 型负载的治理路径完全不同。
追问1:Z 状态在容器里为什么少见? → 容器有 init/reaper 机制(408 题的 tini)或 kubelet 侧回收;宿主上 Z 多 = 父进程没 wait 追问2:S 和 D 的本质区别? → 信号可否中断:S 收 SIGKILL 立即死,D 要等内核操作返回——设计上某些 IO 不允许被打断(数据一致性) 追问3:load 能为 0.x 吗? → 能(空闲);关注的是与核数的比值和趋势,不是绝对值
475. 文件描述符:fd 泄漏怎么发现与根治?
概念 fd 是进程打开文件的句柄(文件/socket/管道/eventfd 都算);每进程默认上限 1024(ulimit -n,容器里可调)。泄漏模式:每次请求打开不关闭(日志文件/DB 连接/socket)。症状链:Too many open files 报错 → 新连接建立失败 → 服务”半死”(存量连接还能跑)。
典型场景 服务跑几天后报 EMFILE;Node 服务日志刷 “too many open files”;容器里的 ulimit 与宿主不一致。
解决方案 三步:泄漏现场 → 计数与归因 → 根治与配置。
第一步:泄漏现场
# 文件: fd-leak.sh
ls /proc/<pid>/fd | wc -l # 当前 fd 数(进程视角)
ls -l /proc/<pid>/fd | awk '{print $NF}' | sed 's/[0-9]*//g' | sort | uniq -c | sort -rn
# 3200 socket:[...] ← socket 没关(连接泄漏/未销毁的流)
# 180 /var/log/app.log ← 每次打开没关闭
# 容器里的进程: docker exec <c> sh -c 'ls /proc/1/fd | wc -l'
# K8s: 先找到 Pod 所在节点与容器 PID(crictl), 再看 /proc/<pid>/fd
第二步:计数与归因
# 文件: fd-track.sh
watch -n5 'ls /proc/<pid>/fd | wc -l' # 压测期间持续涨 = 泄漏(只涨不回落)
# socket 细分: ss -p 2>/dev/null | grep "pid=<pid>" | awk '{print $1}' | sort | uniq -c
# 大量 CLOSE-WAIT → 对端关了你没关(应用没 close: 480 题状态机)
# 大量 ESTAB 到同一 DB → 连接池没上限/泄漏(229 题池治理)
# Node 侧定位: lsof -p <pid> | grep -c node; 配合 214 题指标暴露 process._getActiveHandles
第三步:根治与配置
# 文件: fd-limit.yaml
# 容器的 fd 上限(systemd 单元/containerd 配置, K8s 侧):
spec:
containers:
- name: api
securityContext: {}
# 实际由容器运行时的 LimitNOFILE 决定(containerd 默认 65535; 老 docker 继承 systemd 1024)
# 配置纪律:
# 1) 上限是保险丝不是解药: 调大 1024→65535 争取时间, 泄漏照漏
# 2) 代码根治: 显式 close(fs/promises 的句柄用完关; stream 用完 destroy, 227 题)
# 3) 监控: fd 使用率(ls /proc/N/fd 周期采集)进 452 题栈, 80% 告警
总结:fd 泄漏的经典画像:socket 或日志文件只开不关、计数单调涨、EMFILE 后半死;定位用 /proc/
追问1:EMFILE 和 ENFILE 的区别? → EMFILE 是进程级上限(ulimit -n),ENFILE 是系统级(/proc/sys/fs/file-max)——先撞到的几乎总是前者 追问2:容器的 fd 上限谁说了算? → 容器运行时与 systemd 的 LimitNOFILE;K8s 没有原生字段,平台层统一配置——迁移上 K8s 后“fd 变小了”的经典根因 追问3:accept 风暴与 fd 有什么关系? → 新连接排队占 fd;backlog 满时拒绝——480 题 ss 的 Recv-Q/Send-Q 观察
476. 内存全景:page cache、RSS 与 OOM killer 的宿主视角?
概念 宿主内存三层:page cache(文件缓存,可回收,“免费”的内存)、进程 RSS(真实占用)、swap(禁用为主)。free 的 available 才是可用内存(含可回收 cache)。OOM killer:物理内存+swap 耗尽时内核挑“badness 最大的进程”(OOM score:大内存、root 加权低)杀掉——容器里被 cgroup OOM 先拦(410/456 题),宿主 OOM 是节点级灾难(440 题驱逐的上游)。
典型场景 free 看着没内存了但服务正常(cache);宿主 OOM 杀了关键进程;容器 limit 与宿主余量的账对不上。
解决方案 三步:free 正确读法 → OOM 事后取证 → 宿主与容器的双层账。
第一步:free 正确读法
# 文件: free.sh
free -h
# total used free shared buff/cache available
# 125Gi 80Gi 1.2Gi ... 44Gi 45Gi
# ❌ 看 free: "只剩 1.2G 快炸了" ✅ 看 available: 还有 45G(cache 可回收)
# buff/cache 高是好事: 文件热数据在内存, 内核按需回收(有压力时)
# cache 什么时候有害: 大文件复制后 cache 涨(冷数据), 挤压时可 posix_fadvise/drop_caches
# —— 生产别习惯性 drop_caches(性能自残), 让内核自己管
第二步:OOM 事后取证
# 文件: oom-forensics.sh
dmesg -T | grep -i -A20 "out of memory" # 宿主 OOM 现场
# 关键行: "Killed process 4321 (node) total-vm:..., anon-rss:6.2Gb ..."
# oom_score: cat /proc/<pid>/oom_score # 越大越先死
# 保护关键进程: echo -1000 > /proc/<pid>/oom_score_adj # 免死(SSHD/监控别被杀)
# 容器场景先分层: 是 cgroup OOM(exit 137, 456 题)还是宿主 OOM(dmesg 有记录)?
# 宿主 OOM = 节点超卖失控(440 题)/系统组件吃爆 —— 平台层治理
第三步:宿主与容器的双层账
# 文件: mem-layers.txt
两层限额两层账:
容器层: memory limit(cgroup, 410 题)→ 应用层 OOMKilled
宿主层: 节点容量 - kubelet 预留 - 系统组件 > Σ容器用量
对不上的三种常见原因:
1) page cache 计费: 写文件也计入 cgroup 内存(cache 归 cgroup)→ 容器"没跑啥就吃满"
2) 内核 slab/网络内存: conntrack 表、TCP 缓冲区是内核态, 不在任何容器账里
3) 预留不足: kubelet/kube-proxy 的内存被业务挤(446 题预留纪律)
观测: node_memory_* 与 container_memory_* 的差值 —— 平台层的月度巡检项(448 题)
总结:宿主内存观:available 而非 free、cache 是朋友;OOM 取证靠 dmesg 与 oom_score,先分清 cgroup 还是宿主层;双层账对不上时查 cache 计费、内核态内存与预留不足。
追问1:swap 到底该不该开? → 数据库/K8s 节点普遍禁(延迟抖动换“假活着”);个别场景(突发大内存任务)可开并盯 si/so 指标
追问2:oom_score_adj 怎么用才对? → 只保护“死了就失联”的进程(sshd/监控 agent);业务进程被保护 = 把死亡转嫁给无辜邻居
追问3:RSS 里有别人的内存吗? → 共享库页算进每个进程 RSS(重复计)——进程 RSS 之和大于真实占用;看 PSS(/proc/
477. CPU 排查:上下文切换、运行队列与 steal?
概念 三个关键量:运行队列(r,等 CPU 的进程数)、上下文切换(voluntary 主动让出/ involuntary 被抢占——后者高 = CPU 争抢)、steal(虚拟机被宿主拿走的百分比,云上特有)。工具链:top(CPU 分项 us/sy/wa/st)、vmstat(r/cs)、pidstat(按进程归因)。
典型场景 CPU 100% 但不知道谁吃的;系统 CPU(sy)异常高;云主机性能莫名折扣。
解决方案 三步:top 分项解读 → 切换与队列 → 按进程归因。
第一步:top 分项解读
# 文件: top-cpu.sh
top # %Cpu(s): 78.3 us, 12.1 sy, 0.0 ni, 4.2 id, 3.1 wa, 0.0 hi, 2.3 si, 0.0 st
# us 高: 应用在算(该看看是谁 → 第三步)
# sy 高: 内核在忙(系统调用风暴/锁竞争/fault): strace -c 看调用统计
# wa 高: 在等 IO(478 题)—— CPU"闲着等", 加核没用
# si 高: 软中断(网络包处理): 网卡流量大 → RSS 多队列/绑核
# st 高: 宿主超卖抢走了你的时间片(云上)—— 换机型/提工单, 应用层无解
第二步:切换与队列
# 文件: ctx-switch.sh
vmstat 1 5
# procs r=2(队列) cs=48000/s(切换)
pidstat -w 1 3 | sort -k5 -rn | head # 按 cswch/s 排
# 判读:
# involuntary(cswch 高 + nvcswch 低) → CPU 不够: 加资源或限流(245 题)
# voluntary 高 → IO/锁等待型(等 fd/互斥)—— 不一定是坏事(等网络很正常)
# 队列持续 > 核数 → 调度延迟上升(请求 P99 的系统侧来源, 286 题毛刺排查的一环)
第三步:按进程归因
# 文件: cpu-who.sh
pidstat -u 1 5 | awk '$NF !~ /Command|Average|^$/ && $8+0 > 50 {print}' | head
# 单进程吃满: top -H -p <pid> 看线程(是不是某个工作线程死循环)
# Node 场景衔接: 214 题事件循环延迟高 + 单核打满 = 主线程被同步计算卡(421 题 libuv 池的兄弟问题)
# 火焰图: perf record -F 99 -p <pid> -g -- sleep 10 && perf report(205 题的宿主版工具)
总结:CPU 排查三问:哪段高(us/sy/wa/st 分项)、谁在等(vmstat 的 r/b)、谁在吃(pidstat/top -H);wa 高去查 IO,st 高找云,us 高做归因——分项决定路径。
追问1:nice/priority 能救 CPU 争抢吗? → 能缓解(降优先级让关键进程先跑),但本质是容量问题(286 题);441 题优先级是它的 K8s 版 追问2:多线程应用的 CPU 为什么显示超 100%? → top 默认 IRIX 模式按单核归一;8 核打满显示 800%——看 %Cpu(s) 总分项而不是单进程数字 追问3:容器的 CPU limit 与这里的 sy/wa 有关系吗? → CPU limit 节流表现为”应用感觉 CPU 变少”(410 题),宿主分项照常——排查要分层:先 cgroup 节流指标再宿主分项
478. 磁盘 IO:iostat 怎么读,队列与 Util 的陷阱?
概念 iostat 关键列:%util(设备忙时间比例)、await(平均 IO 延迟 ms)、r/s w/s 与 rMB/s wMB/s(吞吐)、avgqu-sz(队列深度)、aqu-sz。经典陷阱:%util 100% 不等于满(SAT A/NVMe 可并行,忙≠饱和——队列与延迟才是判断依据);await 高 + 队列深 = 真饱和。
典型场景 数据库写延迟抖;iostat util 100% 但加盘没改善;日志盘打满影响数据盘。
解决方案 三步:iostat 解读 → 归因到进程 → 治理路径。
第一步:iostat 解读
# 文件: iostat.sh
iostat -xz 1
# Device r/s w/s rMB/s wMB/s await r_await w_await aqu-sz %util
# nvme0n1 120 3400 2 45 8.5 2.1 9.1 2.8 92.0
# 判读:
# await(尤其 w_await)> 10ms 且 aqu-sz 持续 > 数 = 写饱和(真瓶颈)
# %util 92 但 await 低队列浅 = 设备忙而未饱和(并行能力强)——别急着扩
# r_await 与 w_await 分开看: 读缓存命中与否差异巨大
# 对照应用感受: DB 的 fsync 延迟 ≈ w_await + 队列等待(164 题刷盘敏感点)
第二步:归因到进程
# 文件: io-who.sh
pidstat -d 1 5 | sort -k7 -rn | head # 按 kB_wr/s 排
# 常见元凶:
# 日志洪峰(223 题日志量治理)、DB 全表扫描的读风暴、批量导出(225 题流式导出)
# 检查点/备份任务与业务高峰撞车(调度错峰, 426 题 CronJob 时区与排期)
# 文件级归因(慢在哪): iotop 交互看; 或 fatrace/ebpf(bcc filelife)
第三步:治理路径
# 文件: io-fix.txt
写饱和:
1) 减写: 日志采样/换输出路径(日志盘与数据盘分离)
2) 合并写: 批量刷盘(应用的 write buffering; DB 的 checkpoint 调参)
3) 换介质: SATA → NVMe/本地盘(云盘 IO 性能等级)
读风暴:
1) 缓存: 应用层缓存(251 题思想)/page cache 预热
2) 索引与查询治理(158 题慢查询)
K8s 场景: PVC 的 storageClass IO 等级(444 题参数)、本地盘(亲和绑定)给 DB 类
总结:IO 判断看延迟与队列而不是 %util(并行设备的经典陷阱);归因链:iostat 定设备 → pidstat 定进程 → 日志/DB/任务定责任;治理按“减写、合并、换介质”三步走。
追问1:await 包含队列时间吗? → 包含(从发起到完成的完整时间);r_await/w_await 分开看更有价值 追问2:云盘的 IOPS 限额怎么看? → 云监控的 IOPS/吞吐与 iostat 对照,触顶表现为延迟陡升(令牌桶耗尽)——升等级或本地盘 追问3:fsync 慢的连锁反应? → DB 提交延迟、消息队列持久化延迟(RMQ 磁盘警报)、etcd fsync(446 题集群抖动)——一块慢盘拖三套系统
479. 文件系统:inode 耗尽与”磁盘满”的另类形态?
概念 磁盘满有两种:空间满(df 看 block)与 inode 满(df -i,文件数耗尽——症状是“df 还有空间但创建文件报 No space left”)。容器/节点场景的高发:海量小文件(会话/分片/日志切割)、被删但被进程占用的文件(df 看着满、du 找不到)。
典型场景 服务报 No space left on device 但 df 显示还有 20%;删了大日志 df 没降;inode 用尽。
解决方案 三步:两种满的诊断 → 已删占用的经典坑 → 治理与预防。
第一步:两种满的诊断
# 文件: disk-full.sh
df -h # 空间维度
df -i # inode 维度(文件数)
# inode 满: 找小文件大户
du --inodes -x /var 2>/dev/null | sort -rn | head # 按文件数统计
# 典型: /var/lib/kubelet/pods/... 的日志与 emptyDir、会话文件目录百万级碎文件
# 空间满: du -x / --max-depth=2 | sort -rh | head 逐层下钻
第二步:已删占用的经典坑
# 文件: deleted-file.sh
df -h /var # 90G/100G
du -sh /var # 只找到 30G —— 差的 60G 呢?
lsof +L1 # 列出"已删除但仍被打开"的文件(进程握着 fd, 空间不释放)
# node 4321 3u REG 8,3 61847552 12 /var/log/app.log (deleted)
# 根因: 日志按天切割, 旧文件被 rm 但应用进程还握着 fd 没轮转(rotate 后未 reopen)
# 处置: 重启进程/给应用发"重开日志"信号(copytruncate 的 logrotate 与之等价)
# 预防: 应用侧日志走 stdout(450 题, 运行时自己滚动)—— 容器时代根治这类问题
第三步:治理与预防
# 文件: fs-govern.txt
1) 容器可写层治理: ephemeral-storage 限额(440 题)让乱写的应用显性爆炸而不是拖死节点
2) emptyDir 加 sizeLimit: tmp 场景必须限(445 题)
3) 日志 stdout 化(450 题): 运行时滚动 + 采集, 节点侧 rotation 兜底
4) 监控: 节点 filesystem 分区与 inode 两个使用率都进告警(452 题栈的 node-exporter)
5) 定期巡检: 节点 DiskPressure 的近因分析(440 题)→ 回溯到写入源治理
总结:磁盘满有空间与 inode 两种形态,df -h 与 df -i 配对使用;“df 满而 du 找不到”是已删文件被 fd 占用——容器时代的根治是日志 stdout 化;限额(ephemeral-storage/emptyDir)把乱写变成可控爆炸。
追问1:为什么 rm 大文件后 df 不降? → rm 只删目录项,打开该文件的进程持有 inode,数据块引用计数未归零——空间在进程退出或 close 后才释放 追问2:overlay 层会 double counting 吗? → df 看的是文件系统级;容器层的占用要容器运行时的磁盘用量命令(docker system df/crictl)对照 追问3:节点磁盘满了 K8s 会怎样? → DiskPressure → 驱逐链路(440 题):先 GC 镜像,再驱逐 Pod——所以镜像盘与数据盘分离能少一类连锁
480. ss 与连接状态机:TCP 排查的基本功?
概念 ss(netstat 的继任)看连接四元组与状态机;TCP 关闭握手的状态序列是排障地图:主动关方 FIN_WAIT_1/2 → TIME_WAIT(2MSL,正常大量存在),被动关方 CLOSE_WAIT(等你调 close——堆积 = 应用不关连接)。Recv-Q/Send-Q 是收发缓冲的积压。
典型场景 服务变慢,发现几千条 CLOSE-WAIT;TIME_WAIT 几万个慌不慌;连接数暴涨归因。
解决方案 三步:状态统计 → CLOSE-WAIT 与 TIME_WAIT 的判读 → 积压与重传。
第一步:状态统计
# 文件: ss-stat.sh
ss -s # 总览: ESTAB/CLOSE-WAIT/TIME-WAIT 计数
ss -tan state close-wait | head # 谁堆着 CLOSE-WAIT
ss -tan | awk '{print $1}' | sort | uniq -c | sort -rn # 状态分布
ss -tnp state established '( dport = :5432 )' | wc -l # 到 DB 的连接数(229 题池对账)
第二步:两种”奇怪状态”的判读
# 文件: wait-states.txt
CLOSE-WAIT 堆积(对端发了 FIN, 你没 close):
= 应用层 bug: 忘关 socket/连接池泄漏(475 题fd 的孪生)
→ 归因: ss -p 找进程, 看代码哪里拿了连接不还; 临时重启缓解, 根治在代码
TIME_WAIT 巨量(你主动关的连接在等 2MSL):
= 大多是正常的(短连接高频场景: 每秒新建几千连接)
→ 优化方向: 连接复用(keep-alive 池, 209 题 Agent; 229 题连接池)
→ 调整(慎): tcp_tw_reuse(客户端侧)可以, 端口耗尽时 ip_local_port_range 扩
区分: 哪些端口/目标堆积 —— ss 按对端分组统计
第三步:积压与重传
# 文件: ss-q.sh
ss -tin state established | head -40
# 看: Recv-Q/Send-Q(收发积压字节), retrans(重传), rtt/rttvar(往返延迟)
# Send-Q 持续大: 发得快对端收得慢 → 应用层背压该出场(201 题)/对端卡
# retrans 高: 网络质量(跨区/丢包) —— 与 481 题抓包配合定位
# accept 队列: ss -ltn 的 Recv-Q(监听socket 的 backlog 当前值)与 Send-Q(上限)
# 满了 = 新连接被丢 → 调整应用 backlog(如 Node 的 listen(path, backlog))
总结:TCP 排障基本功:状态机统计定形态、CLOSE-WAT 堆积指向应用不关连接、TIME_WAIT 大多无辜该治连接复用;Recv/Send-Q 与 retrans 把“慢”落到收发两端。
追问1:为什么 TIME_WAIT 是 2MSL? → 保证最后一个 ACK 丢失时可重传、旧连接的报文自然消亡——它是网络健壮性的成本,不是病 追问2:容器里 ss 看到的是谁的连接? → netns 内视角:容器里只看到自己的(409 题);节点全景要 hostNetns 的 ss 或 debug 容器(458 题) 追问3:连接数涨=泄漏吗? → 对照业务量(QPS 与连接的比值)与池上限(229 题):涨得比流量快才是泄漏
481. tcpdump:什么时候抓包、怎么抓才有用?
概念 tcpdump 在网卡层捕获报文(BPF 过滤),是“网络层争议的最终裁决”:DNS 解析对不对、握手是否完成、谁先发的 FIN、重传丢包在哪段。生产用法三纪律:过滤器收窄(全量抓会丢包+拖性能)、限时限量(-c 数量/-G 轮转)、输出写文件用 wireshark 分析。
典型场景 “服务间偶发超时”查不出日志;“连接被重置”谁干的;DNS 有时解析错。
解决方案 三步:常用过滤器 → 三类经典案例 → 生产纪律。
第一步:常用过滤器
# 文件: tcpdump-basic.sh
tcpdump -i any -nn 'host 10.244.1.13 and port 5432' -c 1000 -w db.pcap
# -i any 所有网卡; -nn 不做名字解析(快且准); -w 写文件
# 常用过滤:
# port 53 DNS(430 题排障取证)
# 'host pg and port 5432' 指定两端的流量
# 'tcp[tcpflags] & (tcp-rst|tcp-fin) != 0' 只看 RST/FIN(谁先断的)
# 'tcp port 3000 and greater 1400' 大包(MTU 问题, 429 题)
# 快速看(不写文件): tcpdump -i any -nn port 5432 -A | head # ASCII 内容(仅排障小流量)
第二步:三类经典案例
# 文件: pcap-cases.txt
案例1 "偶发连接重置":
过滤 RST → 看是客户端发还是服务端发:
服务端 RST: 立刻跟应用日志对时间点(accept 队列满/进程重启/探针杀)
中间设备 RST: 云 LB 空闲超时(465 题长连接的常见牺牲品)→ keep-alive 心跳修
案例2 "握手都不通":
SYN 发了没回包 → 路径问题: 逐跳抓(客户端/服务端/网关)
NetworkPolicy 丢包在抓包里表现为"SYN 出去了对端没收到"(443 题策略核对)
案例3 "大请求卡住":
抓到 [TCP Retransmission] 与 "packet size > MSS" → MTU/VXLAN 问题(429 题)
分析工具: wireshark 打开 pcap —— 专家信息(Expert Information)自动标注重传/乱序/RST
第三步:生产纪律
# 文件: tcpdump-discipline.sh
# 1) 限时限量的默认参数:
timeout 60 tcpdump -i any -nn -c 200000 -G 30 -W 2 -w /tmp/trace.pcap '<过滤器>'
# 2) 大流量接口先抽样: 采样过滤 'tcp port 3000 and (tcp[tcpflags] & tcp-syn != 0)' 只抓握手
# 3) ring buffer(-W -C 按大小轮转)常驻抓"偶发问题": 事后能回看最近 5 分钟
# 4) 容器视角: kubectl exec 里有 tcpdump 吗? 没有 → 458 题 debug 容器(共享 netns)
# 5) 敏感注意: pcap 里有明文内容(HTTP header/token) —— 拿出去分析要脱敏审批
总结:tcpdump 是网络争议的终审:过滤器收窄 + 限时限量 + 写文件上 wireshark;RST 归因、握手路径、MTU 三类案例覆盖大部分”玄学网络问题”;容器里用 debug 容器抓,pcap 含敏感数据要当密件处理。
追问1:BPF 过滤和 wireshark 的 display filter 一样吗? → 不一样:BPF 是抓包时内核过滤(性能好、语法简),display 是事后过滤(功能强)——尽量在抓包层收窄 追问2:为什么抓包看到丢包但应用没报错? → TCP 重传自愈了(对应用透明);retrans 计数与业务延迟的相关性才是证据链(480 题) 追问3:eBPF 时代还需要 tcpdump 吗? → 需要:精确报文级取证;eBPF 类工具(带宽/延迟地图)是统计视角,两者互补
482. iptables 与连接跟踪:K8s 网络的宿主地基?
概念 两块基础设施:iptables/netfilter(包过滤与 NAT 的规则引擎——kube-proxy 的 Service 规则就翻译成它,419 题)、conntrack(连接跟踪表:记录每条连接的五元组与状态, NAT 依赖它回程改写)。排障关联:conntrack 表满(新连接被丢,“时好时坏”的元凶)、规则冲突(手动 iptables 与 kube-proxy 打架)。
典型场景 高并发时大量连接失败但 CPU/内存正常;排查发现 conntrack-table-full 日志;自建防火墙规则干扰 Service。
解决方案 三步:conntrack 观测与扩容 → 表满的症状链 → iptables 与 K8s 的相处。
第一步:conntrack 观测与扩容
# 文件: conntrack.sh
cat /proc/sys/net/netfilter/nf_conntrack_count # 当前条目
cat /proc/sys/net/netfilter/nf_conntrack_max # 上限
conntrack -L -s 10.244.1.13 2>/dev/null | head # 按源查(容器 Pod 的连接)
# 表满日志: dmesg | grep "nf_conntrack: table full"
# 扩容(平台层): sysctl net.netfilter.nf_conntrack_max=1048576
# 配套: hashsize(哈希桶)同步调, UDP timeout 调短(短连接 UDP 会堆积条目)
# K8s 高发: NodePort/DNAT 场景每条连接一条表项 —— 大流量节点先撞墙
第二步:表满的症状链
# 文件: ct-symptom.txt
链条: 表满 → 内核丢新建连接的包(SYN 静默丢) → 客户端超时重试 → "时好时坏"
特征:
1) 间歇性失败(表项在过期腾挪)而非全量失败
2) 日志有 table full 报错(或 netstat -s | grep -i conntrack 的 drop 计数)
3) 高并发短连接场景(DNS! 每次解析一条)先中招 —— ndots 优化(430 题)同时缓解这里
治理优先级: 减少连接创建(连接复用, 209/229 题) > 调 timeout > 扩表 —— 与 fd 泄漏同思路
第三步:iptables 与 K8s 的相处
# 文件: iptables-k8s.sh
iptables-save | grep -c KUBE- # kube-proxy 生成的规则量(Service 越多越多)
iptables -L -nv | head # 计数器看规则命中(排障 Service 的数据面)
# 纪律:
# 1) 手动 iptables 规则会挡 kube-proxy 的转发(顺序) —— 节点防火墙用上层管理
# (calico/network policy, 443 题)而不是裸 iptables
# 2) 大集群规则性能: iptables 模式 O(n) → IPVS 模式(419 题的集群侧选型)
# 3) 排障顺序: 457 题链路分段 → 嫌疑到节点数据面时才看这里(iptables 计数器+conntrack)
总结:K8s 网络的宿主地基是 iptables + conntrack:表满是“间歇性连接失败”的高频根因(观测 nf_conntrack_count/max);治理顺序复用优先于扩表;节点上的防火墙需求走网络策略,别和 kube-proxy 抢链。
追问1:conntrack 条目何时老化? → 按 timeout(TCP established 数小时、TIME_WAIT 数十秒、UDP 数十秒)——UDP 风暴场景要调短 追问2:为什么 conntrack 满是丢包而不是拒绝? → 表满后新连接无法跟踪,内核默认 drop(没资源生成 RST)——客户端视角是超时不是 refused 追问3:nftables 会取代 iptables 吗? → 工具链在迁移(iptables-nft 后端),kube-proxy 也有 nftables 模式——心智模型(表/链/NAT)延续,语法在换
483. systemd 与 journalctl:节点服务的”K8s 之外”?
概念 systemd 是节点init(PID 1)与服务管理器(unit 声明依赖/重启/资源);journalctl 是它的结构化日志(二进制 journal,按 unit 查询)。K8s 集群里仍有它的地盘:容器运行时、kubelet、自建 agent(数据库备份脚本/监控探针)——节点层排障绕不开。
典型场景 kubelet 状态异常查日志;节点上的定时脚本(备份)要 systemd 单元化;容器运行时(containerd)排障。
解决方案 三步:journalctl 高频用法 → unit 文件要点 → 与 K8s 的分工。
第一步:journalctl 高频用法
# 文件: journalctl.sh
journalctl -u kubelet -f --since "10 min ago" # 跟踪某 unit 最近日志
journalctl -u containerd --since today | grep -i error
journalctl -k | grep -i oom # 内核日志(476 题OOM取证)
journalctl --disk-usage # journal 占用(磁盘治理一环, 479 题)
# 配置: /etc/systemd/journald.conf 的 SystemMaxUse=500M 限额(journal 涨满磁盘的经典)
第二步:unit 文件要点
# 文件: /etc/systemd/system/db-backup.service
[Unit]
Description=database backup
[Service]
Type=oneshot
ExecStart=/usr/local/bin/db-backup.sh
# 定时: 配套 db-backup.timer(OnCalendar=*-*-* 19:00, Persistent=true 错过补跑)
# 生产要点:
# User=dbbackup(非 root, 414 题纪律的节点版)
# MemoryMax=1G(Cgroup 保护: 备份脚本失控不拖节点, 410 题同源)
# Nice=10 / IOSchedulingClass=idle(让路业务, 478 题错峰)
[Install]
WantedBy=multi-user.target
第三步:与 K8s 的分工
# 文件: host-vs-k8s.txt
留节点的: kubelet/containerd/CNI agent(它们是 K8s 的地基, 不能跑在 K8s 里)、
硬件相关(nvidia 驱动/监控 agent)、以及"集群挂了也要活"的兜底(节点保活脚本)
上 K8s 的: 一切业务与可容器化的任务(备份编排更适合 426 题CronJob+对象存储)
判定: 依赖 K8s API 的任务放 K8s 里(集群挂了它本来也不该跑);
依赖单节点硬件/要在控制面之外存活的, 留 systemd
交接点: systemd 单元日志进 journal, 采集器(fluent-bit)同样能收 —— 450 题链路对节点日志同样适用
总结:节点层的 systemd/journalctl 是 K8s 的“地基排障面”:kubelet/运行时日志、内核消息、节点级守护任务都在这;unit 的资源限制与让路参数是节点版的基础治理;业务能上 K8s 就上,节点只留地基。
追问1:systemd 单元怎么查状态与失败原因? → systemctl status x(最近日志内嵌)/systemctl list-units —failed;journalctl -u x 是完整日志 追问2:Type=oneshot 和 simple 的区别? → oneshot 等 ExecStart 结束才算 unit 启动完成(适合“准备类”任务与依赖串联);simple 立即视为启动 追问3:为什么 kubelet 不能容器化跑? → 它负责起容器(鸡生蛋);kubeadm 用静态 Pod 跑控制面已是极限,kubelet 恒在节点进程层
484. /proc 与 /sys:为什么它是排障的金矿?
概念 /proc(进程与内核的运行时视图:每个 PID 一目录)与 /sys(设备与内核参数)是“一切观测工具的底层数据源”——top/ss/free/iostat 都在读它们。直接读的价值:工具坏了/容器里没装工具时(distroless!403 题)依然能排障;还能看到工具不暴露的细节(进程环境变量、fd 指向、cgroup 限额)。
典型场景 容器里没有任何诊断工具;要确认进程真实的环境变量/启动参数;验证 cgroup 限额与用量。
解决方案 三步:进程档案 → 容器场景的钥匙 → 内核参数。
第一步:进程档案
# 文件: proc-files.sh
cat /proc/<pid>/status # 状态/RSS/线程数/上下文切换(voluntary 与 involuntary, 477 题)
ls -l /proc/<pid>/fd # fd 全景(475 题泄漏定位)
cat /proc/<pid>/cmdline | tr '\0' ' ' # 完整启动参数(环境差异排障: 它到底怎么起的)
cat /proc/<pid>/environ | tr '\0' '\n' # 环境变量(421 题注入的值到底对不对)
cat /proc/<pid>/limits # fd/栈等 ulimit(475 题配错的验证)
cat /proc/<pid>/smaps_rollup # PSS/RSS 内存口径(476 题精确账)
第二步:容器场景的钥匙
# 文件: proc-container.sh
# distroless 容器内, /proc 是永远可用的"只读工具箱":
cat /proc/1/status | grep -i mem # 主进程内存(456 题曲线的现场版)
cat /proc/1/limits | grep files # fd 上限
cat /proc/loadavg # 容器视角的负载(受 cgroup 影响, 对照宿主)
# 宿主 → 容器: 找到容器进程的真实 PID(docker top / crictl inspect)后,
# 一切 /proc/<真实pid>/* 都可看 —— 458 题临时容器的 --target 共享的就是这个视野
# cgroup 验证:
cat /sys/fs/cgroup/.../memory.max # 容器内存 limit(410 题对账)
cat /sys/fs/cgroup/.../cpu.stat # 节流统计(nr_throttled, 410 题P99毛刺证据)
第三步:内核参数
# 文件: sysctl-list.sh
sysctl -a 2>/dev/null | grep -E 'somaxconn|tw_reuse|local_port'
# 高频关联题: net.core.somaxconn(accept 上限, 480 题backlog)、tcp_tw_reuse(480 题)、
# ip_local_port_range(端口耗尽)、net.netfilter.*(482 题conntrack)
# 修改: sysctl -w net.core.somaxconn=4096; 持久化 /etc/sysctl.d/*.conf
# ⚠️ K8s 里 Pod 的 netns 有独立可调参数(每容器一套), 节点级参数影响所有容器 —— 改动走平台变更
总结:/proc 与 /sys 是观测的源头与保底:进程档案(参数/环境/fd/limits)是最硬的事实,容器里没工具时依然可用;cgroup 文件是限额对账的原始凭据;内核参数的调优都要落到这里的读写。
追问1:/proc/
485. USE 方法:系统性性能排查的通用框架?
概念 USE(Utilization/Saturation/Errors):对每个资源查三问——使用率( busy 比例)、饱和度(排队/等待)、错误(计数)。资源清单:CPU/内存/磁盘 IO/网络/连接池/线程池。它给“性能问题排查”提供了不漏项的网格:先列资源,再问三问,按证据下钻(474~484 题的每一题都是网格里的一格)。
典型场景 “系统有点慢”从哪下手;排查漏项导致来回返工;面试考察排查方法论。
解决方案 三步:资源×三问的网格 → 下钻路径 → 实战串题。
第一步:网格
# 文件: use-grid.txt
资源 Utilization Saturation Errors
CPU top 的 us/sy(477) r 队列/上下文切换(477) -
内存 free available(476) swap si/so、OOM(476) OOM 事件(dmesg)
磁盘 IO iostat %util(478) await/aqu-sz(478) dmesg 的介质错误
网络 带宽利用率(ss/ip) 重传/缓冲积压(480) 丢包统计/内核 drop
连接池 活跃比(229) 等待获取数(229) 获取超时
线程/事件循环 CPU 占用(477) 队列深度/延迟(214) 拒绝任务
fd 使用数(475) 接近上限 EMFILE
方法论: 一行一行过, 不凭直觉跳 —— "有点慢"的排查从填表开始
第二步:下钻路径
# 文件: use-drill.txt
饱和度是重点: Util 高不一定是问题(高利用率=健康), Saturation 才是痛苦(排队)
CPU 饱和 → 谁吃: pidstat → top -H → 火焰图(477)
IO 饱和 → 谁 IO: pidstat -d → 文件级 → 场景归因(478)
网络饱和 → 哪条流: ss -ti 的重传/积压 → tcpdump 定段(480/481)
错误的性价比最高: 一个 OOM 日志/丢包计数顶十分钟猜测(476/482)
分层 reminder: 先分层(K8s/容器/cgroup → 宿主 → 应用)再填表 —— cgroup 节流(410)
会被宿主视角的"CPU 正常"掩盖
第三步:实战串题
# 文件: use-case.txt
案例: "API 的 P99 从 200ms 涨到 2s"
1) 应用层: 慢日志/trace(279 题)→ 定位到 DB 查询慢? 还是自己 CPU?
2) 资源网格快扫:
CPU 饱和? vmstat r + cgroup 节流(410/477)→ HPA 扩没扩(435)
IO 饱和? iostat await(478)→ 是 DB 盘还是本机日志盘
网络? 重传(480)→ 跨可用区? MTU?(429/481)
池? DB 连接等待(229)→ 慢查询占连接(235)
3) 变更面: 最近发布/迁移/配置(451 题审计倒查)
方法论的价值: 把"感觉是网络问题"变成"网格逐项排除" —— 证据链完整
总结:USE 是排障的防漏网格:资源逐项、三问(用/饱/错)、饱和优先、错误最值钱;474~484 题是网格各格的深水区,本题给的是使用它们的纪律——先分层,再填表,按证据下钻。
追问1:USE 和 RED/LMNDB 什么关系? → USE 面向“资源”(系统侧),RED 面向“服务”(请求侧)——排障常两套并用:RED 定哪个服务痛,USE 定哪个资源病 追问2:什么时候上全链路压测? → 单机网格找不到瓶颈/要验证容量(286 题)——排查是诊断,压测是体检 追问3:网格里有“无饱和概念”的资源吗? → 内存特殊:不排队,超了就是 OOM(错误即饱和)——这就是 476 题强调 available 与 OOM 取证的原因
七、GPU 与 AI 负载(486–493)
486. GPU 调度:device plugin 与 nvidia.com/gpu 资源模型?
概念 GPU 通过 NVIDIA device plugin 以扩展资源(nvidia.com/gpu)注册进 K8s:节点装驱动 + device plugin DaemonSet → 节点可分配 nvidia.com/gpu: N → Pod 在 resources.limits 里申请 1 → Scheduler 整卡分配。特性与约束:GPU 资源只支持 limits(整数,不可超卖);默认”整卡独占”;时间片共享与 MIG 是例外路径(491 题);驱动在宿主、CUDA 在镜像(版本矩阵要对齐)。
典型场景 推理服务申请不到 GPU;CUDA 版本与驱动不匹配报错;GPU 节点上跑了无 GPU 需求的普通 Pod(被白占)。
解决方案 三步:节点就绪链路 → Pod 申请与排障 → 节点池隔离。
第一步:节点就绪链路
# 文件: gpu-node-ready.sh
# 三层缺一不可:
# 1) 宿主驱动(483 题节点层): nvidia-smi 有输出
# 2) device plugin(DaemonSet, 428 题):
kubectl get nodes -o json | jq '.items[].status.allocatable' | grep nvidia
# "nvidia.com/gpu": "8" ← 注册成功的标志
# 3) 容器运行时支持: nvidia-container-toolkit(runtimeClass 或默认注入)
# 验证 GPU 可用: 起一个 CUDA 探针 Pod(480 题的 GPU 版)
kubectl run gpucheck --rm -it --image=nvidia/cuda:12.4-base-ubuntu22.04 \
--limits nvidia.com/gpu=1 -- nvidia-smi
第二步:Pod 申请与排障
# 文件: gpu-pod.yaml
spec:
nodeSelector: { nvidia.com/gpu.present: "true" } # 438 题污点+容忍配套
tolerations: [{ key: workload, operator: Equal, value: gpu, effect: NoSchedule }]
containers:
- name: vllm
image: harbor.corp.local/ai/vllm:0.6
resources:
limits:
nvidia.com/gpu: 1 # 只能整数; 申请后这卡被本 Pod 独占(默认语义)
cpu: "8"
memory: 32Gi # GPU 侧也要给 CPU/内存(数据预处理在 CPU)
# 文件: gpu-triage.txt
申请不到 GPU 的排查序:
1) 节点没注册: allocatable 无 nvidia.com/gpu → 驱动/plugin 问题(第一步)
2) Pending: describe 看 Events → 整卡被占(GPU 不可超卖, 释放或加节点)
3) 起了就崩: CUDA driver version is insufficient → 驱动与镜像 CUDA 矩阵(第三步)
4) 慢: nvidia-smi 看利用率(487 题容量账)
版本矩阵纪律: 驱动(宿主) ≥ CUDA(镜像)要求; 镜像里固定 CUDA 版本, 平台统一升级驱动
第三步:节点池隔离
# 文件: gpu-pool.txt
GPU 节点池纪律(438 题的实践):
1) 污点 workload=gpu:NoSchedule —— 普通 Pod 上不来(一张卡几十万, 不能被 web 服务白占)
2) GPU Pod 的非 GPU 需求也要声明(CPU 预处理/内存放 KV)—— 否则 GPU 等数据, 卡闲着
3) 节点独占型大模型: 反亲和/独占节点(437 题) —— 通信密集型任务别混部
4) 监控: DCGM exporter(GPU 的 node-exporter)进 452 题栈: 利用率/显存/温度/功耗
总结:GPU 调度链三层就绪(驱动/plugin/runtime),申请是整数整卡;排障按”注册→调度→运行”三段走;节点池隔离保护昂贵资源,DCGM 让 GPU 的账本和 CPU 一样清楚。
追问1:为什么 GPU 只能整卡申请? → 扩展资源的默认语义是”整数设备”(device plugin 模型);分数卡要靠时间片(491 题)或 MIG 硬件切分 追问2:CUDA in docker 的版本怎么选? → 官方镜像按 CUDA 版本+基础发行版命名;驱动的向后兼容(高驱动跑低 CUDA)是常态做法——锁镜像 CUDA,平台控驱动 追问3:GPU Pod 的 restart 会重载模型吗? → 会(模型在容器内/下载缓存):冷启动问题的来源(490 题专门讲)
487. GPU 容量核算:一块卡到底能扛多少并发?
概念 推理容量 = f(模型显存、上下文长度、并发批处理)。三个公式:模型权重显存(参数量 × 精度字节);KV Cache 显存(并发 × 上下文 × 每层系数,404 题原理的工程版);吞吐能力(batch 内并行,TTFT 与 TPOT 的权衡)。单卡并发数 = (总显存 − 权重 − 激活开销) ÷ 单请求 KV 占用——这是 286 题容量规划在 GPU 的算式。
典型场景 “这张卡能扛多少 QPS”;显存 OOM 与并发上限的关系;要不要买更大显存的卡。
解决方案 三步:显存公式 → 并发换算 → 实测校准。
第一步:显存公式
# 文件: vram-math.txt
权重显存: 参数量 × 每参数字节
14B 模型 FP16: 14G × 2 = 28GB
14B 模型 INT4(AWQ/GPTQ): 14G × 0.5 ≈ 7GB + 量化开销
KV Cache(每请求): 2(K/V) × 层数 × 每层 KV 头数 × 头维度 × 序列长 × 精度字节
7B 级模型 FP16、4k 上下文 ≈ 0.5~1GB/请求(粗算, 精确按架构)
预算: 卡显存 80G = 权重(28G) + KV(并发 × 0.8G) + 激活/碎片(~10%)
→ 可承载并发 ≈ (80 - 28 - 8) / 0.8 ≈ 55 路
结论杠杆: 量化降权重(493 题外的主杠杆)、限制上下文、PagedAttention 减碎片(488 题vLLM)
第二步:并发换算
# 文件: qps-math.txt
QPS = 并发路数 ÷ 平均请求驻留时长(Little's Law, 286 题同一条定律)
例: 55 路并发 × 平均生成 15s/请求 → ~3.7 QPS 生成流量
TTFT(首字延迟)与吞吐的取舍: batch 越大吞吐越高, 单请求越慢(排队等凑批)
GPU 利用率形态: 推理是"小 kernel 高频" —— nvidia-smi 利用率 60-80% 可能已是满载
(不是 CPU 那种 100% 才饱和), 配合 488 题引擎指标判断
成本视角: 单卡并发 ÷ 卡价 = 性价比; 量化+大 batch 通常是最便宜的扩容(493 题联动)
第三步:实测校准
# 文件: gpu-bench.txt
压测三件套(286 题方法论的 GPU 版):
1) 负载画像: 真实上下文分布/输出长度(拿生产 trace 采样, 别用"平均 500 token"自欺)
2) 指标: TTFT P95 / TPOT / 吞吐(token/s) / 显存峰值 —— 目标值由产品定
3) 扫描: 并发从 8/16/32... 逐档压 → 找 TTFT 或显存先撞线的档位 = 容量
vLLM 自带 benchmark 脚本; 结果存档进 runbook(299 题), 变更(模型/引擎版本)重测
注意: 压测流量形状决定一切 —— 长 context 场景 KV 是瓶颈, 短输出场景算力是瓶颈
总结:GPU 容量是一道显存算术:权重+KV Cache+开销 ≤ 卡显存,并发决定 KV;吞吐用 Little’s Law 换算;杠杆排序:量化 > 限上下文 > 引擎效率 > 加卡;压测用真实流量画像,指标看 TTFT/TPOT 而不是 GPU 利用率。
追问1:为什么 GPU 利用率不满也可能饱和? → 推理 kernel 小而碎,SM 利用率与“还能不能塞请求”非线性;以引擎指标(队列长度/拒绝)为准 追问2:多卡推理什么时候需要? → 单卡放不下模型(张量并行)或单卡吞吐不够且延迟达标——前者是硬需求,后者先榨批处理 追问3:CPU 推理什么时候是选项? → 小模型(≤3B 量化)+ 低 QPS + 无 GPU 预算;493 题讲混合兜底
488. vLLM 部署:容器化与关键启动参数?
概念 vLLM 是高吞吐推理引擎的代表:PagedAttention(KV 分页管理,消灭显存碎片)、continuous batching(请求动态进出批,吞吐核心)、OpenAI 兼容 API。K8s 部署要点:模型来源(镜像内置/启动下载/PVC 挂载)、关键参数(gpu-memory-utilization/max-model-len/max-num-seqs)、优雅停机(在途生成收尾)。
典型场景 模型加载慢拖累发布与扩容;显存 OOM 或浪费;扩副本时冷启动风暴。
解决方案 三步:部署清单 → 参数调优 → 生命周期(加载与停机)。
第一步:部署清单
# 文件: vllm-deploy.yaml
apiVersion: apps/v1
kind: Deployment
metadata: { name: vllm-qwen }
spec:
replicas: 2
strategy:
rollingUpdate: { maxSurge: 1, maxUnavailable: 0 } # 418 题容量纪律
template:
spec:
nodeSelector: { nvidia.com/gpu.present: "true" }
tolerations: [{ key: workload, operator: Equal, value: gpu, effect: NoSchedule }]
terminationGracePeriodSeconds: 120 # 在途生成收尾+模型不重载快
containers:
- name: vllm
image: harbor.corp.local/ai/vllm-openai:0.6-qwen14b # 模型烘焙进镜像(490 题)
args:
- --model=/models/qwen2.5-14b-instruct
- --gpu-memory-utilization=0.90
- --max-model-len=8192
- --max-num-seqs=64
resources:
limits: { nvidia.com/gpu: 1, cpu: "8", memory: 32Gi }
readinessProbe: # 424 题就绪门禁
httpGet: { path: /health, port: 8000 }
initialDelaySeconds: 60 # 模型加载期
startupProbe:
httpGet: { path: /health, port: 8000 }
failureThreshold: 60 # 最长等 5 分钟加载
第二步:参数调优
# 文件: vllm-args.txt
--gpu-memory-utilization 0.90 给引擎的显存预算(留 10% 给系统/激活)—— 太低浪费, 1.0 会 OOM
--max-model-len 8192 按业务真实上限设(直接决定 KV 预算, 487 题)
--max-num-seqs 64 最大并发路数(排队上限): 超了排队或 429, 显存不够会启动失败
--quantization awq 量化加载(493 题成本杠杆)
--enable-prefix-caching 前缀缓存: 系统 prompt 长且固定的场景免费提速
--swap-space 4 CPU 换出的 KV 余量(避免极端场景直接拒绝)
调参闭环: 改参 → 压测(487 题benchmark)→ TTFT/吞吐/显存峰值三维对比 —— 参数是测出来的
第三步:生命周期
# 文件: vllm-lifecycle.txt
启动: 容器起 → 加载模型(分钟级)→ health 就绪 → 接流量
就绪探针的 initialDelay/failureThreshold 要按加载时长给足(424 题慢启动保护)
停机: SIGTERM → vLLM 停止收新请求, 在途生成尽力完成 → 退出
宽限期(120s)要覆盖最长生成; 上游网关配合摘流(247 题 SSE 网关的同款收尾)
发布策略: maxSurge 1 滚动 —— 新副本先加载完成再切流量(就绪门禁保证)
GPU 紧张时 maxSurge 会等卡: 与 435 题 HPA 的交互要测(扩容潮撞上限)
总结:vLLM 上 K8s 的三件事:模型分发策略定好(490 题)、参数按显存算式与压测调、生命周期照顾慢加载与长生成;就绪探针的耐心(startupProbe)是 GPU 服务与普通服务最大的部署差异。
追问1:PagedAttention 解决什么? → KV 显存的碎片与浪费:按页分配而不是按最大长度预留——同等显存承载更多并发(487 题算式的分母变小) 追问2:vLLM 和 TGI/Triton 怎么选? → vLLM 吞吐与生态(OpenAI 兼容)平衡最好;Triton 多后端/多框架;自研图优化的用 TensorRT-LLM——常规开源模型服务 vLLM 起步 追问3:多副本的模型一致性? → 镜像烘焙模型 = 版本即镜像 tag(462 题同源)——不存在“副本间模型不一样”;下载式部署则要版本锁与校验
489. 推理服务扩缩容:GPU 的 HPA 有什么不同?
概念 GPU 服务扩容的三个特殊点:扩的是“昂贵整数资源”(每副本一张卡,扩容慢——模型加载分钟级);CPU 指标失效(GPU 推理的 CPU 几乎不动);冷启动严重(新副本 5 分钟才就绪)。因此信号选并发/QPS/队列深度,策略要“扩快缩极慢”,并接受扩容延迟——超载期靠排队与限流扛(245/284 题),而不是指望秒级扩容。
典型场景 流量尖峰时推理 P99 飙升;HPA 扩了但新副本 5 分钟后才顶上;GPU 卡预算下的扩容上限设计。
解决方案 三步:信号选择 → 行为策略 → 扛住扩容延迟的手段。
第一步:信号选择
# 文件: gpu-hpa.yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata: { name: vllm-qwen }
spec:
scaleTargetRef: { apiVersion: apps/v1, kind: Deployment, name: vllm-qwen }
minReplicas: 2
maxReplicas: 8 # 487 题压测的卡数上限(预算+容量双约束)
metrics:
- type: Pods # 引擎暴露的并发指标(vLLM 的 /metrics)
pods:
metric: { name: vllm_num_requests_running }
target: { type: AverageValue, averageValue: "45" } # 每副本 45 路在跑(容量 55 留余量)
- type: External # 队列积压(网关侧排队, 245 题限流的排队器)
external:
metric: { name: llm_queue_depth }
target: { type: AverageValue, averageValue: "20" }
# 为什么不用 CPU: 推理时 CPU 做 tokenize/调度, 利用率与负载弱相关 —— 435 题的信号纪律在 GPU 更硬
第二步:行为策略
# 文件: gpu-hpa-behavior.yaml
spec:
behavior:
scaleUp:
stabilizationWindowSeconds: 60 # 尖峰确认 1 分钟再扩(GPU 贵, 防过扩)
policies: [{ type: Pods, value: 2, periodSeconds: 120 }] # 每 2 分钟最多 +2 副本
scaleDown:
stabilizationWindowSeconds: 1800 # 缩容观察 30 分钟: 模型加载贵, 缩了再扩血亏
policies: [{ type: Pods, value: 1, periodSeconds: 600 }]
# 扩容时长账: 决策(1-2min)+调度等卡+加载(2-5min)≈ 8 分钟 —— 这是"扩容延迟"的真实数字
第三步:扛住扩容延迟的手段
# 文件: burst-absorb.txt
扩容延迟期的三道缓冲(按序生效):
1) 排队: 网关侧请求队列(有界)—— 用户看到"稍慢"而不是失败
2) 限流降级: 超过阈值返回 429+Retry-After(245 题), 保守并发保 TTFT(487 题batch取↙)
3) 缓冲副本: 定时预扩(日历型流量: 早晚高峰前 Cron 扩, KEDA cron 源)—— 已知模式别赌 HPA 反应
观测: 扩容延迟内的拒绝率/排队时长是 SLO 的一部分(286 题错误预算把这段计入)
对照: 467 题金丝雀期 GPU 版本发布更要慢 —— 每次放量都伴随副本滚动(加载窗口叠加)
总结:GPU 扩缩容的心智:信号用并发/队列而非 CPU、扩快缩极慢、扩容延迟按分钟计;超载期的体验靠排队+限流+预扩三道缓冲,而不是幻想秒级弹性;max 副本 = 压测容量与卡预算的交点。
追问1:为什么缩容要 30 分钟窗口? → 缩容省的是“闲置卡的分钟”,代价是“再加载的分钟+显存拷贝”:不对称的成本要让不对称的策略匹配 追问2:KEDA 的 cron 源怎么用? → 定时预扩(min 副本按时刻表变化),流量模式固定的场景比指标驱动更稳 追问3:能按 token 用量计费信号扩吗? → 可以(business metric):按预算而非负载扩——成本导向的弹性,与 286 题配额联动
490. 模型加载与冷启动:几分钟的启动怎么优化?
概念 冷启动三段:镜像拉取(模型在镜像里则 GB 级拉取)、模型加载(权重读入显存+初始化)、引擎预热(first token 前 JIT/编译)。优化路径按成本排序:模型与运行时分离(PVC/对象存储挂载 vs 烘焙镜像)、加载加速(页面缓存/量化减小体积)、避免不必要的重载(副本不重建就不冷)。
典型场景 每次发布等 5 分钟;HPA 扩容的副本全部要加载;镜像仓库带宽被模型打爆。
解决方案 三步:模型分发三策略 → 加载加速 → 避免重载的设计。
第一步:模型分发三策略
# 文件: model-dist.txt
A 镜像烘焙(默认, 中小模型):
模型进镜像层 → 411 题分层缓存: 版本=镜像, 一致性最强
代价: 镜像 15-30GB, 拉取慢(预热/P2P 分发缓解, 411 题)
B PVC 挂载(大模型/多副本):
模型放 PVC(RWX 共享存储或每节点缓存) → 副本秒挂载
代价: 读共享存储也慢(EFS 类); 常配节点本地缓存(hostPath+初始化 Job 预热)
C 启动下载(HF hub / S3):
启动时拉到本地 emptyDir/缓存卷 → 灵活(模型与镜像解耦)
代价: 启动最慢 + 版本漂移风险(必须锁 revision 哈希)
经验: <10B 模型用 A(简单可靠); 大模型/频繁换模型用 B+C 缓存卷
第二步:加载加速
# 文件: load-speed.txt
1) 量化加载: AWQ/GPTQ 的权重小一半以上 —— 加载 IO 与显存双降(487 题公式)
2) page cache 复用: 同节点重复加载(重建 Pod)命中宿主 cache —— 镜像烘焙+节点亲和的组合拳
3) vLLM --load-format 可选 safetensors 多线程/mmap: IO 并行
4) 镜像层按权重单独分层: 配置变更不重拉权重层(400 题分层纪律的模型版)
5) 预热请求: 就绪后先打几条合成请求(触发 JIT/编译), 再进负载均衡 —— 避免"首个用户买单"
第三步:避免重载的设计
# 文件: no-reload.txt
副本不重建 = 不冷启动, 工程上少折腾发布:
1) 配置与模型解耦: 调 prompt/参数走配置中心, 不滚动推理集群
2) 模型版本切换用双 Deployment 蓝绿(468 题): 新版本加载完成后切流, 旧版本保温
3) 优雅停机宽限期足够: 正常滚动不杀加载中的副本(maxUnavailable: 0, 418 题)
4) 常驻最低副本: minReplicas ≥ 2 —— 夜间缩 0 的 GPU 服务, 早上第一波用户就是冷启动受害者
总结:冷启动优化先分诊三段(拉取/加载/预热)再对症:分发策略按模型规模选、量化与缓存加速加载、蓝绿切换与配置解耦让“发版不重载”;预热请求把 JIT 成本从用户手里买回来。
追问1:镜像 30GB 会超 Docker hub 限制吗? → 私有 Harbor 无此限制;注意 registry 存储与 GC 策略(411 题),按 digest 保留历史版本(469 题回滚) 追问2:RWX 共享存储放模型为什么慢? → 网络文件系统的吞吐/延迟远逊本地盘:大权重顺序读是 IO 密集;常见折衷是“共享存储 + 节点本地缓存副本” 追问3:多模型怎么办(一个服务多个模型)? → 每模型独立 Deployment(独立扩缩, 489 题)+ 网关路由(369 题思想);单副本堆多模型会互相抢显存
491. GPU 共享与分片:时间片、MIG 怎么选?
概念 整卡独占之外的两种共享:时间片(驱动层轮转,如 NVIDIA time-slicing:多 Pod 共享一张卡,按时间片轮,隔离弱——一方可拖慢另一方、显存仍共享);MIG(硬件级切分:一张卡切成多个隔离实例,各自显存/SM 独立,隔离强但切分固定、小模型才划算)。选型:强隔离/多租户 → MIG;同团队小任务提高利用率 → 时间片;大模型 → 整卡。
典型场景 小模型任务只用到 10% 显存,一卡一任务太浪费;多个实验任务要隔离;M1/M2 小实例怎么规划。
解决方案 三步:两种机制对照 → 配置方法 → 选型决策。
第一步:两种机制对照
# 文件: gpu-share.txt
时间片 MIG
切分层级 驱动调度(软) 硬件分区(硬)
显存 共享(互踩风险) 各实例独立配额
故障/性能隔离 弱(一拖全慢) 强(独立 SM/缓存)
粒度 按比例 固定档(1g.10gb/2g.20gb...)
适用 同信任小任务 多租户/关键小模型
代价 隔离差 灵活性差+重建分区的服务中断
对照 CPU 世界: 时间片 ≈ 共享 CPU 的"超卖"; MIG ≈ 绑核+cgroup 独立配额
第二步:配置方法
# 文件: mig-config.yaml
# MIG: 节点上切分(平台操作或 GPU operator 编排)
# nvidia-smi mig -cgi 9,9,9 -C # A100 切 3 个 1g.10gb 实例
# device plugin 以 mig 实例注册: nvidia.com/gpu 变成 3 个可分配设备
spec:
containers:
- name: small-model
resources:
limits: { nvidia.com/gpu: 1 } # 拿到的是一个 MIG 实例(1g.10gb), 不是整卡
# 时间片: device plugin 配置(共享模式), Pod 照常 limits: nvidia.com/gpu: 1
# ⚠️ 时间片模式下 limits 声称 1 卡但实际共享 —— 账本(423 题)要按共享口径记, 防超卖事故
第三步:选型决策
# 文件: share-decision.txt
决策树:
模型显存 > 半卡 → 整卡(共享没意义)
多租户/不可信任务 → MIG(隔离是硬需求)
同团队小模型集群(意图分类/嵌入/小 rerank) → 时间片提高利用率, 接受互相影响
想要"细粒度+强隔离"都要 → 等/买新硬件(vGPU 商业方案/新一代 MIG 粒度)
工程提醒:
1) MIG 分区变更是节点级维护(461 题排空)—— 分区规划一次到位少折腾
2) 时间片集群的容量核算按"整卡吞吐"算(487 题), 不是设备数
3) 监控: DCGM 的 per-instance 视角(MIG)/整卡视角(时间片)—— 告警语义别弄混
总结:GPU 共享两路:时间片是“软共享”(利用率优先、隔离让位),MIG 是“硬切分”(隔离优先、灵活让位);选型按信任边界与模型规模;无论哪路,容量账本与监控口径都要跟着切分语义走。
追问1:时间片会带来什么尾部问题? → 上下文切换开销+排队:TTFT 抖动——对延迟敏感的在线服务慎用,离线/小任务场景无感 追问2:MIG 实例能跑 CUDA 任意版本吗? → 可以(切分对上层透明);但单实例显存上限固定,超了就上不去——按模型选档位 追问3:vGPU 和 MIG 的区别? → vGPU 是虚拟化层切分(厂商授权、可迁移),MIG 是物理切分(免费、固定);K8s 自建平台 MIG 更常见
492. 训练任务:分布式 Job 与断点续训怎么跑?
概念 训练负载与推理相反:长时间(小时~天)、要断点(checkpoint)、通信密集(多卡 AllReduce)。K8s 形态:Job(单机)或 MPIJob/PyTorchJob(Kubeflow 训练 operator:多机编排);断点续训 = checkpoint 存共享存储 + 重启从最新点恢复;容错 = 挂了重跑(Job 重试)但要接得住断点,否则白烧卡。
典型场景 微调任务跑 8 小时节点挂了全部重来;多机训练的 gang scheduling(一半起了一半没起,等着干耗);checkpoint 写太勤拖慢训练。
解决方案 三步:训练 Job 形态 → checkpoint 策略 → 调度与容错。
第一步:训练 Job 形态
# 文件: train-job.yaml(PyTorchJob 示意)
apiVersion: kubeflow.org/v1
kind: PyTorchJob
metadata: { name: sft-qwen-14b }
spec:
runPolicy: { cleanPodPolicy: Running, backoffLimit: 2 }
pytorchReplicaSpecs:
Master:
replicas: 1
template:
spec:
restartPolicy: OnFailure
containers:
- name: pytorch
image: harbor.corp.local/ai/train:2.3
command: ["torchrun", "train_sft.py", "--resume=auto"]
resources: { limits: { nvidia.com/gpu: 8, cpu: "48", memory: 200Gi } }
volumeMounts: [{ name: ckpt, mountPath: /ckpt }]
volumes: [{ name: ckpt, persistentVolumeClaim: { claimName: train-ckpt } }]
Worker:
replicas: 3 # 4 机 32 卡
template: /* 同 Master */
第二步:checkpoint 策略
# 文件: ckpt.txt
1) 位置: 共享 PVC(训练专属 StorageClass)或对象存储(S3, 大模型常态)
2) 频率: 按 step/时间(如每 30min)—— 太勤拖速度(IO), 太疏重算多(崩溃损失=间隔×速度)
3) 原子性: 先写临时目录再 rename(半截 checkpoint 是毒药); 保留 N 份滚动
4) resume 语义: --resume=auto 找最新完整点; 数据加载器要能跳过已训样本(dataloader 的 resume)
5) 断点的内容不止权重: 优化器状态/数据进度/超参 —— 少一样都算"假断点"
对账: 训练 loss 曲线接续(接不上的台阶 = 断点丢东西), 曲线进 452 题看板
第三步:调度与容错
# 文件: gang.txt
gang scheduling(组调度): 多机任务"全起或全不起"
问题: 32 卡任务起了 24 卡, 剩 8 卡等节点 —— 起来的 24 卡空烧通信等待
解法: 调度器插件(Volcano/Kueue): 资源够一次性分配, 不够整体排队
容错分级:
弹性训练(torch elastic): 挂一台降世界大小继续 —— 工程复杂, 大厂自研路线
重启续训(默认): 挂了 Job 重试 → --resume 从 checkpoint 继续 —— 依赖第二步做扎实
云 spot 跑训练: 便宜但会断 —— checkpoint 策略 + 容错是前提, 否则省的钱全交了学费
观测: 训练 Dashboard(loss/吞吐/GPU 利用率) + 完成通知(告警通道复用, 454 题)
总结:训练上 K8s 的三件套:operator 编排多机、checkpoint 驱动的断点续训(原子写+全量状态)、组调度防“半启动空烧”;容错路线默认“重启续训”,弹性训练是进阶。
追问1:训练和推理能混部一个 GPU 池吗? → 能但要用优先级+调度隔离(441 题:训练低优可抢,推理高优);MIG/时间片也能物理分开——池化策略是 GPU 平台的核心设计 追问2:checkpoint 太大(百 GB)怎么办? → 异步 checkpoint(后台线程写不阻塞训练)+ 压缩 + 对象存储直写;或 sharded checkpoint 分卡并行写 追问3:数据集怎么给训练 Pod? → 共享 PVC/对象存储流式读取(lazy load);数据预处理做成独立流水线(426 题 Job),训练 Pod 只读成品
493. CPU 推理兜底与混合部署:没有 GPU 时怎么办?
概念 CPU 推理的合理位:小模型(≤1-3B 量化)、低 QPS 场景、兜底容量(GPU 池故障时的降级路径)、边缘部署。混合部署架构:GPU 池为主力(高吞吐),CPU 池为兜底与小模型专区;网关按“模型→池”路由,超载与故障时按降级矩阵切流(284 题思想)。
典型场景 GPU 池故障或预算不足;小模型任务没必要上卡;想要“GPU 挂了服务不死”的韧性。
解决方案 三步:CPU 推理的边界实测 → 混合架构 → 降级演练。
第一步:CPU 推理的边界实测
# 文件: cpu-infer.txt
能力边界(经验值, 以实测为准):
1-3B 量化模型(INT4): 单路生成可用(TPOT 数十 ms 级), 并发路数有限(CPU 核数/批)
嵌入/重排类小模型: CPU 表现良好(批量吞吐可观) —— RAG 管道的 embedding 常驻 CPU 是合理选择
7B+: CPU 只适合"演示", 生产 TTFT 不可接受
工程要点:
1) 推理引擎的 CPU 后端(llama.cpp/ONNX Runtime): 量化+线程绑核, 性能差异数倍
2) K8s 侧就是普通无状态 Deployment: 资源是 cpu/mem(便宜可超卖), 全套 435 题弹性可用
3) 实测口径与 487 题相同: TTFT/TPOT/并发 —— CPU 的"每核吞吐"是新的容量单位
第二步:混合架构
# 文件: hybrid-arch.txt
┌─ GPU 池(vLLM): 主力模型, 高吞吐, 488/489 题全套
LLM 网关(369 题) ──┤
├─ CPU 池(onnx/llama.cpp): 小模型专区(分类/嵌入), 兜底容量
└─ 外部 API(283 题密钥): 突发溢出/私有化前的过渡
路由规则(网关配置):
按模型名路由: qwen-14b → GPU; bge-embed → CPU;
按水位路由: GPU 池排队超阈值 → 小模型请求溢出到 CPU 池(仅同构可替代时)
按故障路由: GPU 池熔断(284 题) → 降级到 CPU 上的小模型 + 功能降级提示
第三步:降级演练
# 文件: degrade-drill.txt
降级矩阵(写进 runbook, 299 题演练场):
场景 D-GPU1: 单 GPU 节点故障 → 调度重排+扩容延迟期, 网关排队+限流(489 题三道缓冲)
场景 D-GPU2: GPU 池整体故障(驱动升级翻车) → 核心小模型切 CPU 池, 大模型功能降级(明确话术)
场景 D-MIX: CPU 池同时高载 → 限流阈值联动收紧(286 题水位分级)
演练产出: 每个"池故障"的实际 RTO + 用户感知(降级文案/恢复切换) —— 每季度一次
配置事实: 降级路径的开关与路由是网关配置(282 题开关体系), 演练拨的就是它们
总结:CPU 推理不是“低配替代”而是架构角色:小模型专区、兜底容量、边缘方案;混合架构的路由与降级在网关层统一设计;GPU 依赖的韧性靠“CPU 兜底+功能降级”买回来,且必须演练过才算数。
追问1:embedding 服务放 CPU 还是 GPU? → 常驻 CPU(批量吞吐好、成本低),高峰溢出 GPU——嵌入与生成的资源画像不同,分池各自弹性 追问2:降级时用户怎么感知? → 诚实降级(可用小模型回答/提示稍后再试)好过硬扛超时;284 题的原则:明示降级比假装正常可信 追问3:CPU 推理的 K8s 配置有特别的吗? → CPU 亲和/绑核(独占核 Guaranteed+静态 CPU 管理器)、NUMA 感知——把 CPU 当“第一种 GPU”认真调度
八、综合上云场景(494–499)
本章是全库的收官:把 400–493 题拆散的知识拼回完整系统。每题按”清单 + 决策点 + 验收”组织——综合题考的不是背清单,是在约束下做取舍。
494. 场景一:Nest API + PG + Redis 的完整上云清单?
概念 最典型的三件套上云:API(无状态 Deployment)、PG(外置托管或 operator)、Redis(集群内或托管)。考察点:每层选 K8s 内还是外(445 题决策)、无状态化的前置体检(434 题)、交付链(462-464 题)与运行时保障(探针/资源/观测)的一张总清单。
典型场景 团队第一个服务上集群;评审别人的上云方案;查漏补缺自家存量服务。
解决方案 三步:分层清单 → 关键决策点 → 上云验收单。
第一步:分层清单
# 文件: cloud-checklist.txt
【应用层 api】
镜像: 多阶段+非 root+stdout 日志(401/414/450 题)
workload: Deployment(2+ 副本)+ 反亲和软打散(437 题)
配置: ConfigMap overlay 差异 + ExternalSecret(421/470 题)
生命周期: 探针三件套(424)+ preStop+宽限期(417/239 题)
资源: request 按压测, 内存 limit 锁死(423 题)
【数据层 pg】
首选云托管(445 题四问); 自管走 CloudNativePG(备份/轮换/HA)
连接: ExternalName/内网 endpoint 服务化(430 题), 池参数对齐(229 题)
【缓存层 redis】
单实例 StatefulSet+PVC 或托管; 订阅连接独立(229 题)
【接入层】
Service+Ingress+证书 cert-manager(419/420 题)
【交付层】
镜像流水线(462)+ 部署仓库 GitOps(464)+ 环境晋升(471)
【运维层】
指标接入(452/453)+ 日志采集(450)+ 告警路由(454)+ runbook(299)
第二步:关键决策点
# 文件: cloud-decisions.txt
决策一: PG 放哪? 团队无 DBA → 托管; 强合规 → 私有化 operator(445 题)
决策二: 副本数与 HPA? 起步 2 副本固定; 流量成型后接 435 题指标弹性
决策三: 环境数量? dev/staging/prod 三套起步, 命名空间隔离(432 题)
决策四: 变更窗口? 全链路 GitOps 化(464), 应急通道与破窗规则写进 runbook
成本视角: 托管 DB 的许可费 vs 自管的人力成本 —— 第一次上云默认"买"(445 题)
第三步:上云验收单
# 文件: cloud-accept.sh
# 功能: 冒烟(289 题E2E)+ 业务关键路径手工三点
# 弹性: HPA 扩缩一轮(435); 节点 drain 演练(461)—— 副本搬家业务无感
# 韧性: kill 一个 Pod(自愈计时)/ 滚动发布看错误率曲线(418)/ 断 DB 看熔断(284)
# 观测: 指标/日志/trace 三支柱在 Grafana 一屏可见(452/453/279)
# 回退: 整套回滚演练(469)—— 从镜像到配置
# 以上全绿才算"上云完成"; 清单存 runbook, 每季复跑(299 题)
总结:三件套上云是全库知识的目录页:应用层照无状态纪律、数据层按运维能力外置或 operator、交付与运维两条线并行铺设;验收单驱动——所有题目最终都要落到“可演练的通过标准”。
追问1:先上应用还是先建平台设施? → 最小可用:观测+GitOps 先行(没这两样,上云=盲飞),再迁应用,数据层最后 追问2:存量服务怎么排期? → 按“无状态化难度”排队:纯 API 先行、本地文件居中、DB 强绑定最后——每批带上 468 题蓝绿切换 追问3:上云后谁值班? → 告警分级与 runbook 先于服务上线(454/299 题)——“上线了没人管”是最常见的失败模式
495. 场景二:RAG 服务的上云:向量库、embedding 与管道?
概念 RAG 上云的三个特殊件:向量库(有状态:Milvus/Qdrant/PGVector,选型与部署形态)、embedding 服务(CPU 池优先,493 题)、离线管道(文档解析/切分/入库的批处理,426 题 Job)。链路特征:离线管道吞吐型 + 在线检索延迟型,两类负载要分开编排;知识库更新的增量管道靠事件驱动。
典型场景 知识库服务从单机迁集群;离线管道和在线服务抢资源;向量库选型纠结。
解决方案 三步:架构分层 → 向量库部署形态 → 管道编排与触发。
第一步:架构分层
# 文件: rag-arch.txt
【在线链路】(延迟敏感)
api(Nest, 244 题检索接口) → embedding(CPU 池, 493 题) → 向量库(检索) → rerank(CPU/GPU)
→ LLM 生成(GPU 池/外部 API, 488 题)
【离线管道】(吞吐型)
事件源(文档上传 224 题 S3 事件/定时全量) → 解析+切分 Job(426 题) → embedding 批量 Job
→ 向量库写入 → 索引版本切换
【共享件】
对象存储(原始文档+解析产物)/ 消息队列(增量事件)/ 配置与密钥(470 题)
资源画像差异是在线 435 题弹性 vs 离线按队列深度扩(KEDA), 分池部署
第二步:向量库部署形态
# 文件: vector-db.txt
PGVector: 数据本来就在 PG → 中小规模(百万级向量)最省心的选择; 备份/运维复用 PG 那套
Milvus/Qdrant(专用): 亿级/过滤复杂/性能要求高; 有状态组件多(依赖 etcd/对象存储)
→ Helm/operator 部署(463/445 题), 生产前把 445 题四问过一遍
云托管向量服务: 省运维, 数据出境合规要先审(04 的 367 题)
指标接入: 检索延迟/QPS/索引大小进 452 题栈 —— 慢查询(向量库版)也要治理
容量: 向量数 × 维度 × 精度 = 索引内存(487 题同款算术), HNSW 参数与召回率的权衡要评测集驱动(04 批 RAG 章同源)
第三步:管道编排与触发
# 文件: rag-pipeline.yaml(CronJob + 事件双触发示意)
apiVersion: batch/v1
kind: CronJob
metadata: { name: rag-reindex-daily }
spec:
schedule: "0 19 * * *" # 每日全量对账(430 题时区)
concurrencyPolicy: Forbid
jobTemplate:
spec:
backoffLimit: 2
activeDeadlineSeconds: 14400
template:
spec:
restartPolicy: OnFailure
containers:
- name: reindex
image: harbor.corp.local/ai/rag-pipeline:1.0.0
# 内部: hash 对账(变更文档才重算, 277 题幂等) → 切分 → embed(批量) → upsert
# 增量触发: S3 事件 → 队列 → KEDA 按深度扩的消费者(426/435 题组合)
# 全量对账兜底增量丢失 —— 台账思想(277 题)的管道版
总结:RAG 上云按“在线延迟型/离线吞吐型”两套编排:在线走 435 题弹性,离线走 Job+队列深度扩;向量库按规模与团队能力选 PGVector→专用库→托管;管道幂等+全量对账兜底,索引切换平滑。
追问1:embedding 池和 LLM 池能合并吗? → 小规模可以(时间片/分时复用,491 题);规模大了分池——资源画像与故障域都不同 追问2:知识库更新用户多久可见? → 增量管道分钟级、全量对账日级;产品话术按增量承诺——评测集里加“时效性用例”(04 批评测章) 追问3:检索慢先查什么? → 向量库指标(过滤比例/召回扫描量)→ embedding 批量排队(离线挤占在线?)→ 网络(同池部署,491 题亲和)—— USE 网格(485 题)逐格过
496. 场景三:LLM 推理服务上 GPU 节点池的完整设计?
概念 把 486–493 题串成一个决策流:节点池(GPU 池规格与隔离)→ 部署(模型分发与参数)→ 容量(显存算式与压测)→ 弹性(并发信号与冷启动)→ 韧性(降级与兜底)。输出物是一份“推理平台上云设计文档”的骨架。
典型场景 公司第一次自建推理平台;面试系统设计题“设计一个 LLM 推理服务”;容量与预算答辩。
解决方案 三步:节点池与部署 → 容量与弹性 → 韧性与成本。
第一步:节点池与部署
# 文件: llm-design-1.txt
节点池:
规格: 按模型选显存(487 题公式反推): 14B FP16 → 24G+ 卡; 70B 量化 → 80G 或多卡并行
数量: min 2 节点(故障域), 弹性上限按预算
隔离: 污点 workload=gpu + 普通池互斥(438/486 题)
驱动与运行时: 平台统一(NVIDIA GPU operator 管理), 版本矩阵公告
部署:
中小模型镜像烘焙(490 题A); 大模型 PVC+节点缓存(490 题B)
vLLM 参数按容量算式初设, 压测校准(488 题)
探针: startup 给足加载期, readiness 带模型 warmup(424/490 题)
第二步:容量与弹性
# 文件: llm-design-2.txt
容量账(487 题): 每卡并发 = (卡显存-权重-开销)/单请求KV; QPS = 并发/驻留时长
压测定档: 真实流量画像 → TTFT/TPOT 达标的最大并发 = 单副本容量
弹性(489 题): 信号 = 引擎并发 + 网关队列深度; 扩快缩慢; 扩容延迟 8 分钟计入 SLA
预扩: 日历型流量 Cron 预热副本(已知模式不赌反应)
预算形态: 峰值副本数 × 卡价 = 平台成本; 利用率与 SLO 的权衡表进设计文档(286 题视角)
第三步:韧性与成本
# 文件: llm-design-3.txt
韧性(493 题):
降级矩阵: GPU 池故障 → CPU 池小模型兜底 + 功能降级话术; 外部 API 作三级兜底(密钥 470 题)
单点检查: minReplicas ≥ 2、反亲和跨节点(437)、PDB(439)
成本杠杆(优先级): 量化 > 批处理参数 > 前缀缓存 > 混部(训练填谷, 492 题池化) > 换卡
观测: DCGM(GPU)+引擎指标(队列/KV)+业务指标(token 成本)三合一看板(452/453 题)
验收: 487 题压测报告 + 493 题降级演练记录 + 490 题冷启动计时 —— 三份附件齐了再上线
总结:推理平台设计 = 五个已答题目的串联:池(486)→部署(488/490)→容量(487)→弹性(489)→韧性(493);文档的三份硬附件(压测/演练/计时)是设计可信度的来源——面试里说得出的数字都该有出处。
追问1:多模型多租户怎么排优先级? → 每模型独立 Deployment(490 题追问)+网关配额(245 题维度);卡不够时按业务线权重排队——平台的产品化议题 追问2:要不要直接用外部 API 省事? → 起步阶段大概率“是”(成本拐点在 QPS 与合规,384/286 题决策);自建的前提是利用率算得过来 追问3:灰度新模型版本怎么做? → 双 Deployment 蓝绿(468/490 题)+ 网关按用户 hash 分流(282 题)+ 评测集回归(04 批)——三件缺一不可
497. 场景四:多团队共享集群的多租户治理怎么设计?
概念 共享集群的治理四层:命名空间与配额(432 题组织)、权限(RBAC 442 题)、网络隔离(443 题)、调度隔离(优先级 441 题与节点池 438 题)——再加成本分摊(label 计账)与”公平性”机制(配额 = 谈判的结果)。目标:团队自治(自己发布)与平台兜底(谁也搞不死谁)并存。
典型场景 三个团队共用一个集群互相埋怨;平台组被“帮我提权/加配额”工单淹没;某团队的任务拖垮全集群。
解决方案 三步:治理分层 → 自助化边界 → 成本与公平。
第一步:治理分层
# 文件: mt-gov.txt
层1 组织: <team>-<env> 命名空间 + ResourceQuota/LimitRange(432 题)
层2 权限: 团队 admin 只在自己 ns; 平台组独有集群级; CI 用机器人 SA(442 题)
层3 网络: 敏感 ns 默认拒绝 + 白名单(443 题); 共享服务(向量库/网关)显式放行
层4 调度: 在线高优/离线低优(441 题); GPU/大内存专用池污点隔离(438 题)
层5 准入: PSS 基线 + 镜像签名校验(447/412 题)—— 谁也塞不进危险负载
层6 观测: ns 维度的用量/成本看板(453 题 label)—— 治理要有账本
第二步:自助化边界
# 文件: mt-selfservice.txt
自助(团队自己 PR):
自己 ns 的 Deployment/ConfigMap/ExternalSecret 引用(464 题GitOps, ArgoCD 项目按 ns 授权)
HPA/扩缩自己的副本(配额内)
平台审批(工单/流程):
配额变更(432 题Quota 调整——谈判资源, 不是技术动作)
新节点池/集群级资源/特权例外(447 题豁免)
禁止(默认拒绝):
跨 ns 写、集群级 RBAC、privileged —— admission 与 RBAC 双保险
自助化的意义: 平台组的工单量是治理成功度的反指标
第三步:成本与公平
# 文件: mt-cost.txt
成本分摊: ns/团队 label 贯穿(433 题)→ 用量 × 单价 = 账单; GPU 按卡时、存储按 GB 月
展示"你的团队花了多少"月报 —— 成本意识是配额谈判的数据基础
公平性机制:
配额 = 保底; 空闲资源允许 burst(LimitRange 上限约束)—— 各团队高峰错峰的利用率红利
离线任务跑 spot/低优(441 题): 共享集群的"填谷者"
滥用治理: 用量异常(ns 突涨)→ 自动告警给 owner —— 451 题审计 + 453 题指标的联动
总结:多租户治理是六层防线(组织/权限/网络/调度/准入/观测)加一本账:团队自助的边界画得越清楚,平台越省心;配额是谈判工具不是技术参数,成本分摊给它提供弹药。
追问1:什么时候拆多集群? → 合规要求(数据物理隔离)、故障域要求(一个集群炸不全炸)、版本节奏差异——先用尽单集群的隔离手段(443/447 题)再拆 追问2:共享服务(向量库/网关)怎么管? → 平台组 owns,团队只读访问(网络白名单+配额);或商业化内部产品(计费/SLA)——治理与产品的边界 追问3:团队绕过流程怎么办? → 技术上 admission 挡(想做也做不了);流程上审计+周报(做了会看见);文化上把自助做得比绕过更顺手(最有效的防线)
498. 场景五:大促容量保障:从压测到扩容的全链路?
概念 大促保障 = 平时容量工程(286/435/448 题)的一次“考试编排”:容量推算(压测定单副本上限 → 乘副本与冗余)、预案分层(水位分级响应)、扩容路径(预扩为主+弹性兜底)、数据与依赖侧容量(DB/网关/GPU 池一个不能漏)。时间线倒排是组织关键。
典型场景 大促/新品发布/热点事件前的一周;容量评审会;保障期间的值班指挥。
解决方案 三步:容量推算 → 预案分层 → 保障时间线。
第一步:容量推算
# 文件: promo-capacity.txt
1) 流量预估: 业务侧给峰值(QPS/用户数)× 不确定系数(2x 起步)
2) 单副本容量: 压测报告(286/487 题)—— 注意流量形状要像大促(读多写少? 长文本?)
3) 副本数 = 峰值/单副本 × 冗余(1.5: 挂一台+滚动余量+突发)
4) 全链路账: 应用副本 → DB(连接数/QPS/存储) → 缓存(命中率假设变化) → 网关(带宽/CPU)
→ GPU 池(若是 AI 大促: 487 题并发账) → 第三方配额(限流提前申请!)
5) HPA 上限对齐: maxReplicas ≥ 计划副本 × 1.2(435 题)—— 弹性是余量不是主力
第二步:预案分层
# 文件: promo-plan.txt
水位分级(286 题预案的实例化):
70%: 观察(值班盯盘: 453 题看板+告警安静度)
85%: 限流收紧(245 题非核心配额砍半)、异步化(写转队列 277 题削峰)
95%: 功能降级(284 题清单: 推荐/评价/大模型长回复降档)
100%: 排队+兜底页; 数据层最后一道: 读写分离引流、批量任务全停
指挥链: 值班群 → 指挥(谁有权按下降级按钮)→ 各域 owner —— 名单与电话写进 runbook(299 题)
第三步:保障时间线
# 文件: promo-timeline.txt
T-14天: 容量评审(上两步产出)+ 依赖方对齐(云配额/第三方限流提升)
T-7天: 全链路压测(生产影子流量或等比环境)→ 差距修复(扩容/慢查询/参数)
T-3天: 预扩到位(HPA min 抬高/手动扩容)+ 冻结发布(473 题冻结窗, hotflow 除外)
T-1天: 演练(299 题: 主备切换/降级开关拨动/告警触发)+ 值班排期确认
T-0: 盯盘节奏(15min 巡检表)+ 按水位行动; 变更一律走应急通道并广播
T+1: 复盘(容量误差/预案命中率/成本)→ 回补日常容量基线(436 题推荐值修正)
总结:大促保障是容量工程的编排考试:推算要有压测出处、预案要分级可执行、时间线要倒排到人;弹性是余量、预扩是主力、第三方配额是最容易被忘的坑;复盘的产出回补日常基线,才算螺旋上升。
追问1:压测怎么做才不像自欺? → 生产影子回放/同规格环境+真实数据量级(286 题提醒)+全链路(不是只压 web 层);压测报告要有“没测到什么”一节 追问2:大促期间出 bug 怎么办? → 冻结窗内 hotfix 走快车道(471 题:跳观察期不跳门禁)+ 指挥批准;回滚优先于修复(469 题决策树) 追问3:成本怎么不失控? → 预扩资源标记(可回收清单: T+1 缩回);spot 填谷(441 题);复盘里成本单列——“为峰值付的钱买到了什么”要能回答
499. 场景六:P0 故障的完整演练:从告警到复盘?
概念 收官题:一次 P0(核心服务不可用)的全流程演练,串起全库的“运行时”知识:告警触发(454)→ 定位(485 题网格+455/456/457 题分诊)→ 决策(止血 vs 根治,469 题)→ 恢复验证 → 复盘(299 题模板)。演练的价值:让流程在人身上跑通,而不是纸面存在。
典型场景 季度故障演练的脚本设计;面试考察“你处理过什么故障”的结构化表达;新值班的岗前训练。
解决方案 三步:演练脚本 → 评分点 → 常见失败模式。
第一步:演练脚本
# 文件: p0-drill.txt
注入(演习导演组密设, 值班不知情):
场景: "DB 主库连接数打满 → API 全线 5xx"(依赖侧故障的经典)
注入: 限流注入(Chaos Mesh network delay / 连接占满脚本)
时间线:
T0 注入故障
T+x 告警触发(454 题路由到值班)—— 计时: 检测延迟(有没有靠用户先发现? 451 题盲区)
T+y 值班定位: 告警 runbook 链接(299 题)→ 457 题排障树 → DB 指标确认
T+z 决策: 血 stop 优先 —— 切只读副本/限流(245 题)/回滚最近变更(451 题审计倒查)
T+r 恢复: 5xx 归零 + 核心链路冒烟(494 题验收单)
T+2h 复盘会(299 题模板)
第二步:评分点
# 文件: p0-score.txt
硬指标(计时):
检测时间(MTTD): 告警比用户快吗
恢复时间(MTTR): 从注入到归零 —— 对照 SLO 预算(286 题)
软指标(行为):
值班是否按 runbook 走(而不是自由发挥)
止血决策是否果断(止血与根治分离, 469 题)
沟通是否到位(状态播报节奏/升级路径触发)
产出: 每次演练的 MTTD/MTTR 曲线 + runbook 修订清单 + 新盲区转告警(451 题)
第三步:常见失败模式
# 文件: p0-fail.txt
1) 告警没触发或没人认领(454 题路由/升级链断)
2) 定位跑偏: 在应用层翻日志一小时, 实际是依赖故障 —— USE 网格(485 题)逐层排除的价值
3) 优先根治不先止血: "我找到 root cause 了"和"服务恢复了"的顺序错误
4) 恢复不验证: 流量回来一半就宣布胜利(灰度恢复+冒烟)
5) 复盘变追责: blameless 缺失 → 下次人人藏着掖着(299 题文化纪律)
6) 演练后不还账: 修订项没进 runbook/代码 —— 下次同样卡壳(行动项跟踪)
总结:P0 演练是全库知识的综合考核:检测靠告警体系、定位靠排障方法论、决策靠止血优先、恢复靠验收清单、进步靠 blameless 复盘;演练的终极产出不是“这次成功”,是下次的 MTTD/MTTR 更短。
追问1:怎么让演练不变成表演? → 注入保密(导演组与值班分离)+ 随机时段 + 真实渠道(值班电话真响);复盘只评流程不评人 追问2:什么故障不该演练? → 爆炸半径不可控的(数据删除类)——用降级环境/只读演练替代(299 题爆炸半径纪律) 追问3:全库学完的动作清单? → 把 494 题上云验收单与本题演练脚本的交集跑一遍:你的服务经得起哪一问,哪里就是下一步的学习清单
第五批完:Docker 基础与镜像 15 题(400–414)+ K8s 核心对象 20 题(415–434)+ K8s 进阶与稳定性 15 题(435–449)+ 可观测与运维 12 题(450–461)+ CI/CD 与交付 12 题(462–473)+ Linux 与进程基础 12 题(474–485)+ GPU 与 AI 负载 8 题(486–493)+ 综合上云场景 6 题(494–499),共 100 题,题号 400–499。跨批次引用:1–99 → 第一批(前端/网络/性能),100–199 → 第二批(Python/FastAPI/后端),200–299 → 第三批(Node/NestJS),300–399 → 第四批(AI 深度工程)。