Kubernetes MCP Server深度测评：AI与云原生管理的完美融合

# 通过pip安装
pip install kubectl-mcp-tool

# 验证安装
kubectl-mcp-tool --version

# 创建虚拟环境
python -m venv mcp-env

# 激活虚拟环境
mcp-env\Scripts\activate

# 在虚拟环境中安装
pip install kubectl-mcp-tool

# 使用pip直接安装（推荐）
pip install kubectl-mcp-tool

# 或使用uv包管理器（针对K8s MCP Server）
curl -Ls https://astral.sh/uv/install.sh | sh
uv python install 3.12

# 使用Docker方式（避免环境冲突）
docker pull chinnareddy578/k8s-mcp-server

# 方法一：pip安装
pip install kubectl-mcp-tool

# 方法二：从源码构建
git clone https://github.com/kubesphere/ks-mcp-server.git
cd ks-mcp-server
go build -o ks-mcp-server cmd/main.go
sudo mv ks-mcp-server /usr/local/bin/

# 方法三：Docker部署
docker run -it \
  -v ${HOME}/.kube:/root/.kube:ro \
  -v ${HOME}/.minikube:/root/.minikube:ro \
  chinnareddy578/k8s-mcp-server

apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: <CA file>
    server: <Server Address>
  name: kubesphere
contexts:
- context:
    cluster: kubesphere
    user: admin
  name: kubesphere
current-context: kubesphere
kind: Config
preferences: {}
users:
- name: admin
  user:
    username: <KubeSphere Username>
    password: <KubeSphere Password>

错误信息：Cannot uninstall 'yaml'. It is a distutils installed project...
解决方案：使用虚拟环境隔离安装，或添加--ignore-installed参数

错误信息：x509: certificate signed by unknown authority
解决方案：确认CA证书是否正确配置，或临时添加--insecure-skip-tls-verify参数

错误信息：User "system:anonymous" cannot list pods in the namespace "default"
解决方案：确保使用的kubeconfig文件具有足够权限，或通过RBAC绑定适当角色

错误信息：Address already in use
解决方案：更换服务端口，或停止占用端口的进程

{
  "mcpServers": {
    "KubeSphere": {
      "args": [
        "stdio",
        "--ksconfig", "/absolute/path/to/your/kubeconfig",
        "--ks-apiserver", "http://your-ks-apiserver:30880"
      ],
      "command": "ks-mcp-server"
    }
  }
}

{
  "mcpServers": {
    "KubeSphere": {
      "command": "ks-mcp-server",
      "args": [
        "stdio",
        "--ksconfig","/absolute/path/to/your/kubeconfig",
        "--ks-apiserver","http://your-ks-apiserver:30880"
      ]
    }
  }
}

# 1. 查看异常Pod
kubectl get pods -n order-service | grep -v Running

# 2. 查看Pod详情
kubectl describe pod order-service-7d8f6c9c5-xxxxx -n order-service

# 3. 查看Pod日志
kubectl logs order-service-7d8f6c9c5-xxxxx -n order-service --previous

# 4. 检查资源使用情况
kubectl top pods -n order-service

# 5. 查看节点状态
kubectl get nodes -o wide

# 6. 检查事件
kubectl get events -n order-service --sort-by='.lastTimestamp'

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { z } from 'zod';
import { exec } from 'child_process';
import { promisify } from 'util';

const execAsync = promisify(exec);

/**
 * 创建Kubernetes诊断MCP服务器
 */
