AIOps 入门

# 角色（Role）
你是一名有 10 年经验的资深 SRE，擅长 Kubernetes、Prometheus、Go 后端排障。
你的回答风格：直接、简洁、给可执行的命令，不要复述用户问题。

# 上下文（Context）
## 故障信息
- 服务：order-service（Go 1.22，K8s 集群 prod）
- 现象：5xx 错误率从 0.1% 涨到 15%，持续 8 分钟
- 告警时间：2025-11-01 14:32:00

## 相关指标（最近 10 分钟）
- CPU 使用率：85%（常态 40%）
- 内存使用率：92%，Pod OOMKilled 3 次
- P99 延迟：从 200ms 涨到 3.2s
- 错误日志样本：
  "context deadline exceeded"  x 432
  "connection refused (db:3306)" x 128

## 架构信息
- order-service → MySQL（主从）+ Redis（哨兵）
- 上游：api-gateway，下游：payment-service

# 约束（Constraint）
1. 优先级最高的根因放第一条，不要列超过 3 条
2. 每个根因配 1 个验证命令（kubectl / mysql / redis-cli）
3. 不要建议重启数据库，这是生产主库
4. 如果信息不足，明确说"需要补充 XX 指标"，不要瞎猜

# 任务
对下面的运维日志进行分类，从以下 4 类中选一个：
- NETWORK：网络相关（连接超时、拒绝、DNS 失败）
- RESOURCE：资源相关（CPU/内存/磁盘/文件句柄）
- DEPENDENCY：下游依赖故障（DB/Redis/MQ）
- APPLICATION：应用逻辑错误（panic、空指针、业务异常）

# 示例
日志：dial tcp 10.0.1.5:3306: connect: connection refused
分类：DEPENDENCY

日志：OOMKilled (exit code 137)
分类：RESOURCE

日志：panic: runtime error: invalid memory address or nil pointer dereference
分类：APPLICATION

日志：i/o timeout
分类：NETWORK

# 待分类
日志：{input_log}
分类：

# 任务
分析 Pod `order-service-abc123` 为什么起不来。请按以下步骤推理：

Step 1：列出可能的原因类别（镜像/资源/配置/依赖/权限）
Step 2：针对每个类别，给出对应的事件/指标验证方法
Step 3：根据下面提供的实际事件，排除不可能的类别
Step 4：得出最可能的根因，并给出修复命令

# 实际事件
Events:
  - FailedScheduling      3m   0/3 nodes available: 3 Insufficient memory
  - FailedScheduling      3m   0/3 nodes available: 3 Insufficient memory

Step 1：可能原因
- 资源：节点内存不足，无法满足 Pod requests
- 配置：resources.requests.memory 设得过大
- 调度：节点数太少

Step 2：验证方法
- kubectl describe node | grep -A5 Allocated resources  # 看节点内存分配
- kubectl get pod -o yaml | grep -A3 resources          # 看 Pod 资源请求

Step 3：根据事件排除
- 事件明确写 "3 Insufficient memory"，所以是资源问题
- 不是镜像拉取失败（没有 ImagePullBackOff）
- 不是配置错误（资源配置是合法值，只是节点装不下）

Step 4：根因与修复
根因：3 个节点剩余内存都不够，Pod 一直 Pending
修复：
  # 方案 A：临时扩节点
  kubectl scale nodegroup prod-ng --size 5
  # 方案 B：降低 Pod 资源请求（如果业务允许）
  kubectl patch deployment order-service --type=json \
    -p='[{"op":"replace","path":"/spec/template/spec/containers/0/resources/requests/memory","value":"256Mi"}]'

Thought: 用户报告 order-service 500 错误。先看 Pod 状态。
Action: kubectl get pods -n prod | grep order-service
Observation: 3/4 Running，1 个 CrashLoopBackOff

Thought: 有 Pod 在崩溃。看崩溃原因。
Action: kubectl logs <crashed-pod> -n prod --tail=100
Observation: panic: redis: connection refused

