负载 · XB 现场笔记

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

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

Deployment 在意总数，DaemonSet 在意覆盖面：新节点一进池子，同一个服务立刻就在那里。节点级关切——发日志、暴露硬件指标、跑网络 fabric、执行策略——必须处处有，不然等于处处没有。用逐节点脚本或每个 Pod 塞 sidecar 去凑合，立刻就烂：新节点漏掉、版本漂移，没人答得出"哪些节点跑着 agent"而不审计。

DaemonSet 控制器用声明式覆盖弥合这个缝。你把守护进程描述一次，控制器永远把现实收敛到每合格节点一个 Pod，扩集群自动扩守护舰队。覆盖从 runbook 条目变成系统维护的不变量。

每节点一个、天生如此

你把守护进程描述一次，控制器就给每个节点都挂一份副本，这正是节点级日志、指标 agent 与 kube-proxy 这类流量的天然归属。没有需要手工调大小的伸缩旋钮。没有旋钮是特性：副本数一经手压就会从意图漂走，而"每合格节点一个"不会漂——它按节点列表持续重算。新节点注册时 gain Pod，离场释放，被 cordon 的除非 drain 都留着。

因为放置按节点不按容量，DaemonSet Pod 一般要优先级和抢占 headroom，才能在满节点上活下来。给高 PriorityClass、诚实而克制的资源 requests：节点再满它们也必须调度上去，因为过载节点上缺席的监控 agent，恰在最需要 visibility 时致盲。没有需要手工调大小的伸缩旋钮，但调度要做对。

覆盖优先于数量

因为期望副本数本就隐含，一次滚动更新会触及每个成员：往池子里加一个节点，守护进程不用额外动作就自动出现。这是任何逐节点脚本都拼不过的保证。更新用 maxUnavailable 限 disruption 在舰队铺开——设 1 就逐节点刷新，舰队永不断覆盖。节点脚本的慢性病版本漂移，在结构上不可能：控制器把每节点收敛到同一模板，kubectl rollout status ds/agent 告诉你收敛何时完成。

异构舰队用 nodeSelector 与亲和延伸这份保证：一类节点一个 DaemonSet，各收敛各的子集。GPU 节点装 device plugin daemon，边缘节点装轻量 forwarder，各控制器只管自己的覆盖。心智模型保持"这类节点永远跑这个 daemon"，被强制执行而不只是被希望。

跟着节点生命周期走

用 toleration 让 DaemonSet 能进那些一般工作负载被 taint 挡在门外的专用节点，从而保住全集群一致。典型例子是 master 的 control-plane taint 和 GPU/spot taint：没有 toleration，最有意思的节点恰恰没有 agent，舰队视图的洞长得跟特殊硬件一个形状。再用 nodeSelector 挑哪些子集该装，同时让每个够资格的节点都保持同步——按标签选子集保持声明式，给节点重打标签就在 daemon 舰队之间搬家，不碰任何控制器。

反过来也要尊重驱逐与 drain 语义。DaemonSet Pod 按设计无视普通调度压力，但 drain 时还是要优雅退出：terminationGracePeriodSeconds 诚实配置，SIGTERM 好好处理，不然节点维护变成日志断档和指标窟窿。覆盖意味着 churn 中也在场，而优雅关闭决定节点的滚动升级在监控里看不看像故障。新节点池上线第一件事就是对 daemon 覆盖数：期望数与就绪数按池分组看，分叉立刻补 toleration。把这个检查写进节点池交付清单，而不是靠故障发现。守护镜像的更新先灰度一个池，观察一轮无异常再全量铺开。

灰度期间重点看三组数字：新旧两个版本的 Pod 就绪数是否都稳定、节点侧日志量是否连续无断档、该池的 CPU 与内存占用是否明显抬升。任何一组抖动都先暂停全量，把有问题的镜像钉死在灰度池里排查，而不是带着疑问继续铺。灰度通过后再放开剩余池子，并保留旧版镜像标签一周，方便回滚时一步到位。

坏掉的样子

最经典的是悄悄没覆盖的节点：新节点池带了没人告诉 DaemonSet 的 taint，agent 处处有、除了那四十台新机器——而正在查的恰恰是它们。用各池的节点数对 daemon Pod 数诊断：每 DaemonSet 的 desiredNumberScheduled 对 numberReady 按节点标签分组。数字分叉的池子，缺的 toleration 或 selector 当场现形。

第二种是坏 daemon 更新铺满舰队：坏 agent 镜像配过大的 maxUnavailable，一次带走多节点的日志，致盲的恰是日志本要服务的调查。可观测 daemon 的 maxUnavailable 钉 1，先在 canary 池暂停验证（nodeSelector 限定的 DaemonSet 天然是 canary），记住回滚 DaemonSet 是一条命令——用得要快，因为没有 agent 的每一分钟都是缺证据的一分钟。

快速验证

期望覆盖对现实：

kubectl get ds -A -o custom-columns=NAME:.metadata.name,DESIRED:.status.desiredNumberScheduled,READY:.status.numberReady
kubectl get pods -o wide -l app=log-agent | awk '{print $7}' | sort | uniq -c | wc -l
kubectl get nodes --no-headers | wc -l

第一条看每 daemon 的覆盖缺口，Pod 节点数对节点数证明每台机器真有它的副本。

来源

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

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。