探针 · XB 现场笔记

启动探针成功后，其他探针才开始执行

Sun, 22 Aug 2027 00:00:00 +0000

Startup 探针为容器提供单独的初始化契约。在已经配置的启动探针成功之前，Kubernetes 不会执行这个容器的 liveness 或 readiness 探针。这比“宽限期内忽略一些存活失败”更具体：另外两种检查根本还没有开始。启动检查成功之后，后续健康和就绪判断才按各自规则接管，不能把三个名称理解成同一个接口的不同标签。

为每个阶段定义可观察条件

应用进程必须先运行，启动探针才可能成功。因此，容器已经 Running 时，container status 中的 started 仍可能为 false，所在 Pod 也可能尚未 Ready。运行状态描述进程正在执行，启动成功则描述配置的检查条件已经满足。提前开放的 HTTP 监听端可以报告进度，但不应该因此自动声称全部准备已经完成。

启动条件应代表必要的本地准备，例如加载索引或验证初始状态。只有打开端口确实就是所需前置条件时，单纯检查端口才足够。如果监听器先出现，昂贵的初始化稍后才结束，过早成功的检查就会提前解除存活保护，再次造成原本想避免的重启循环。接口名称不会替应用定义初始化完成的真实含义。

启动检查一旦成功，kubelet 就停止当前容器实例的 startup 探针，并按独立配置运行存活与就绪检查。启动成功不是永久健康证明：应用稍后仍可能变成未就绪，或者需要重启。新的容器实例还要重新完成自己的启动检查，不能继承上一实例已经成功的结论。把实例身份和状态变化一起记录，才能解释重复启动的原因。

坏掉的样子

启动探针如果一直不成功，最终会达到失败阈值。Kubelet 随后终止容器，并根据对应重启策略处理。因此，启动保护不是允许初始化无限等待。周期、超时和失败阈值应依据真实初始化耗时设置，同时考虑环境中可能发生的资源争用与可以接受的恢复时间，避免只按开发机器的一次快速启动选择参数。

failureThreshold 与 periodSeconds 的乘积可用于规划启动预算，但不能把它写成所有实际重启都严格遵守的秒表。初始延迟、探针执行与调度、终止宽限和重启退避也影响完整时间线。排查慢发布时，应记录真实尝试和状态变化，而不是仅根据两个配置数字推断容器应该已经重启，或断定平台行为错误。

除非通过 startup 明确建立依赖，否则不应认为 liveness 会等 readiness 成功才开始。就绪与存活原本回答两个持续运行阶段的问题。反过来，启动成功也不会强迫就绪成功：后续 readiness 可能因为另一个条件拒绝流量资格，而进程仍然正常存活。把这些结果分开，才能选择正确恢复动作，避免用反复重启处理暂时不可服务。

修改探针也需要应用实际配合。一个永远返回成功的接口，不会因为名称叫 startup，就具备验证初始化步骤的能力。状态转换应有明确实现，并提供足够诊断信息解释为什么仍在等待。接口还应避免向非预期调用方暴露凭据或敏感初始化内容。下面的测试仅输出计数和合成状态，便于核对调用顺序。

快速验证

以下实验及观察结果沿用原文记录。本次审阅没有重新执行 Kubernetes 集成实验；文中的成功结果属于历史记录，不代表本轮取得了新的运行证据。