Thought: Redis 连不上。确认 Redis 是否正常。
Action: kubectl get pods -n infra | grep redis
Observation: redis-master-0 Running，但 READY 0/1

Thought: Redis 起来了但没就绪。看 Redis 事件。
Action: kubectl describe pod redis-master-0 -n infra
Observation: Liveness probe failed: NOAUTH Authentication required

Thought: 找到根因——Redis 密码变了但 order-service 没更新配置
Final Answer: 根因是 Redis 密码被修改，order-service 仍用旧密码连接。
修复：更新 order-service 的 Secret。

Plan:
1. 拉取最新镜像 v1.5.0
2. 在 staging 部署，跑冒烟测试
3. 生产灰度 10% 流量，观察 10 分钟
4. 全量发布
5. 监控 SLO 1 小时，无异常则完成

Execute step 1: ...
Execute step 2: ...

┌────────────────────────────────────────────────────────────────┐
│ 1. 数据准备                                                    │
│    - 原始数据采集（日志/告警/SOP/文档）                          │
│    - 清洗、去重、脱敏（密钥、PII 必须处理）                      │
│    - 标注：人工标注金标问答对                                    │
│    - 向量化：embedding 模型把文档转成向量                        │
│    工具：DVC / LakeFS / Unstructured / LangChain loaders        │
└────────────────────────────────────────────────────────────────┘
                              ↓
┌────────────────────────────────────────────────────────────────┐
│ 2. 模型选择与训练                                               │
│    - 基座选型：GPT-4 / Claude / Qwen / Llama（看预算和合规）     │
│    - Prompt 工程：写 system / few-shot                          │
│    - 微调（可选）：SFT 监督微调、DPO 偏好优化                    │
│    工具：OpenAI SDK / vLLM / LLaMA-Factory / Axolotl            │
└────────────────────────────────────────────────────────────────┘
                              ↓
┌────────────────────────────────────────────────────────────────┐
│ 3. 评测（Evaluation）                                          │
│    - 离线评测：准确率 / 召回率 / BLEU / ROUGE                   │
│    - 业务评测：是否解决工单、是否被人工接管                      │
│    - 红队测试：prompt 注入、越狱、敏感问题                      │
│    工具：RAGAS / DeepEval / Promptfoo / 自建 benchmark          │
└────────────────────────────────────────────────────────────────┘
                              ↓
┌────────────────────────────────────────────────────────────────┐
│ 4. 部署推理                                                    │
│    - 模型服务：vLLM / TGI / Triton / SGLang                    │
│    - 接入层：FastAPI + 限流 + 缓存                              │
│    - 流量灰度：1% → 10% → 100%                                  │
│    工具：BentoML / Ray Serve / KServe / LiteLLM                 │
└────────────────────────────────────────────────────────────────┘
                              ↓
┌────────────────────────────────────────────────────────────────┐
│ 5. 监控与反馈                                                  │
│    - 性能：延迟 P50/P99、吞吐、错误率                           │
│    - 质量：用户点赞/踩、人工接管率、幻觉率                       │
│    - 成本：token 消耗、API 费用                                 │
│    - 安全：prompt 注入次数、敏感输出                             │
│    工具：LangSmith / Phoenix / Langfuse / OpenLLMetry           │
└────────────────────────────────────────────────────────────────┘
                              ↓
                    反馈回流到数据准备阶段

# ops_agent.py —— 最小运维 Agent
from langchain.agents import initialize_agent, AgentType
from langchain_openai import ChatOpenAI
from langchain.tools import Tool
from kubernetes import client, config

# 加载 K8s 配置
config.load_kube_config()

def get_pod_status(namespace: str) -> str:
    """查询指定 namespace 下 Pod 状态"""
    v1 = client.CoreV1Api()
    pods = v1.list_namespaced_pod(namespace)
    lines = []
    for p in pods.items:
        lines.append(f"{p.metadata.name}: {p.status.phase}")
    return "\n".join(lines)

