负载 · XB 现场笔记

DaemonSet 在每个合格节点各起一个 Pod

Mon, 29 Mar 2027 00:00:00 +0000

Deployment 主要表达副本总数，DaemonSet 主要表达合格节点的覆盖范围，适合节点日志采集、网络代理和设备插件。新节点符合条件后会触发协调工作，不代表服务立刻运行或就绪。节点选择、调度容量、镜像拉取、初始化和节点故障，都可能延迟真正有用的覆盖；这些环节需要分别观察。

控制器根据共享模板创建并协调 Pod，通常以每个合格节点一个受管理 Pod 为期望，而不是依赖手工维护副本总数。期望覆盖与实际就绪是两种指标。还应独立定义运维希望覆盖的节点集合，避免选择器写错后，被排除的机器同时从期望数和审计视野中消失。

每节点一个、天生如此

控制器评估节点选择器与必要亲和条件，为每个合格节点创建定向 Pod，通常再由调度器绑定。节点加入和离开会改变期望集合。DaemonSet Pod 自动容忍 unschedulable 污点，因此只执行 cordon 不会排除它们。节点注册并不保证调度、镜像获取和初始化在同一时刻完成，也不保证每台机器已经具备可用日志采集能力。

优先级可以帮助重要守护进程抢占低优先级工作负载，却不会创造容量或消除冲突的放置条件。应按真实重要性和业务影响选择 PriorityClass 与资源请求。Pod 可能一直 Pending，也可能调度后启动失败；高优先级和容忍都不能证明已经就绪，更不意味着免受节点压力驱逐。

覆盖优先于数量

RollingUpdate 会按策略替换 Pod；OnDelete 则等待旧 Pod 被删除后，才使用更新模板创建替代者。maxSurge 为零时，maxUnavailable 为一允许某个节点在更新期间暂时不可用，并不保证每节点不断档。非零 maxSurge 可以让同一节点暂时同时运行新旧 Pod，需要额外资源。更新期间存在版本差异是正常现象，阻塞会使差异持续。kubectl rollout status ds/agent 报告控制器进度，不能证明日志交付连续。

选择器与亲和可以把异构节点分成有意定义的子集，GPU 设备插件与边缘日志转发器不一定使用同一个 DaemonSet。检查各子集真正应该包含哪些节点，区分有意排除与预期代理缺席。跨池比较前还要确认标签来源可靠，不能把一个看起来合理的标签直接当成硬件或运行能力证明。

跟着节点生命周期走

控制器会自动添加文档规定的容忍，包括 not-ready、unreachable、若干压力污点及 unschedulable。控制平面或硬件自定义污点仍可能需要显式容忍。容忍只是允许跨过匹配污点，不会主动选择节点，也不保证满足其他约束。标签变化可能改变成员集合；应观察实际协调结果，不能假定不同守护集合之间是原子交接。

普通 kubectl drain 遇到 DaemonSet 管理的 Pod 时会拒绝继续，除非指定 –ignore-daemonsets；这个选项跳过它们，不负责删除它们。因此 cordon、drain 与停止节点守护服务是不同动作。实际删除 Pod、节点关闭或其他受支持维护路径，仍需要合理终止宽限与信号处理，并验证具体生命周期流程。新节点池交付时，先把独立定义的预期节点身份与实际受管理 Pod 对照，再检查调度事件和就绪状态。不能一看到数量分叉就直接补容忍，因为资源、镜像、启动失败也可能造成缺口；盲目扩大容忍范围还可能让代理进入原本不应覆盖的节点。守护镜像先在明确限定的节点池灰度，验证真实采集与恢复行为后再扩大。保留可用旧版本和对应配置，回滚操作也需要观察结果，不能把提交回滚请求等同于所有节点已经恢复。

灰度期间检查新旧 Pod 的节点身份、就绪与版本，确认日志连续性及 CPU、内存变化。发现异常先停止扩大范围并排查。旧镜像和配置保留多久，应依据恢复要求、镜像供应与变更政策，而不是把固定一周当成通用规则。

坏掉的样子

新污点节点池可能被整体排除，此时 desiredNumberScheduled 仍然等于 numberReady。这些字段描述控制器认为应该覆盖的集合，不代表运维原本希望覆盖的全部机器，也不是按池分组的计数。应比较预期节点、选择器、污点、所有者 UID、就绪与版本；缺口需要结合事件才能判断具体原因。

