Spring Cloud + AI：微服务智能路由、故障自愈与日志分析

3.3 AI 路由决策服务（Python 端）

# ai_route_service.py
import time
from dataclasses import dataclass
from typing import Optional
import requests
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI(title="AI Routing Decision Service")
PROMETHEUS_URL = "http://localhost:9090/api/v1/query"

class RouteRequest(BaseModel):
    service_id: str
    request_path: str
    client_ip: str = ""

class RouteResponse(BaseModel):
    preferred_instance: Optional[str] = None
    confidence: float = 0.0
    reason: str = ""
    latency_ms: float = 0.0

def query_prometheus(query: str) -> dict:
    """从 Prometheus 查询实时指标。"""
    resp = requests.get(PROMETHEUS_URL, params={"query": query}, timeout=5)
    return resp.json().get("data", {}).get("result", [])

@app.post("/route/decide", response_model=RouteResponse)
async def decide_route(req: RouteRequest):
    """基于实时指标 + AI 模型决策最优路由实例。评估维度：响应时间、错误率、CPU 使用率、连接数。"""
    start = time.perf_counter()
    # 查询各实例的 P99 响应时间
    latency_results = query_prometheus(f'histogram_quantile(0.99, sum(rate(http_server_requests_seconds_bucket{{service="{req.service_id}"}}[5m])) by (le, instance))')
    # 查询各实例的错误率
    error_results = query_prometheus(f'sum(rate(http_server_requests_seconds_count{{service="{req.service_id}",status=~"5.."}}[5m])) by (instance) / sum(rate(http_server_requests_seconds_count{{service="{req.service_id}"}}[5m])) by (instance)')
    # 查询 CPU 使用率
    cpu_results = query_prometheus(f'process_cpu_usage{{service="{req.service_id}"}}')
    
    scores = {}
    for item in latency_results:
        instance = item["metric"].get("instance", "")
        latency = float(item["value"][1])
        scores[instance] = scores.get(instance, 0) + latency * 0.4
    for item in error_results:
        instance = item["metric"].get("instance", "")
        error_rate = float(item["value"][1])
        scores[instance] = scores.get(instance, 0) + error_rate * 0.35
    for item in cpu_results:
        instance = item["metric"].get("instance", "")
        cpu = float(item["value"][1])
        scores[instance] = scores.get(instance, 0) + cpu * 0.25

    if scores:
        best_instance = min(scores, key=scores.get)
        best_score = scores[best_instance]
        confidence = max(0.0, 1.0 - best_score)
    else:
        best_instance = None
        confidence = 0.0
        
    latency = (time.perf_counter() - start) * 1000
    return RouteResponse(
        preferred_instance=best_instance,
        confidence=round(confidence, 4),
        reason=f"综合评分：{scores}" if scores else "无可用指标",
        latency_ms=round(latency, 2),
    )

3.4 Gateway 路由配置

server:
  port: 8080
spring:
  cloud:
    gateway:
      routes:
        - id: service-a
          uri: lb://service-a
          predicates:
            - Path=/api/a/**
          filters:
            - name: Retry
              args:
                retries: 3
                statuses: BAD_GATEWAY, GATEWAY_TIMEOUT
                backoff:
                  firstBackoff: 100ms
                  maxBackoff: 500ms
        - id: service-b
          uri: lb://service-b
          predicates:
            - Path=/api/b/**
ai:
  routing:
    enabled: true
    service-url: http://localhost:5001/route/decide
    fallback-strategy: round-robin
    cache-ttl: 10s

四、故障自愈：AI 驱动的动态熔断与恢复

4.1 故障自愈流程

1. 服务调用 -> Resilience4j 熔断器
2. 正常调用或快速失败/降级
3. 判断异常率是否超阈值？
4. 是 -> AI 分析异常模式
5. 是否为系统性故障？
   • 是 -> 触发全局熔断
   • 否 -> 定向熔断问题实例
6. AI 推荐恢复策略，逐步放流验证
7. 验证通过 -> 恢复全量流量
8. AI 降级响应生成

4.2 动态熔断配置管理

/**
 * AI 驱动的动态熔断配置管理器
 * 根据 AI 分析结果动态调整 Resilience4j 熔断器参数
 */
@Component
@Slf4j
public class AiCircuitBreakerManager {
    private final CircuitBreakerRegistry circuitBreakerRegistry;
    private final RestTemplate restTemplate;
    
    @Value("${ai.circuit-breaker.service-url:http://localhost:5001/circuit-breaker/config}")
    private String aiConfigUrl;