准备可丢弃的 Kubernetes 集群、kubectl，以及节点可用的 python:3.11-slim-bookworm 镜像。保存为 startup-gate.py，执行 python3 startup-gate.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-startup-' + uuid4().hex[:8]
k('create', 'namespace', namespace)
try:
 server = '''from http.server import BaseHTTPRequestHandler,HTTPServer
from pathlib import Path
import json
counts={'startup':0,'live':0,'ready':0}
class Handler(BaseHTTPRequestHandler):
 def do_GET(self):
 key=self.path.removeprefix('/'); code=200
 if key in counts:
 counts[key]+=1
 if key=='startup' and not Path('/tmp/start').exists(): code=503
 body=json.dumps(counts).encode(); self.send_response(code)
 self.send_header('Content-Length',str(len(body))); self.end_headers(); self.wfile.write(body)
 def log_message(self,*args): pass
HTTPServer(('0.0.0.0',8080),Handler).serve_forever()
'''
 podspec = spec(server)
 c = podspec['containers'][0]
 c['startupProbe'] = {'httpGet': {'path': '/startup', 'port': 8080}, 'periodSeconds': 1, 'failureThreshold': 60}
 for field, path in [('livenessProbe', '/live'), ('readinessProbe', '/ready')]:
 c[field] = {'httpGet': {'path': path, 'port': 8080}, 'periodSeconds': 1, 'failureThreshold': 2}
 apply(namespace, {'apiVersion': 'v1', 'kind': 'Pod', 'metadata': {'name': 'slow'}, 'spec': podspec})
 wait_for(lambda: obj(namespace, 'pod', 'slow'), lambda p:
 any('running' in c['state'] for c in p.get('status', {}).get('containerStatuses', [])))
 read = 'from urllib.request import urlopen; print(urlopen("http://127.0.0.1:8080/stats",timeout=3).read().decode())'
 def counts():
 result = k('exec', '-n', namespace, 'slow', '--', 'python3', '-c', read, expected=None)
 return json.loads(result.stdout) if result.returncode == 0 else None
 before = wait_for(counts, lambda d: d and d['startup'] >= 3)
 assert before['live'] == before['ready'] == 0
 starting = obj(namespace, 'pod', 'slow')
 assert not pod_ready(starting)
 assert starting['status']['containerStatuses'][0]['started'] is False
 assert starting['status']['containerStatuses'][0]['restartCount'] == 0
 k('exec', '-n', namespace, 'slow', '--', 'python3', '-c',
 'from pathlib import Path; Path("/tmp/start").touch()')
 ready = wait_for(lambda: obj(namespace, 'pod', 'slow'), pod_ready)
 assert ready['status']['containerStatuses'][0]['started'] is True
 enabled = wait_for(counts, lambda d: d and d['live'] > 0 and d['ready'] > 0)
 time.sleep(3)
 after = counts()
 assert after['startup'] == enabled['startup']
 assert after['live'] > enabled['live'] and after['ready'] > enabled['ready']
 assert obj(namespace, 'pod', 'slow')['status']['containerStatuses'][0]['restartCount'] == 0
 print(json.dumps({'before_startup_success': before, 'after_startup_success': after,
 'other_probes_suppressed_before_startup': True,
 'startup_probe_stops_after_success': True, 'container_restarts': 0}))
finally:
 k('delete', 'namespace', namespace, '--wait=true', '--timeout=90s')

HTTP 服务分别记录 startup、live、ready 路径的请求次数。统计路径只读取数据，不增加这三个计数。启动路径最初返回 503，直到本地放行文件出现。观察到三次启动请求时，另外两个计数都为零，容器没有重启，started 字段为 false。这直接验证其他探针尚未执行，而不是把它们的失败隐藏起来。

创建放行文件后，下一次启动检查成功。Pod 变成 Ready，started 变成 true，存活与就绪计数开始增加。再等三秒，启动计数保持固定，另外两个计数继续增加。本次最终分别观察到四、四、五次；持续探针的精确次数会受到时序影响，因此断言检查的是变化关系，而不是强制所有运行都得到同一个数字。

原文报告全部断言通过，容器没有重启，命名空间随后删除。实验通过真实 HTTP 调用验证了抑制与交接，没有测量生产启动耗时分位数，也没有耗尽启动失败预算。选择真实阈值时需要补充这些观测，同时保持初始化完成与持续服务健康之间的区别，不能用一次启动通过替代后续运行质量。

来源

Kubernetes: Configure Probes，启动失败预算与探针配置，已核验 2026-10-15。
Kubernetes: Pod Probes，启动成功前抑制存活与就绪检查，已核验 2026-10-15。

liveness 与 readiness 告诉 Kubernetes Pod 的状态

Wed, 14 Jul 2027 00:00:00 +0000

慢启动不等于进程已死：readiness 负责遮挡流量，liveness 只负责让进程活着。把两者搞混是最常见的健康检查错误。团队把同一个接口同时接进两种探针，于是每个变慢的依赖都变成重启循环——应用需要时间，存活探针偏不给，Pod 恰恰死在本来再忍一会儿就能活的关口。两种探针并存，因为"没就绪"和"已死"要的是相反的动作：一个要时间，一个要重启。

防混的心智模型是医院分诊。就绪探针是分诊护士，决定谁现在能看医生；存活探针是抢救车，只在病人心跳停了才推出来。没人会因为坐在候诊区就给人除颤。记住这个画面，探针配置几乎不用想就写对了。

Readiness 把流量挡在门外