坏版本可能让多个节点失去可观测性。应选择合适的不可用与增量预算，先验证选择器限定的灰度池，再扩大更新。保留能实际取得的旧镜像和配置，确认回滚最终收敛。命令返回成功不能补回已经丢失的日志，也不能保证旧版本仍然能够启动。

DaemonSet 覆盖审计：机制与证据边界。

快速验证

使用 Bash、Python 3，并明确设置获准查询的 CONTEXT、NAMESPACE 与 DAEMONSET。INTENDED_NODES 指向独立维护的 JSON 对象，键是预期节点名，值是对应 UID；不能从本 DaemonSet 的选择器反推该名单，否则选错节点仍可能自证成功。下面读取 JSON 字段，不再依赖表头、位置列或管道计数：

(
set -euo pipefail
: "${CONTEXT:?Set the authorized kubectl context}"
: "${NAMESPACE:?Set the DaemonSet namespace}"
: "${DAEMONSET:?Set the DaemonSet name}"
: "${INTENDED_NODES:?Set the independent node-name to UID JSON file}"
umask 077
tmp=$(mktemp -d)
trap 'rm -rf -- "$tmp"' EXIT
k=(kubectl --context "$CONTEXT" --request-timeout=15s)
"${k[@]}" -n "$NAMESPACE" get ds "$DAEMONSET" -o json > "$tmp/before.json"
"${k[@]}" get nodes -o json > "$tmp/nodes.json"
"${k[@]}" -n "$NAMESPACE" get pods -o json > "$tmp/pods.json"
"${k[@]}" -n "$NAMESPACE" get ds "$DAEMONSET" -o json > "$tmp/after.json"
python3 - "$tmp" "$INTENDED_NODES" "$NAMESPACE" "$DAEMONSET" <<'PY'
import collections, json, pathlib, sys
root, roster, namespace, name = sys.argv[1:]
def require(ok, message):
 if not ok:
 raise SystemExit(message)
def unique(pairs):
 result = {}
 for key, value in pairs:
 require(key not in result, "Duplicate JSON key")
 result[key] = value
 return result
def load(path):
 return json.loads(pathlib.Path(path).read_text(), object_pairs_hook=unique)
def ready(obj):
 return any(c.get("type") == "Ready" and c.get("status") == "True"
 for c in obj.get("status", {}).get("conditions", []))
a, b = (load(pathlib.Path(root) / (x + ".json")) for x in ("before", "after"))
for ds in (a, b):
 require(ds["kind"] == "DaemonSet" and ds["apiVersion"] == "apps/v1",
 "Wrong resource type")
 require(ds["metadata"]["namespace"] == namespace and
 ds["metadata"]["name"] == name, "Wrong DaemonSet identity")
 require(ds["metadata"].get("uid") and not ds["metadata"].get("deletionTimestamp"),
 "Missing UID or deleting DaemonSet")
require(all(a["metadata"][k] == b["metadata"][k] for k in ("uid", "generation")),
 "DaemonSet changed during collection; retry")
uid = a["metadata"]["uid"]
expected = load(roster)
require(isinstance(expected, dict) and expected and
 all(isinstance(k, str) and k and isinstance(v, str) and v
 for k, v in expected.items()), "Use a nonempty node-name to UID map")
node_items = load(pathlib.Path(root) / "nodes.json")["items"]
nodes = {n["metadata"]["name"]: n for n in node_items}
require(len(nodes) == len(node_items), "Duplicate node names")
wrong_nodes = sorted(n for n in expected if n not in nodes or
 nodes[n]["metadata"]["uid"] != expected[n])
unready_nodes = sorted(n for n in expected if n in nodes and not ready(nodes[n]))
rows, seen = [], set()
for pod in load(pathlib.Path(root) / "pods.json")["items"]:
 m = pod["metadata"]
 require(m["namespace"] == namespace, "Wrong Pod namespace")
 if not any(o.get("controller") is True and o.get("uid") == uid and
 o.get("kind") == "DaemonSet" and o.get("apiVersion") == "apps/v1"
 and o.get("name") == name for o in m.get("ownerReferences", [])):
 continue
 require(m.get("uid") and m["uid"] not in seen, "Missing or duplicate Pod UID")
 seen.add(m["uid"])
 node = pod["spec"].get("nodeName", "")
 phase = pod.get("status", {}).get("phase", "Unknown")
 terminating = bool(m.get("deletionTimestamp"))
 rows.append(dict(pod=m["name"], uid=m["uid"], node=node, phase=phase,
 ready=ready(pod) and phase == "Running" and not terminating,
 terminating=terminating,
 revision=m.get("labels", {}).get("controller-revision-hash")))
counts = collections.Counter(r["node"] for r in rows if r["node"])
ready_nodes = {r["node"] for r in rows if r["ready"] and r["node"]}
issues = dict(node_identity_mismatch=wrong_nodes, node_not_ready=unready_nodes,
 missing_ready=sorted(set(expected) - ready_nodes),
 unexpected_owned_nodes=sorted(set(counts) - set(expected)),
 multiple_pods=sorted(n for n, count in counts.items() if count > 1),
 unassigned=[r["uid"] for r in rows if not r["node"]],
 unready_pods=[r["uid"] for r in rows if not r["ready"]])
print(json.dumps(dict(namespace=namespace, daemonset=name, uid=uid,
 intended=expected, pods=rows, issues=issues), indent=2))
sys.exit(1 if any(issues.values()) else 0)
PY
)

