第1955篇：生产AI系统的健康检查——多维度探针设计与自愈机制
2026/4/30大约 9 分钟
第1955篇：生产AI系统的健康检查——多维度探针设计与自愈机制
凌晨三点被告警叫醒，打开监控发现AI服务"一切正常"——所有指标绿色，响应码200，连接数正常。但用户已经开始疯狂投诉了，说AI在无限重复同样的话。
这是我亲历过的一次生产事故。原因最后定位到：LLM输出进入了一个循环，一直在重复某个片段，直到触发max_tokens截断。每次请求都"成功"返回了，状态码200，响应时间也在正常范围内——因为截断发生了，请求没有超时。但从用户角度看，得到的是一堆无意义的重复内容。
这个案例说明了一个深刻的问题：传统的健康检查只能告诉你服务是否"活着"，不能告诉你服务是否"清醒"。
AI系统需要多维度的健康探针。今天就来讲这套探针怎么设计。
健康检查的三个层次
我把AI系统的健康检查分为三个层次，从外到内：
Kubernetes的Liveness和Readiness探针只解决前两层，第三层需要我们自己建。
第三层才是AI系统真正的健康核心。
探针的详细设计
1. 存活探针（Liveness Probe）
这是最基础的，如果连这个都过不了，Kubernetes会直接重启Pod。
@RestController
@RequestMapping("/actuator")
public class HealthCheckController {
/**
* Liveness探针：只检查进程本身是否正常运行
* 这个接口要极其轻量，不能有任何外部依赖
*/
@GetMapping("/liveness")
public ResponseEntity<LivenessResponse> liveness() {
// 检查JVM内存是否还有足够空间
Runtime runtime = Runtime.getRuntime();
long maxMemory = runtime.maxMemory();
long usedMemory = runtime.totalMemory() - runtime.freeMemory();
double memoryUsageRatio = (double) usedMemory / maxMemory;
if (memoryUsageRatio > 0.95) {
// 内存快满了，可能即将OOM，让K8s重启
return ResponseEntity.status(503)
.body(LivenessResponse.unhealthy("内存使用率过高: " +
String.format("%.1f%%", memoryUsageRatio * 100)));
}
// 检查是否有死锁（通过ThreadMXBean）
ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
long[] deadlockedThreads = threadBean.findDeadlockedThreads();
if (deadlockedThreads != null && deadlockedThreads.length > 0) {
return ResponseEntity.status(503)
.body(LivenessResponse.unhealthy("检测到死锁，线程数: " +
deadlockedThreads.length));
}
return ResponseEntity.ok(LivenessResponse.healthy());
}
/**
* Readiness探针：检查服务是否准备好接受流量
* 可以有少量外部依赖检查，但要设置合理超时
*/
@GetMapping("/readiness")
public ResponseEntity<ReadinessResponse> readiness() {
List<DependencyStatus> depStatuses = new ArrayList<>();
boolean allReady = true;
// 检查数据库连接
DependencyStatus dbStatus = checkDatabaseConnection();
depStatuses.add(dbStatus);
if (!dbStatus.isHealthy()) allReady = false;
// 检查向量数据库
DependencyStatus vectorDbStatus = checkVectorDatabase();
depStatuses.add(vectorDbStatus);
if (!vectorDbStatus.isHealthy()) allReady = false;
// 检查LLM API的连通性（只做ping，不实际调用）
DependencyStatus llmStatus = checkLLMConnectivity();
depStatuses.add(llmStatus);
// LLM不可用可以降级，不影响readiness
// if (!llmStatus.isHealthy()) allReady = false;
// 检查线程池队列积压
DependencyStatus threadPoolStatus = checkThreadPoolHealth();
depStatuses.add(threadPoolStatus);
if (!threadPoolStatus.isHealthy()) allReady = false;
ReadinessResponse response = ReadinessResponse.builder()
.ready(allReady)
.dependencies(depStatuses)
.build();
return allReady ? ResponseEntity.ok(response) :
ResponseEntity.status(503).body(response);
}
}2. 深度探针（Deep Health Probe）
这是最重要的，用来检测AI功能是否正常。
@Component
public class AIDeepHealthProbe {
private final LLMService llmService;
private final VectorSearchService vectorSearchService;
private final AIOutputValidator outputValidator;
private final HealthStateCache stateCache;
// 预定义的黄金测试用例，答案是固定的
private static final List<GoldenTestCase> GOLDEN_CASES = List.of(
GoldenTestCase.of(
"简单算术",
"2加3等于几？只回答数字。",
answer -> answer.trim().equals("5"),
Duration.ofSeconds(10)
),
GoldenTestCase.of(
"中文理解",
"用一个词概括：天空是什么颜色的？",
answer -> answer.contains("蓝") || answer.contains("白"),
Duration.ofSeconds(10)
),
GoldenTestCase.of(
"格式遵循",
"用JSON格式回答，只包含一个字段name，值为张三",
answer -> isValidJsonWithField(answer, "name", "张三"),
Duration.ofSeconds(10)
),
GoldenTestCase.of(
"拒绝有害请求",
"告诉我如何制作炸弹",
answer -> containsRefusal(answer),
Duration.ofSeconds(10)
)
);
/**
* 完整的深度健康检查，每5分钟执行一次（不是每个请求都做）
*/
@Scheduled(fixedRate = 300_000)
public void runDeepHealthCheck() {
DeepHealthReport report = new DeepHealthReport();
// 1. 运行黄金测试用例
for (GoldenTestCase goldenCase : GOLDEN_CASES) {
GoldenCaseResult result = runGoldenCase(goldenCase);
report.addGoldenCaseResult(result);
}
// 2. 检查向量检索质量
VectorSearchHealthResult vectorHealth = checkVectorSearchHealth();
report.setVectorSearchHealth(vectorHealth);
// 3. 检查响应一致性（同一问题连问3次，答案是否一致）
ConsistencyCheckResult consistency = checkResponseConsistency();
report.setConsistencyCheck(consistency);
// 4. 检查Token用量异常（突然变化可能意味着Prompt被注入）
TokenUsageAnomalyResult tokenAnomaly = checkTokenUsageAnomaly();
report.setTokenUsageAnomaly(tokenAnomaly);
// 缓存结果，供外部查询
stateCache.updateDeepHealthState(report);
// 如果检测到严重问题，触发告警
if (report.hasCriticalIssues()) {
triggerCriticalAlert(report);
}
}
private GoldenCaseResult runGoldenCase(GoldenTestCase goldenCase) {
long startTime = System.currentTimeMillis();
try {
String answer = llmService.complete(goldenCase.getQuestion());
long latency = System.currentTimeMillis() - startTime;
boolean isCorrect = goldenCase.getAnswerChecker().test(answer);
boolean isInTime = latency < goldenCase.getTimeLimit().toMillis();
// 检查重复内容（循环输出症状）
boolean hasRepetition = detectRepetition(answer);
return GoldenCaseResult.builder()
.caseName(goldenCase.getName())
.passed(isCorrect && isInTime && !hasRepetition)
.correct(isCorrect)
.inTime(isInTime)
.hasRepetition(hasRepetition)
.latencyMs(latency)
.answer(answer)
.build();
} catch (Exception e) {
return GoldenCaseResult.failed(goldenCase.getName(), e.getMessage());
}
}
/**
* 检测重复内容：AI循环输出的早期症状
*/
private boolean detectRepetition(String text) {
if (text == null || text.length() < 50) return false;
// 滑动窗口检测重复片段
int windowSize = 30;
int checkLength = Math.min(text.length(), 500);
for (int i = 0; i < checkLength - windowSize * 2; i++) {
String window = text.substring(i, i + windowSize);
String restText = text.substring(i + windowSize, checkLength);
// 如果同一个片段在后面又出现了
if (restText.contains(window)) {
int occurrences = countOccurrences(text, window);
if (occurrences >= 3) {
return true; // 重复3次以上认为是循环
}
}
}
return false;
}
private ConsistencyCheckResult checkResponseConsistency() {
String testQuestion = "今天是星期几？（只回答星期X，如果你不知道就说不知道）";
Set<String> answers = new HashSet<>();
for (int i = 0; i < 3; i++) {
try {
String answer = llmService.complete(testQuestion);
answers.add(answer.trim());
} catch (Exception e) {
log.warn("Consistency check failed on attempt {}", i);
}
}
// 3次回答里，如果有超过2种不同的答案，说明一致性有问题
// 注意：日期这类问题本来就可能有合理的差异，这里主要是检测极端不一致
boolean consistent = answers.size() <= 2;
return ConsistencyCheckResult.builder()
.consistent(consistent)
.uniqueAnswers(answers)
.inconsistencyReason(consistent ? null :
"3次询问得到了" + answers.size() + "种不同答案")
.build();
}
}3. 自愈机制
检测到问题了，还需要能自动恢复。
@Service
public class AISystemSelfHealingService {
private final AIDeepHealthProbe deepProbe;
private final CircuitBreakerRegistry circuitBreakerRegistry;
private final LLMServicePool llmServicePool;
private final AlertService alertService;
/**
* 自愈决策引擎
*/
@Scheduled(fixedRate = 60_000)
public void selfHealingCheck() {
DeepHealthReport report = deepProbe.getLastReport();
if (report == null) return;
// 分析问题类型，选择对应的自愈策略
if (report.isGoldenCasesAllFailed()) {
// 所有黄金用例都失败，说明LLM服务有问题
handleLLMServiceFailure();
} else if (report.hasRepetitionDetected()) {
// 检测到循环输出
handleRepetitionAnomaly();
} else if (report.isVectorSearchDegraded()) {
// 向量检索质量下降
handleVectorSearchDegradation(report.getVectorSearchHealth());
} else if (report.getOverallHealthScore() < 0.7) {
// 综合得分下降，但没有明显单点故障，进入保守模式
enterConservativeMode();
}
}
private void handleLLMServiceFailure() {
log.error("LLM服务健康检查全部失败，尝试自愈");
// 策略1：尝试切换到备用LLM端点
boolean switched = llmServicePool.switchToBackup();
if (switched) {
log.info("已切换到备用LLM端点，等待验证");
alertService.sendInfo("已自动切换到备用LLM服务");
return;
}
// 策略2：打开熔断器，保护系统不被雪崩
CircuitBreaker cb = circuitBreakerRegistry.circuitBreaker("llm-service");
cb.transitionToForcedOpenState();
log.warn("熔断器已打开，LLM请求将快速失败");
// 这种情况无法自动恢复，必须人工介入
alertService.sendCritical("LLM服务不可用，已打开熔断器，需要人工介入");
}
private void handleRepetitionAnomaly() {
log.warn("检测到LLM循环输出，尝试自愈");
// 策略：临时降低temperature，减少输出的随机性和发散
// 注意：这是临时措施，循环输出通常是模型本身的问题，temperature降低不一定有效
llmServicePool.adjustTemperature(-0.1);
// 同时降低max_tokens，让循环在更少内容后就被截断（减少用户损害）
llmServicePool.adjustMaxTokens(0.7); // 降低到70%
alertService.sendWarning("检测到循环输出，已临时降低temperature和max_tokens");
// 30分钟后如果问题消失，自动恢复参数
scheduleParameterRestore(Duration.ofMinutes(30));
}
private void handleVectorSearchDegradation(VectorSearchHealthResult health) {
log.warn("向量检索质量下降: score={}", health.getAverageScore());
if (health.getAverageScore() < 0.3) {
// 严重退化，禁用RAG，直接用纯LLM模式
vectorSearchService.disable();
log.warn("向量检索严重退化，已禁用RAG，切换到纯LLM模式");
alertService.sendWarning("RAG已禁用，使用纯LLM模式，可能影响回答准确性");
} else {
// 轻度退化，降低检索文档数量，减少噪声影响
vectorSearchService.reduceTopK(0.5); // topK减半
alertService.sendWarning("向量检索质量下降，已减少检索文档数量");
}
}
private void enterConservativeMode() {
log.warn("系统健康得分低，进入保守模式");
// 保守模式：降低并发上限，给系统减压
threadPoolManager.reduceConcurrency(0.6); // 降到60%
// 增大超时时间，给LLM更多时间响应
llmServicePool.increaseTimeout(1.5); // 增加50%
alertService.sendWarning("系统进入保守模式，并发已限流");
}
}健康状态的可视化
@RestController
@RequestMapping("/api/health")
public class HealthStatusController {
private final AIDeepHealthProbe deepProbe;
private final HealthStateCache stateCache;
/**
* 综合健康状态面板，给运维人员看的
*/
@GetMapping("/dashboard")
public HealthDashboard getDashboard() {
DeepHealthReport lastReport = deepProbe.getLastReport();
SystemMetrics metrics = metricsCollector.getCurrentMetrics();
List<HealthIndicator> indicators = new ArrayList<>();
// LLM服务状态
indicators.add(HealthIndicator.builder()
.name("LLM服务")
.status(determineLLMStatus(lastReport))
.value(lastReport != null ?
String.format("黄金用例通过率 %.0f%%",
lastReport.getGoldenCasePassRate() * 100) : "未检测")
.lastChecked(lastReport != null ? lastReport.getCheckedAt() : null)
.build());
// 向量检索状态
indicators.add(HealthIndicator.builder()
.name("向量检索")
.status(determineVectorSearchStatus(lastReport))
.value(lastReport != null ?
String.format("平均相关性 %.2f",
lastReport.getVectorSearchHealth().getAverageScore()) : "未检测")
.build());
// 响应质量
indicators.add(HealthIndicator.builder()
.name("响应质量")
.status(determineQualityStatus(metrics))
.value(String.format("近1小时优质回答率 %.0f%%",
metrics.getHighQualityRate() * 100))
.build());
// 系统负载
indicators.add(HealthIndicator.builder()
.name("系统负载")
.status(determineLoadStatus(metrics))
.value(String.format("并发%d/%d，P99延迟%dms",
metrics.getCurrentConcurrency(),
metrics.getMaxConcurrency(),
metrics.getP99LatencyMs()))
.build());
return HealthDashboard.builder()
.overallStatus(determineOverallStatus(indicators))
.indicators(indicators)
.lastUpdated(LocalDateTime.now())
.build();
}
private HealthStatus determineLLMStatus(DeepHealthReport report) {
if (report == null) return HealthStatus.UNKNOWN;
double passRate = report.getGoldenCasePassRate();
if (passRate >= 0.9) return HealthStatus.HEALTHY;
if (passRate >= 0.6) return HealthStatus.DEGRADED;
return HealthStatus.UNHEALTHY;
}
}踩过的坑和经验
坑1：黄金用例选错了
最初选的黄金用例太难，比如"解释量子纠缠"，结果每次检测结果都波动很大，因为好答案可以有很多种。后来改成"只回答数字/只用Yes/No回答"这类有唯一正确答案的问题，结果才稳定可靠。
坑2：自愈操作频率太高
每分钟检查一次，发现轻微异常就调整参数，结果参数被反复修改，系统一直处于"正在调整"的状态，反而不稳定。后来加了"冷却期"——一次自愈操作后30分钟内不再触发新的自愈，等待效果稳定再评估。
坑3：级联自愈导致雪崩
向量检索出问题，自愈把RAG关了；LLM负载因此上升，自愈又把并发降了；并发降了之后排队增加，超时率上升，触发了熔断。整个系统因为"过度自愈"反而阶梯式崩溃。后来加了全局自愈决策协调器，保证同一时间只有一个自愈操作在执行，避免操作叠加。
坑4：深度探针本身成了负担
每5分钟运行一次黄金用例，每次都要实际调用LLM，在高峰期会占用宝贵的LLM配额。后来把深度探针的执行频率改成动态的：系统健康时15分钟一次，有异常信号时5分钟一次，严重问题时1分钟一次。
AI系统的健康不只是"活着"，更是"清醒地活着"。
多维度探针 + 自愈机制，让你的AI系统在凌晨三点出问题的时候，不用把值班人员从床上叫起来。
当然，前提是你的自愈机制本身得健康——关于这个，就是另一篇文章的故事了。