export function createKubernetesDiagnosticsServer() {
  const server = new McpServer({
    name: 'Kubernetes Diagnostics',
    version: '1.0.0',
  });

  /**
   * 注册Pod诊断工具
   */
  server.registerTool(
    'diagnosePodIssues',
    {
      description: '诊断Pod异常问题，包括重启、崩溃、资源不足等',
      inputSchema: {
        namespace: z.string().describe('命名空间名称'),
        podName: z.string().optional().describe('特定Pod名称（可选）'),
        maxLogLines: z.number().default(100).describe('最大日志行数'),
      },
      outputSchema: {
        unhealthyPods: z.array(z.object({
          name: z.string(),
          status: z.string(),
          restarts: z.number(),
          age: z.string(),
        })).describe('不健康的Pod列表'),
        resourceIssues: z.array(z.object({
          podName: z.string(),
          issue: z.string(),
          suggestion: z.string(),
        })).describe('资源问题和建议'),
        recentEvents: z.array(z.object({
          type: z.string(),
          reason: z.string(),
          message: z.string(),
          timestamp: z.string(),
        })).describe('相关事件'),
        logAnalysis: z.string().describe('日志分析摘要'),
      },
    },
    async ({ namespace, podName, maxLogLines }) => {
      try {
        // 1. 获取不健康的Pod
        const getPodsCmd = `kubectl get pods -n ${namespace} --no-headers | grep -v Running`;
        const podsResult = await execAsync(getPodsCmd).catch(() => ({ stdout: '' }));
        
        const unhealthyPods = parsePodList(podsResult.stdout);

        // 2. 获取资源使用情况
        const resourceIssues = await analyzeResourceUsage(namespace);
        
        // 3. 获取相关事件
        const eventsCmd = `kubectl get events -n ${namespace} --sort-by='.lastTimestamp' --field-selector involvedObject.name!=null`;
        const eventsResult = await execAsync(eventsCmd);
        const recentEvents = parseEvents(eventsResult.stdout);

        // 4. 分析Pod日志
        const logAnalysis = await analyzePodLogs(namespace, podName, maxLogLines);

        return {
          content: [{
            type: 'text',
            text: `诊断完成：在${namespace}命名空间中发现${unhealthyPods.length}个异常Pod`,
          }],
          structuredContent: {
            unhealthyPods,
            resourceIssues,
            recentEvents: recentEvents.slice(-10), // 最近10个事件
            logAnalysis,
          },
        };
      } catch (error) {
        throw new Error(`诊断失败: ${error.message}`);
      }
    }
  );

  /**
   * 注册内存泄漏检测工具
   */
  server.registerTool(
    'detectMemoryLeaks',
    {
      description: '检测Pod中可能的内存泄漏问题',
      inputSchema: {
        namespace: z.string().describe('命名空间名称'),
        deploymentName: z.string().describe('部署名称'),
        timeRange: z.string().default('1h').describe('时间范围（如1h、30m）'),
      },
      outputSchema: {
        memoryTrend: z.object({
          trend: z.string(),
          increasePercentage: z.number(),
          suggestion: z.string(),
        }).describe('内存使用趋势'),
        podRestarts: z.number().describe('Pod重启次数'),
        oomKills: z.number().describe('OOMKill次数'),
        recommendations: z.array(z.string()).describe('优化建议'),
      },
    },
    async ({ namespace, deploymentName, timeRange }) => {
      // 实现内存泄漏检测逻辑
      const memoryTrend = await analyzeMemoryTrend(namespace, deploymentName, timeRange);
      const podRestarts = await getPodRestarts(namespace, deploymentName);
      const oomKills = await getOOMKills(namespace, deploymentName);
      
      const recommendations = generateMemoryRecommendations(
        memoryTrend, podRestarts, oomKills
      );

      return {
        structuredContent: {
          memoryTrend,
          podRestarts,
          oomKills,
          recommendations,
        },
      };
    }
  );

  return server;
}

/**
 * 解析Pod列表
 */
function parsePodList(podListOutput) {
  if (!podListOutput.trim()) return [];
  
  return podListOutput.split('\n')
    .filter(line => line.trim())
    .map(line => {
      const parts = line.split(/\s+/);
      return {
        name: parts[0],
        status: parts[2],
        restarts: parseInt(parts[3]) || 0,
        age: parts[4],
      };
    });
}

/**
 * 分析资源使用情况
 */
async function analyzeResourceUsage(namespace) {
  try {
    const topPodsCmd = `kubectl top pods -n ${namespace} --no-headers`;
    const topResult = await execAsync(topPodsCmd);
    
    // 解析资源使用情况并识别问题
    return analyzeResourceConstraints(topResult.stdout);
  } catch (error) {
    return [{ podName: 'All', issue: '无法获取资源指标', suggestion: '确保metrics-server已安装' }];
  }
}

/**
 * 分析Pod日志
 */
async function analyzePodLogs(namespace, podName, maxLogLines) {
  try {
    const logCmd = podName 
      ? `kubectl logs -n ${namespace} ${podName} --tail=${maxLogLines}`
      : `kubectl logs -n ${namespace} --selector=app=order-service --tail=${maxLogLines}`;
    
    const logResult = await execAsync(logCmd);
    return analyzeLogPatterns(logResult.stdout);
  } catch (error) {
    return `日志分析失败: ${error.message}`;
  }
}

// 启动服务器
if (import.meta.url === `file://${process.argv[1]}`) {
  const server = createKubernetesDiagnosticsServer();
  // 启动逻辑...
}