def scale_deployment(input_str: str) -> str:
    """扩容 Deployment，输入格式：namespace/dep_name:replicas"""
    # 关键：解析参数要严格校验，防止 LLM 传奇怪值
    try:
        target, replicas = input_str.split(":")
        namespace, dep_name = target.split("/")
        replicas = int(replicas)
        if replicas < 1 or replicas > 20:
            return f"非法副本数 {replicas}，允许范围 1-20"  # 硬限制，防止 LLM 扩到 100
    except Exception as e:
        return f"参数解析失败: {e}"

    apps = client.AppsV1Api()
    body = {"spec": {"replicas": replicas}}
    apps.patch_namespaced_deployment_scale(dep_name, namespace, body)
    return f"已将 {dep_name} 扩容到 {replicas} 副本"

# 定义工具
tools = [
    Tool(
        name="get_pod_status",
        func=get_pod_status,
        description="查询 K8s Pod 状态，输入 namespace 名"
    ),
    Tool(
        name="scale_deployment",
        func=scale_deployment,
        description="扩容 Deployment，输入格式 namespace/dep_name:replicas"
    ),
]

# 初始化 Agent
llm = ChatOpenAI(model="gpt-4o", temperature=0)  # temperature=0 保证稳定
agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True,
    max_iterations=5,         # 硬限制，防止无限循环
    early_stopping_method="generate"
)

# 跑起来
result = agent.run("查看 prod 命名空间 Pod 状态，如果有 Pod 不健康就扩容到 5 副本")
print(result)

{
  "name": "scale_deployment",
  "arguments": {
    "namespace": "prod",
    "deployment": "api-gateway",
    "replicas": 5
  }
}

{
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "query_prometheus",
        "description": "查询 Prometheus 指标。仅支持已知的安全 PromQL，禁止使用子查询。",
        "parameters": {
          "type": "object",
          "properties": {
            "query": {
              "type": "string",
              "description": "PromQL 表达式，例如 rate(http_requests_total[5m])"
            },
            "start": {
              "type": "string",
              "description": "起始时间，ISO 8601 格式"
            },
            "end": {
              "type": "string",
              "description": "结束时间，ISO 8601 格式"
            }
          },
          "required": ["query"]
        }
      }
    },
    {
      "type": "function",
      "function": {
        "name": "scale_deployment",
        "description": "扩缩容 K8s Deployment。需要人工确认后才真正执行。",
        "parameters": {
          "type": "object",
          "properties": {
            "namespace": {
              "type": "string",
              "description": "命名空间"
            },
            "deployment": {
              "type": "string",
              "description": "Deployment 名称"
            },
            "replicas": {
              "type": "integer",
              "minimum": 1,
              "maximum": 20,
              "description": "目标副本数，范围 1-20"
            }
          },
          "required": ["namespace", "deployment", "replicas"]
        }
      }
    },
    {
      "type": "function",
      "function": {
        "name": "restart_pod",
        "description": "重启指定 Pod。仅用于非数据库 Pod。",
        "parameters": {
          "type": "object",
          "properties": {
            "namespace": {
              "type": "string"
            },
            "pod_name": {
              "type": "string"
            },
            "reason": {
              "type": "string",
              "description": "重启原因，会记录到审计日志"
            }
          },
          "required": ["namespace", "pod_name", "reason"]
        }
      }
    },
    {
      "type": "function",
      "function": {
        "name": "search_knowledge_base",
        "description": "搜索运维知识库，返回历史故障复盘、SOP 文档。",
        "parameters": {
          "type": "object",
          "properties": {
            "query": {
              "type": "string",
              "description": "搜索关键词"
            },
            "top_k": {
              "type": "integer",
              "default": 3,
              "minimum": 1,
              "maximum": 10
            }
          },
          "required": ["query"]
        }
      }
    }
  ],
  "tool_choice": "auto"
}

# function_calling.py —— OpenAI Function Calling 示例
import json
from openai import OpenAI

client = OpenAI()