    @Scheduled(fixedRate = 30_000) // 每 30 秒动态调整一次
    public void adjustCircuitBreakerConfig() {
        for (String name : circuitBreakerRegistry.getAllCircuitBreakers().stream().map(CircuitBreaker::getName).toList()) {
            CircuitBreaker cb = circuitBreakerRegistry.circuitBreaker(name);
            CircuitBreaker.Metrics metrics = cb.getMetrics();
            CircuitBreakerMetrics snapshot = new CircuitBreakerMetrics(
                name, metrics.getFailureRate(), metrics.getSlowCallRate(),
                metrics.getNumberOfSuccessfulCalls(), metrics.getNumberOfFailedCalls(),
                metrics.getNumberOfBufferedCalls()
            );
            try {
                ResponseEntity<AiCircuitBreakerConfig> response = restTemplate.postForEntity(
                    aiConfigUrl, snapshot, AiCircuitBreakerConfig.class
                );
                AiCircuitBreakerConfig recommended = response.getBody();
                if (recommended != null && recommended.confidence() > 0.8) {
                    applyConfig(name, recommended);
                }
            } catch (Exception e) {
                log.warn("AI 熔断配置服务调用失败：{}", e.getMessage());
            }
        }
    }

    private void applyConfig(String name, AiCircuitBreakerConfig config) {
        CircuitBreakerConfig newConfig = CircuitBreakerConfig.custom()
            .failureRateThreshold(config.failureRateThreshold())
            .slowCallRateThreshold(config.slowCallRateThreshold())
            .slowCallDurationThreshold(Duration.ofMillis(config.slowCallDurationMs()))
            .waitDurationInOpenState(Duration.ofMillis(config.waitDurationInOpenMs()))
            .permittedNumberOfCallsInHalfOpenState(config.permittedCallsInHalfOpen())
            .slidingWindowType(CircuitBreakerConfig.SlidingWindowType.COUNT_BASED)
            .slidingWindowSize(config.slidingWindowSize())
            .build();
        circuitBreakerRegistry.replace(name, newConfig);
        log.info("已更新熔断器 [{}] 配置：{}", name, config);
    }
}

4.3 AI 降级响应服务

/**
 * AI 增强的服务降级处理器
 * 在熔断触发时调用 LLM 生成有意义的降级响应
 */
@Component
public class AiFallbackHandler {
    private final RestTemplate restTemplate;
    
    @Value("${ai.fallback.service-url:http://localhost:5001/fallback/generate}")
    private String fallbackServiceUrl;

    public ResponseEntity<String> handleFallback(String serviceName, String path, Throwable throwable) {
        FallbackRequest request = new FallbackRequest(
            serviceName, path, throwable.getClass().getSimpleName(), throwable.getMessage()
        );
        try {
            ResponseEntity<String> response = restTemplate.postForEntity(
                fallbackServiceUrl, request, String.class
            );
            return ResponseEntity.ok().contentType(MediaType.APPLICATION_JSON).body(response.getBody());
        } catch (Exception e) {
            // AI 服务也不可用，返回静态兜底
            return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
                .body(String.format("{ \"code\": 503, \"message\": \"服务暂时不可用，请稍后重试\", \"service\": \"%s\", \"timestamp\": \"%s\" }", serviceName, Instant.now()));
        }
    }
}

五、智能日志分析：AI 驱动的异常检测与根因定位

5.1 日志分析流水线

微服务日志输出 -> Filebeat 采集 -> Logstash 清洗/转换 -> Elasticsearch 存储 -> Kibana 可视化 -> AI 日志分析模块 -> 异常检测/根因分析 -> 告警通知（钉钉/邮件/Slack）-> 基线更新

5.2 日志异常检测（Python AI 模块）

# ai_log_analyzer.py
import re
import time
from datetime import datetime, timezone
from typing import Optional
import requests
from elasticsearch import Elasticsearch
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI(title="AI Log Analyzer")
es = Elasticsearch(["http://localhost:9200"])
LLM_API_URL = "http://localhost:8000/v1/chat"

class LogEntry(BaseModel):
    timestamp: str
    service: str
    level: str
    message: str
    trace_id: str = ""
    span_id: str = ""
    stack_trace: str = ""

class AnalysisResult(BaseModel):
    is_anomaly: bool
    severity: str  # critical, warning, info
    category: str  # OOM, NetworkError, Timeout, etc.
    root_cause: str
    suggestion: str
    confidence: float