退出零表示所收集快照中，每个预期节点 UID 匹配且 Ready，并恰有一个非终止中、Running 且 Ready 的受管理 Pod。非零需要调查：surge 造成的重复可能合法，尚未绑定节点的 Pod 仍待诊断。输出记录 Pod UID 与版本标签，但不证明目标版本、放置资格或日志交付。不同 API 读取不是原子快照，变更期间应重新核对；节点名到 UID 的映射也不能证明 Pod 当前确在该机器执行。本轮只检查语法与合成文件控制，没有运行集群、更新或 drain，技术与运行验证仍暂缓。

来源

Kubernetes node-pressure eviction，DaemonSet 优先级不能保证免于节点压力驱逐，已核验 2026-10-18。
Kubernetes DaemonSet API，期望与就绪状态及 surge 和 unavailable 预算，已核验 2026-10-18。
Kubernetes node drain，ignore-daemonsets 使 drain 跳过受 DaemonSet 管理的 Pod，已核验 2026-10-18。
Kubernetes DaemonSet rolling updates，更新策略、不可用预算与增量配置，已核验 2026-10-18。
Kubernetes DaemonSet，说明 DaemonSet 行为，已核验 2026-06-01。
Kubernetes taints 与 tolerations，说明进入被 taint 节点，已核验 2026-09-05。

普通初始化容器建立启动前置条件

Sun, 03 Jan 2027 00:00:00 +0000

普通 init container 在 Pod 的应用容器启动之前执行准备工作。它有自己的命令、镜像和文件系统视图，也可以挂载应用稍后读取的共享卷。这让前置步骤与主进程分开，但不意味着任意初始化操作都会自动安全，也不意味着重试默认存在固定次数上限。应根据真实重试方式及产物生命周期设计这个步骤，而不是把启动顺序当成完整容错机制。

原文历史样例，本次未重跑；执行仍受阻。普通初始化顺序仅限单个 Pod。显式 emptyDir 在容器重启后保留，但随 Pod 消失；不表示持久化或整组副本串行化。

顺序约束只属于一个 Pod

Kubelet 按声明顺序运行普通初始化容器。每一步必须成功结束，下一步才开始，应用容器则等待整个序列完成。检查 initContainerStatuses，才能区分正在等待的步骤、运行中的步骤和已经终止的某次尝试。仅查看 Pod 的阶段，无法说明哪条命令失败，也无法说明新的尝试是否正在进行；排查需要结合具体容器状态和日志。

共享存储需要显式挂载。emptyDir 可以在初始化容器与应用容器之间传递生成文件，并在同一 Pod 内的容器重启期间保留，但会随着 Pod 消失。不同容器不会自动共享镜像根文件系统，只写在初始化容器可写层中的文件，不会自然出现在应用容器里面。产物的写入位置和读取位置必须通过真实卷定义对应起来。

普通初始化容器需要运行到完成。Kubernetes 也支持在 initContainers 中通过容器级 restartPolicy Always 表示可重启边车，它们具有不同生命周期。因此，不能仅因为某个条目位于这个字段，就认定它必须退出后应用才能继续。本例只使用普通初始化容器，不把持续运行的边车混进顺序完成模型。

坏掉的样子

非零退出并不总会让整个 Pod 立即失败。在普通应用 Pod 采用 Always 策略时，失败的普通初始化容器会继续重试，直到成功；已经成功的初始化步骤则不会因为应用仍在运行就不断重启。退避会放慢连续尝试，却不是固定的重试次数限制。如果 Pod 的 restartPolicy 为 Never，初始化失败会使该 Pod 进入失败状态，恢复方式需要另行安排。