连续 readiness 失败达到阈值，会让 Pod 失去普通 Service 路由资格，但 Pod 仍在运行，好让进程完成热身或自行恢复。端点条件与数据路径在失败、恢复两个方向都异步收敛；已有连接和 Pod 直连需要分别考虑。就绪失败不直接触发探针重启，却可能移除全部服务容量，不能无条件称为安全：缓存可以慢慢热，迁移可以跑完，下游依赖可以回来，全程不丢 Pod 的内存状态，也不付重启的代价。

就绪接口要围绕真正的可服务性设计，而不是进程存在性。检查那些决定这个 Pod 此刻能否正确回答的东西：结构迁移是否应用、必需的缓存是否装满、关键下游是否可达。只检查"服务能响应"的就绪探针，会把注定失败每个请求的 Pod 放进流量——比不检查还糟，因为负载均衡器是信任它的。但也别把所有依赖都塞进去：非关键的推荐服务挂了，就绪失败等于为一件装饰品扔掉主干流量。

Liveness 守护进程本身

liveness 探针连续失败达到阈值会终止容器，是否重启遵循重启策略，这是结束僵死状态的最后一招。它要处理的该是"进程卡死"这类问题，而不是容器只是暂时还没就绪。合格的目标很窄：死锁——此后任何请求都不会再成功；协程或线程泄漏到只有新进程能清；内存状态损坏到任何重试都救不回来。每种情况的共同点是不可逆：不重启就不可能恢复，而不只是恢复得慢。

这个门槛意味着很多服务应该只配极简的存活探针，甚至不配。把存活检查打到外部数据库上，每次数据库抖动都会变成全集群的重启风暴，还顺手毁掉本可以加速恢复的热缓存。优先用廉价的本地检查——主循环定时刷新的看门狗时间戳——不问进程之外的任何东西，只回答"这个进程是不是卡死了"。崩溃之后是否重启，取决于容器重启策略；存活探针则能在普通退出之前识别选定的不可恢复本地故障。

给探针留足余量

把 initialDelaySeconds 设到足够大，别把冷启动误判成崩溃；timeout 也要配合真实工作量。把两类探针分开，让慢的 Pod 由 readiness 护住，而不是被 liveness 误回收。启动慢的容器最好再加一个启动探针：它成功之前，存活与就绪探针都保持关闭，于是需要预热大缓存的版本升级能拿到几分钟而不是几秒，稳态的存活检查强度一点不减。

失败阈值按观测到的行为调，别在服务之间抄整数。检查周期乘以失败次数只是规划估计，不是真实反应时间保证。探针所处周期、超时、调度、终止宽限与重启退避都会改变时间线；就绪端点变化与已有连接也并非在同一瞬间全部完成。量出冷启动的分位耗时、依赖恢复时间、最坏的回收停顿，再定每个数字：比告警快，比噪声慢。

坏掉的样子

标志性故障是依赖故障期的重启循环：数据库变慢，本来就绪探针就够了，但存活探针共用同一个失败的接口，全集群一波波重启。每次重启清空热缓存，下一波恢复更慢，系统无限振荡。诊断看重启时间戳与依赖事故是否对齐；修法是拆接口——就绪查依赖，存活只查进程——让生病的下游只挡流量，不杀 Pod。

镜像故障是僵尸 Pod：服务能响应所以存活探针通过，但请求全卡在死锁的工作池后面。流量源源不断送进一个什么都不回答的 Pod。修法是让存活接口走真实路径——带短超时申请一个工作槽、确认没有客户端请求时仍会刷新的本地进度心跳保持新鲜——卡死能失败探针，单纯慢则不失败。

快速验证

检查探针接线与最近的杀戮记录：

kubectl get pod web-0 -o jsonpath='{.spec.containers[*].livenessProbe}{"\n"}{.spec.containers[*].readinessProbe}{"\n"}'
kubectl get events --field-selector reason=Unhealthy --sort-by=.lastTimestamp | tail -n 10
kubectl describe pod web-0 | grep -A3 -i 'liveness\|readiness'

这些未改动的诊断本轮没有重新执行。若语义适合两项决策，共用 URL 并不天然错误。Unhealthy 事件包含探针失败，不能证明发生了杀进程；需要关联具体 Pod、容器重启计数和终止原因。带期限的检查必须区分死锁、暂时负载及没有业务请求的正常空闲，不能用一次失败代替完整故障判断。

来源

Kubernetes 探针，liveness 与 readiness 官方文档，已核验 2026-10-15。
配置存活与就绪探针，探针配置任务指南，已核验 2026-10-15。

就绪探针改变路由资格，存活探针触发容器重启

Wed, 13 Jan 2027 00:00:00 +0000