ANOMALY_PATTERNS = [
    (r"OutOfMemoryError|OOM|heap space", "OOM", "critical"),
    (r"Connection refused|ConnectTimeoutException", "NetworkError", "critical"),
    (r"SocketTimeoutException|Read timed out", "Timeout", "warning"),
    (r"DeadlockLoserDataAccessException", "Deadlock", "critical"),
    (r"CircuitBreakerOpenException", "CircuitBreakerOpen", "warning"),
    (r"TooManyRequests|RateLimitExceeded", "RateLimit", "warning"),
    (r"StackOverflowError", "StackOverflow", "critical"),
    (r"Segmentation fault|SIGSEGV", "SegFault", "critical"),
]

def rule_based_detect(log: LogEntry) -> Optional[AnalysisResult]:
    """基于规则的快速异常检测。"""
    if log.level not in ("ERROR", "WARN", "FATAL"):
        return None
    for pattern, category, severity in ANOMALY_PATTERNS:
        if re.search(pattern, log.message + log.stack_trace, re.IGNORECASE):
            return AnalysisResult(
                is_anomaly=True, severity=severity, category=category,
                root_cause=f"规则匹配：{pattern}", suggestion="", confidence=0.9
            )
    return None

def llm_root_cause_analysis(log: LogEntry) -> AnalysisResult:
    """调用 LLM 进行深度根因分析。"""
    prompt = f"""你是一位资深微服务运维专家。请分析以下异常日志，给出：
    1. 异常类别
    2. 严重程度（critical/warning/info）
    3. 根因分析
    4. 修复建议
    日志信息：
    - 时间：{log.timestamp}
    - 服务：{log.service}
    - 级别：{log.level}
    - 消息：{log.message}
    - TraceID: {log.trace_id}
    - 堆栈：{log.stack_trace[:2000]}
    请以 JSON 格式回答，字段：category, severity, root_cause, suggestion"""
    try:
        response = requests.post(LLM_API_URL, json={"prompt": prompt, "max_tokens": 1024, "temperature": 0.3}, timeout=30)
        result = response.json().get("response", "")
        return AnalysisResult(
            is_anomaly=True, severity="warning", category="Unknown",
            root_cause=result[:500], suggestion="请查看详细分析", confidence=0.7
        )
    except Exception as e:
        return AnalysisResult(
            is_anomaly=True, severity="warning", category="AnalysisFailed",
            root_cause=f"LLM 分析失败：{str(e)}", suggestion="请人工排查", confidence=0.3
        )

@app.post("/log/analyze", response_model=AnalysisResult)
async def analyze_log(log: LogEntry):
    """分析单条日志：1. 先用规则引擎快速匹配 2. 规则未命中时调用 LLM 深度分析"""
    result = rule_based_detect(log)
    if result and result.confidence >= 0.8:
        return result
    return llm_root_cause_analysis(log)

@app.post("/log/batch-analyze")
async def batch_analyze(service: str, minutes: int = 10):
    """批量分析指定服务最近 N 分钟的 ERROR 日志。"""
    query = {
        "query": {
            "bool": {
                "must": [
                    {"term": {"service": service}},
                    {"term": {"level": "ERROR"}},
                    {"range": {"timestamp": {"gte": f"now-{minutes}m", "lte": "now"}}}
                ]
            }
        },
        "size": 100,
        "sort": [{"timestamp": {"order": "desc"}}]
    }
    result = es.search(index="microservice-logs-*", body=query)
    hits = result["hits"]["hits"]
    anomalies = []
    for hit in hits:
        source = hit["_source"]
        log = LogEntry(**source)
        analysis = await analyze_log(log)
        if analysis.is_anomaly:
            anomalies.append({"log": source, "analysis": analysis.model_dump()})
    return {"service": service, "total_errors": len(hits), "anomalies_found": len(anomalies), "details": anomalies}

5.3 Spring Boot 日志输出配置

<!-- logback-spring.xml -->
<configuration>
    <appender name="JSON_CONSOLE" class="ch.qos.logback.core.ConsoleEncoder">
        <encoder class="net.logstash.logback.encoder.LogstashEncoder">
            <includeMdc>true</includeMdc>
            <customFields>{ "service": "${spring.application.name}", "env": "${SPRING_PROFILES_ACTIVE:default}" }</customFields>
        </encoder>
    </appender>
    <appender name="AI_ALERT" class="com.example.log.AiAlertAppender">
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>ERROR</level>
        </filter>
    </appender>
    <root level="INFO">
        <appender-ref ref="JSON_CONSOLE"/>
        <appender-ref ref="AI_ALERT"/>
    </root>
</configuration>

5.4 自定义 AI 告警 Appender

/**
 * 自定义 Logback Appender
 * 将 ERROR 级别日志实时发送到 AI 分析模块
 */