准备脚本应能够安全面对前一次留下的内容。中断的下载可能留下半个文件，emptyDir 中的标记也可能在失败进程退出后继续存在。应验证完整产物，再明确交付给消费者。下面用于记录次数的计数器只是诊断数据，不能作为生产逻辑，推断某个外部依赖在第二次尝试时就必然可用。真实条件必须由对应检查来判断。

一个 Pod 内的顺序并不会把整组副本串行化。把数据库迁移放进每个副本的初始化流程，仍可能让多份迁移同时执行。应遵循迁移系统真实的锁与兼容性契约。只等待一次数据库，也不能保证初始化之后数据库持续可达；应用后续请求处理和就绪判断仍需要独立设计，不能依靠先前某次成功永久推导健康。

初始化同样影响资源放置。对于普通初始化容器，调度需要比较初始化期间的峰值需求与应用容器的汇总需求，并按适用规则计入额外开销。即使长期运行的应用很小，短暂准备步骤提出过大的请求，也可能导致 Pod 无法调度。边车及 Pod 级资源功能还有自己的计算规则，不能把简化公式无条件套用到所有清单。

快速验证

准备可丢弃的 Kubernetes 集群，确保 kubectl 可访问，节点可以使用 python:3.11-slim-bookworm 镜像。保存为 init-order.py，执行 python3 init-order.py KUBECONFIG_PATH CONTEXT，明确传入测试配置路径与上下文。账号需要创建、删除命名空间的权限。原文记录的服务端为 Kubernetes 1.34.11，本轮没有重新执行集群实验；应为一次失败初始化及其重试预留时间。

import json
import subprocess
import sys
import time
from uuid import uuid4

assert len(sys.argv) == 3, 'usage: python3 example.py DISPOSABLE_KUBECONFIG CONTEXT'
base = ['kubectl', '--kubeconfig', sys.argv[1], '--context', sys.argv[2], '--request-timeout=30s']
image = 'python:3.11-slim-bookworm'


def k(*args, payload=None, expected=0):
 result = subprocess.run(base + list(args), input=json.dumps(payload) if payload is not None else None,
 capture_output=True, text=True, timeout=150)
 if expected is not None:
 assert result.returncode == expected, result.stderr
 return result


def obj(namespace, kind, name=None, selector=None):
 args = ['get', kind, '-n', namespace, '-o', 'json']
 if name:
 args.append(name)
 if selector:
 args += ['-l', selector]
 return json.loads(k(*args).stdout)


def apply(namespace, data):
 return k('apply', '-n', namespace, '-f', '-', payload=data)


def wait_for(read, ready, seconds=120):
 until = time.monotonic() + seconds
 while time.monotonic() < until:
 value = read()
 if ready(value):
 return value
 time.sleep(0.5)
 raise AssertionError('expected Kubernetes condition did not arrive')


def pod_ready(pod):
 return any(c['type'] == 'Ready' and c['status'] == 'True'
 for c in pod.get('status', {}).get('conditions', []))


def spec(script='import time; time.sleep(600)'):
 return {'automountServiceAccountToken': False, 'terminationGracePeriodSeconds': 1,
 'containers': [{'name': 'app', 'image': image, 'imagePullPolicy': 'IfNotPresent',
 'command': ['python3', '-c', script],
 'resources': {'requests': {'cpu': '10m', 'memory': '24Mi'},
 'limits': {'cpu': '200m', 'memory': '96Mi'}}}]}