Readiness 与 liveness 回答不同的运维问题。就绪探针判断当前容器是否应该参与一个能够接收普通 Service 流量的 Pod，存活探针则判断是否应该执行预先配置的容器重启恢复。两者都可以使用 HTTP，但协议相同不代表语义相同。应先确定希望平台采取什么动作，再设计触发该动作的条件，否则一个健康接口可能同时承担互相冲突的责任。

同时观察响应和平台动作

就绪探针失败会让容器变成未就绪，并影响 Pod 的 Ready 条件。对于普通带选择器的 Service，端点协调随后改变哪些后端可以参加正常路由。Pod 可以保持 Running，同时处于未就绪状态，应用进程也可能继续运行。重启次数、Pod 标识和 Ready 条件回答的是不同问题，排查时不能只看其中一个状态就推导全部行为。

存活探针连续失败达到配置阈值后，kubelet 会终止容器并按相应重启规则处理。普通 Always 策略应用 Pod 会在原 Pod 中获得替换容器，而不是必然创建一个新 Pod 对象，也不是发布另一版应用。应在比较 Pod 身份的同时查看容器重启次数与终止状态，避免把一次进程恢复误报为完整工作负载替换。

检查应便宜，而且成功条件要具有实际含义。TCP 连接成功只证明监听端能够接受连接，不证明应用能够完成有用工作。HTTP 可以表达更丰富的问题，但如果它递归调用昂贵的依赖检查，也可能成为额外负载来源。探针自己的执行成本应符合工作负载容量和超时预算，不能让健康检查本身把健康服务压慢。

坏掉的样子

把共享数据库故障当成存活失败，可能导致所有正常应用进程不断重启，却完全无法修复数据库。把同一个依赖直接加入就绪检查也需要判断：撤走全部副本可能同时撤掉本来有价值的降级响应，在局部故障中还可能把流量集中到剩余副本。应依据服务实际契约定义就绪，包括已经明确支持的部分可用行为，而不是照抄统一依赖清单。

就绪状态不是网络访问控制。即使某个 Pod 不再属于 Service 的就绪目标，它的地址仍可能被直接访问。既有连接、其他路由层，以及 publishNotReadyAddresses 等 Service 设置，也需要单独分析。因此，不能把 readiness 失败描述成一个瞬时保证，认为从此没有任何请求能够到达进程。它改变的是对应服务发现和路由流程中的资格。

阈值和时序决定敏感程度。超时过短可能把 CPU 争用误认成故障，要求连续多次失败则可以避免对一次短暂延迟立即反应。启动保护是另一回事：配置了 startup 探针时，在它成功之前不会执行就绪与存活探针。这些参数定义采样和恢复策略，并不证明终止过程中不会丢失请求；可靠停机仍需应用参与。

快速验证