@Component
public class AiAlertAppender extends UnsynchronizedAppenderBase<ILoggingEvent> {
    private final RestTemplate restTemplate = new RestTemplate();
    
    @Value("${ai.log-analyzer.url:http://localhost:5001/log/analyze}")
    private String analyzerUrl;

    @Override
    protected void append(ILoggingEvent event) {
        if (!event.getLevel().isGreaterOrEqual(Level.ERROR)) {
            return;
        }
        Map<String, Object> logEntry = Map.of(
            "timestamp", Instant.ofEpochMilli(event.getTimeStamp()).toString(),
            "service", event.getLoggerName(),
            "level", event.getLevel().toString(),
            "message", event.getFormattedMessage(),
            "trace_id", MDC.get("traceId") != null ? MDC.get("traceId") : "",
            "stack_trace", getStackTrace(event)
        );
        try {
            restTemplate.postForEntity(analyzerUrl, logEntry, AnalysisResult.class);
        } catch (Exception e) {
            addWarn("AI 日志分析服务不可用：" + e.getMessage());
        }
    }

    private String getStackTrace(ILoggingEvent event) {
        if (event.getThrowableProxy() == null) return "";
        return StreamSupport.stream(event.getThrowableProxy().getStackTraceElementProxyArray(), false)
            .map(Object::toString).collect(Collectors.joining("\n"));
    }
}

六、Kubernetes 部署编排

6.1 部署拓扑

资源分配估算：

• Spring Cloud 业务服务：35%
• AI 推理服务 (GPU)：25%
• Elasticsearch + Logstash：15%
• Prometheus + Grafana：10%
• Nacos 注册中心：5%
• Kafka 消息队列：5%
• 其他基础设施：5%

6.2 核心部署清单

# k8s/ai-inference-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ai-inference-service
  namespace: ai-platform
spec:
  replicas: 2
  selector:
    matchLabels:
      app: ai-inference
  template:
    metadata:
      labels:
        app: ai-inference
    spec:
      containers:
        - name: inference
          image: registry.example.com/ai-inference:v2.0.0
          ports:
            - containerPort: 5001
          resources:
            limits:
              nvidia.com/gpu: 1
              memory: "16Gi"
            requests:
              memory: "8Gi"
          env:
            - name: LLM_API_URL
              value: "http://llm-service:8000/v1/chat"
            - name: PROMETHEUS_URL
              value: "http://prometheus:9090"
            - name: ELASTICSEARCH_URL
              value: "http://elasticsearch:9200"
          livenessProbe:
            httpGet:
              path: /health
              port: 5001
            initialDelaySeconds: 30
            periodSeconds: 15
          readinessProbe:
            httpGet:
              path: /health
              port: 5001
            initialDelaySeconds: 10
            periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: ai-inference-service
  namespace: ai-platform
spec:
  selector:
    app: ai-inference
  ports:
    - port: 5001
      targetPort: 5001
  type: ClusterIP

七、效果评估与监控

7.1 关键指标看板

7.2 Grafana 监控面板配置

# grafana-dashboard-ai-metrics.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: ai-metrics-dashboard
  namespace: monitoring
data:
  dashboard.json: |
    {
      "dashboard": {
        "title": "AI 增强微服务监控",
        "panels": [
          {
            "title": "AI 路由决策延迟",
            "type": "graph",
            "targets": [
              {
                "expr": "histogram_quantile(0.99, sum(rate(ai_route_decision_duration_seconds_bucket[5m])) by (le))"
              }
            ]
          },
          {
            "title": "AI 熔断器调整次数",
            "type": "stat",
            "targets": [
              {
                "expr": "sum(increase(ai_circuit_breaker_adjustments_total[1h]))"
              }
            ]
          },
          {
            "title": "日志异常检测量",
            "type": "graph",
            "targets": [
              {
                "expr": "sum(rate(ai_log_anomaly_detected_total[5m])) by (severity)"
              }
            ]
          }
        ]
      }
    }

八、总结与展望

本文详细介绍了 Spring Cloud + AI 的三大核心应用场景：

未来演进方向：

• AIOps 平台化：将 AI 运维能力抽象为通用平台，支持多业务线接入
• 多模态分析：结合指标、日志、链路追踪（Trace）进行跨维度关联分析
• 强化学习：让 AI 从历史运维数据中学习，持续优化路由和熔断策略
• 边缘部署：将轻量 AI 推理模型下沉到边缘节点，实现近端决策

参考资源：

• Spring Cloud Gateway：https://spring.io/projects/spring-cloud-gateway
• Resilience4j：https://resilience4j.readme.io
• Elasticsearch：https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html
• vLLM：https://docs.vllm.ai