namespace = 'notes-init-' + uuid4().hex[:8]
k('create', 'namespace', namespace)
try:
 prepare = r'''from pathlib import Path
import sys,time
root=Path('/work'); counter=root/'attempts'
attempt=int(counter.read_text())+1 if counter.exists() else 1
counter.write_text(str(attempt))
with (root/'order').open('a') as f: f.write('prepare'+str(attempt)+'\n')
if attempt == 1: sys.exit(7)
print('waiting for release',flush=True)
while not (root/'go').exists(): time.sleep(0.1)
(root/'input').write_text('ready')
'''
 transform = r'''from pathlib import Path
root=Path('/work'); assert (root/'input').read_text()=='ready'
(root/'output').write_text('READY')
with (root/'order').open('a') as f: f.write('transform\n')
'''
 main = r'''from pathlib import Path
import json,time
root=Path('/work'); assert (root/'output').read_text()=='READY'
with (root/'order').open('a') as f: f.write('app\n')
print(json.dumps({'order':(root/'order').read_text().splitlines(),
 'artifact':(root/'output').read_text()}),flush=True)
time.sleep(600)
'''
 podspec = spec(main)
 mount = [{'name': 'work', 'mountPath': '/work'}]
 podspec['volumes'] = [{'name': 'work', 'emptyDir': {}}]
 podspec['containers'][0]['volumeMounts'] = mount
 podspec['initContainers'] = []
 for name, script in [('prepare', prepare), ('transform', transform)]:
 container = spec(script)['containers'][0]
 container['name'] = name
 container['volumeMounts'] = mount
 podspec['initContainers'].append(container)
 apply(namespace, {'apiVersion': 'v1', 'kind': 'Pod', 'metadata': {'name': 'ordered'}, 'spec': podspec})
 def retry_running(p):
 statuses = p.get('status', {}).get('initContainerStatuses', [])
 return statuses and statuses[0]['restartCount'] >= 1 and 'running' in statuses[0]['state']
 waiting = wait_for(lambda: obj(namespace, 'pod', 'ordered'), retry_running)
 first = waiting['status']['initContainerStatuses'][0]
 assert first['lastState']['terminated']['exitCode'] == 7
 assert waiting['status']['phase'] == 'Pending'
 assert all('running' not in c['state'] for c in waiting['status'].get('containerStatuses', []))
 assert 'running' not in waiting['status']['initContainerStatuses'][1]['state']
 k('exec', '-n', namespace, 'ordered', '-c', 'prepare', '--', 'python3', '-c',
 'from pathlib import Path; Path("/work/go").touch()')
 ready = wait_for(lambda: obj(namespace, 'pod', 'ordered'), pod_ready)
 assert ready['metadata']['uid'] == waiting['metadata']['uid']
 output = wait_for(lambda: k('logs', '-n', namespace, 'ordered', '-c', 'app').stdout.strip(), bool)
 observed = json.loads(output)
 assert observed == {'order': ['prepare1', 'prepare2', 'transform', 'app'], 'artifact': 'READY'}
 assert ready['status']['initContainerStatuses'][0]['restartCount'] == 1
 assert all(c['state']['terminated']['exitCode'] == 0 for c in ready['status']['initContainerStatuses'])
 never = spec()
 never['restartPolicy'] = 'Never'
 failed_init = spec('raise SystemExit(7)')['containers'][0]
 failed_init['name'] = 'fails'
 never['initContainers'] = [failed_init]
 apply(namespace, {'apiVersion': 'v1', 'kind': 'Pod', 'metadata': {'name': 'never'}, 'spec': never})
 failed = wait_for(lambda: obj(namespace, 'pod', 'never'), lambda p: p.get('status', {}).get('phase') == 'Failed')
 status = failed['status']['initContainerStatuses'][0]
 assert status['restartCount'] == 0 and status['state']['terminated']['exitCode'] == 7
 assert not any('running' in c['state'] for c in failed['status'].get('containerStatuses', []))
 print(json.dumps({'ordered_artifact': observed, 'retried_init_count': 1,
 'app_waited_for_both_regular_init_containers': True,
 'never_policy_failed_pod_without_retry': True}))
finally:
 k('delete', 'namespace', namespace, '--wait=true', '--timeout=90s')

准备容器记录第一次尝试并以退出码七结束。第二次尝试等待一个放行文件，脚本在此时确认 Pod 仍为 Pending、上一次失败已记录，而且后续初始化步骤与应用都没有运行。然后通过这个容器的共享卷放行准备过程。这个暂停点提供直接状态证据，而不是根据最终日志猜测应用曾经等待。

第二个初始化容器把 ready 转成 READY，应用随后校验产物。日志中的顺序为 prepare1、prepare2、transform、app，第一个初始化容器的重启次数为一。另一个采用 Never 策略的 Pod 初始化失败后进入 Failed，没有重试。原文报告全部断言通过，命名空间清理了两个 Pod；这里保留历史执行归属，不表示本轮独立重现。实验验证的是本地顺序、共享产物及失败策略，没有证明分布式迁移安全，也没有提供持久化存储保障。

来源

Kubernetes: Init Containers，普通初始化容器的顺序、重试、资源计算与可重复执行，已核验 2026-10-15。
Kubernetes: Pod Lifecycle，Pod 阶段、容器状态与重启策略，已核验 2026-10-15。