准备可丢弃的 Kubernetes 集群，确保 kubectl 可用，节点能够使用 python:3.11-slim-bookworm 镜像。保存为 probe-actions.py，执行 python3 probe-actions.py KUBECONFIG_PATH CONTEXT，明确传入测试集群参数。账号需要创建、删除命名空间。原文记录的服务端为 Kubernetes 1.34.11，本轮没有重新执行集群实验；脚本创建一个 HTTP Pod 和采用默认端点就绪行为的普通 Service。

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-probes-' + uuid4().hex[:8]
k('create', 'namespace', namespace)
try:
 server = '''from http.server import BaseHTTPRequestHandler,HTTPServer
from pathlib import Path
class Handler(BaseHTTPRequestHandler):
 def do_GET(self):
 flag={'/live':'/tmp/live-fail','/ready':'/tmp/ready-fail'}.get(self.path)
 code=503 if flag and Path(flag).exists() else 200
 body=b'worker'; self.send_response(code); self.send_header('Content-Length',str(len(body)))
 self.end_headers(); self.wfile.write(body)
 def log_message(self,*args): pass
HTTPServer(('0.0.0.0',8080),Handler).serve_forever()
'''
 podspec = spec(server)
 c = podspec['containers'][0]
 c['readinessProbe'] = {'httpGet': {'path': '/ready', 'port': 8080}, 'periodSeconds': 1, 'failureThreshold': 2}
 c['livenessProbe'] = {'httpGet': {'path': '/live', 'port': 8080}, 'periodSeconds': 1, 'failureThreshold': 3}
 apply(namespace, {'apiVersion': 'v1', 'kind': 'Pod', 'metadata': {'name': 'worker', 'labels': {'app': 'worker'}}, 'spec': podspec})
 apply(namespace, {'apiVersion': 'v1', 'kind': 'Service', 'metadata': {'name': 'web'},
 'spec': {'selector': {'app': 'worker'}, 'ports': [{'port': 80, 'targetPort': 8080}]}})
 def targets():
 return {e['targetRef']['uid'] for s in obj(namespace, 'endpointslices', selector='kubernetes.io/service-name=web')['items']
 for e in s.get('endpoints', []) if e.get('conditions', {}).get('ready') and e.get('targetRef')}
 initial = wait_for(lambda: obj(namespace, 'pod', 'worker'), pod_ready)
 uid = initial['metadata']['uid']
 wait_for(targets, lambda value: value == {uid})
 def change(path, create):
 method = 'touch' if create else 'unlink'
 k('exec', '-n', namespace, 'worker', '--', 'python3', '-c',
 'from pathlib import Path; Path('+repr(path)+').'+method+'()')
 change('/tmp/ready-fail', True)
 wait_for(lambda: obj(namespace, 'pod', 'worker'), lambda p: not pod_ready(p))
 wait_for(targets, lambda value: not value)
 time.sleep(4)
 unready = obj(namespace, 'pod', 'worker')
 assert unready['metadata']['uid'] == uid and unready['status']['containerStatuses'][0]['restartCount'] == 0
 address = 'http://' + unready['status']['podIP'] + ':8080/api'
 probe = 'from urllib.request import urlopen; print(urlopen('+repr(address)+',timeout=3).read().decode())'
 assert k('exec', '-n', namespace, 'worker', '--', 'python3', '-c', probe).stdout.strip() == 'worker'
 change('/tmp/ready-fail', False)
 wait_for(targets, lambda value: value == {uid})
 change('/tmp/live-fail', True)
 restarted = wait_for(lambda: obj(namespace, 'pod', 'worker'), lambda p:
 pod_ready(p) and p['status']['containerStatuses'][0]['restartCount'] >= 1)
 assert restarted['metadata']['uid'] == uid
 assert restarted['status']['containerStatuses'][0]['restartCount'] == 1
 wait_for(targets, lambda value: value == {uid})
 print(json.dumps({'readiness_removed_ready_target_without_restart': True,
 'unready_pod_direct_http_still_succeeds': True,
 'readiness_recovery_restores_target': True,
 'liveness_container_restarts': 1, 'same_pod_uid': True}))
finally:
 k('delete', 'namespace', namespace, '--wait=true', '--timeout=90s')

起初 Pod 已就绪，它的标识出现在 Service 的 EndpointSlice 就绪目标中。创建本地标记文件后，只有 readiness 路径返回 503。达到失败阈值并完成协调后，就绪目标集合为空。再过四秒，Pod 标识仍相同，容器重启次数仍为零。这同时验证了路由资格变化与进程没有重启，而不是仅检查接口返回码。

在同一个 Pod 内，向它自己的未就绪 Pod 地址直接发送 HTTP 请求，仍能得到 worker。这没有测试其他 Pod 或外部客户端的可达性。删除就绪失败标记，目标资格便恢复。接着创建另一个标记，让 liveness 路径失败，kubelet 实际重启容器一次。新容器的可写层不再包含该标记，Service 就绪目标随之恢复。整个过程中 Pod 的标识没有变化，显示重启发生在容器层面。

原文报告全部断言通过，命名空间随后删除；这里保留的是历史执行归属，不表示本轮独立重现。实验展示了不同平台动作与直接可达性，没有测试已有连接的优雅排空，也没有证明生产可用性。真实发布还需要共同验证端点传播、应用停机、未完成工作和客户端行为。健康探针返回成功，只能说明该探针检查的条件成立，不能代替整个请求生命周期的交付证据。

来源

Kubernetes: Configure Probes，失败阈值以及就绪和存活探针的不同动作，已核验 2026-10-15。
Kubernetes: Pod Lifecycle，容器重启与 Pod 就绪状态，已核验 2026-10-15。
Kubernetes: EndpointSlices，后端就绪条件及服务发现行为，已核验 2026-10-15。

探针 · XB 现场笔记

启动探针成功后，其他探针才开始执行

为每个阶段定义可观察条件

坏掉的样子

快速验证

延伸阅读

来源

liveness 与 readiness 告诉 Kubernetes Pod 的状态

Readiness 把流量挡在门外

Liveness 守护进程本身

给探针留足余量

坏掉的样子

快速验证

延伸阅读

来源

就绪探针改变路由资格，存活探针触发容器重启

同时观察响应和平台动作

坏掉的样子

快速验证

来源