# 可用工具映射
AVAILABLE_FUNCTIONS = {
    "query_prometheus": query_prometheus,
    "scale_deployment": scale_deployment,
    "restart_pod": restart_pod,
    "search_knowledge_base": search_knowledge_base,
}

def run_agent(user_query: str):
    messages = [
        {"role": "system", "content": "你是运维助手，能调用工具处理 K8s/Prometheus 相关任务。"},
        {"role": "user", "content": user_query}
    ]

    # 第一轮：模型决定调哪个函数
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=TOOLS,            # 上面那份 JSON
        tool_choice="auto"
    )
    msg = response.choices[0].message

    # 如果模型决定调用工具
    if msg.tool_calls:
        messages.append(msg)
        for call in msg.tool_calls:
            func_name = call.function.name
            args = json.loads(call.function.arguments)

            # 关键：执行前校验权限和参数
            if func_name in ("scale_deployment", "restart_pod"):
                # 危险动作，必须人工确认
                approved = ask_human_approval(func_name, args)
                if not approved:
                    result = "用户拒绝执行该操作"
                else:
                    result = AVAILABLE_FUNCTIONS[func_name](**args)
            else:
                result = AVAILABLE_FUNCTIONS[func_name](**args)

            messages.append({
                "role": "tool",
                "tool_call_id": call.id,
                "content": str(result)
            })

        # 第二轮：模型基于工具结果生成最终回答
        final = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=TOOLS
        )
        return final.choices[0].message.content

    return msg.content

def ask_human_approval(action: str, args: dict) -> bool:
    """推飞书消息给值班同学，等点确认按钮"""
    # 实际实现省略，返回 True/False
    return True

                    ┌─────────────────────────────────┐
   用户问题          │  Query Rewriting（查询改写）    │
   "订单 500"  ────→ │  改成检索友好的关键词            │
                    │  "订单服务 500 错误 故障排查"     │
                    └──────────────┬──────────────────┘
                                   ↓
                    ┌──────────────────────────────────┐
                    │  Embedding Model（bge-large-zh） │
                    │  把 query 转成 1024 维向量        │
                    └──────────────┬──────────────────┘
                                   ↓
              ┌────────────────────┴────────────────────┐
              ↓                                          ↓
   ┌────────────────────┐                    ┌──────────────────────┐
   │ 向量检索（语义）    │                    │ BM25 检索（关键词）   │
   │ Milvus / pgvector  │                    │ Elasticsearch         │
   │ Top-K = 10         │                    │ Top-K = 10            │
   └─────────┬──────────┘                    └──────────┬────────────┘
             └────────────────────┬─────────────────────┘
                                 ↓
                    ┌──────────────────────────────────┐
                    │ Reranker（bge-reranker-base）    │
                    │ 精排，取 Top 3                    │
                    └──────────────┬──────────────────┘
                                   ↓
                    ┌──────────────────────────────────┐
                    │ LLM 生成回答                      │
                    │ 上下文：召回文档 + 告警信息        │
                    │ 输出：根因 + 处置步骤 + 引用来源   │
                    └──────────────────────────────────┘

# index_docs.py —— 文档入库
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from langchain_milvus import Milvus

# 1. 加载文档（复盘 markdown、SOP、Confluence 导出）
from langchain.document_loaders import DirectoryLoader
loader = DirectoryLoader("./docs", glob="**/*.md")
docs = loader.load()

# 2. 切块：每块 500 字符，重叠 50，保证上下文不断
splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,
    separators=["\n## ", "\n### ", "\n\n", "\n", "。", " "]
)
chunks = splitter.split_documents(docs)

# 3. Embedding：bge-large-zh，中文场景最稳
embeddings = HuggingFaceEmbeddings(
    model_name="BAAI/bge-large-zh-v1.5",
    model_kwargs={"device": "cpu"}     # 没 GPU 就 CPU，慢点但能跑
)

# 4. 存 Milvus
vectorstore = Milvus.from_documents(
    documents=chunks,
    embedding=embeddings,
    connection_args={"host": "milvus", "port": "19530"},
    collection_name="ops_knowledge"
)