K8s MCP Server

K8s MCP Server

K8s-mcp-server 是一个模型上下文协议 (MCP) 服务器，它使像 Claude 这样的 AI 助手能够安全地执行 Kubernetes 命令。它在语言模型和必要的 Kubernetes CLI 工具（包括 kubectl、helm、istioctl 和 argocd）之间提供了一座桥梁，允许 AI 系统协助集群管理、故障排除和部署。

alexei-led

开发者工具
访问服务器

README

K8s MCP 服务器

CI 状态 发布状态 codecov Python 版本 License: MIT Docker Pulls

K8s MCP 服务器是一个用于 Anthropic 的 MCP (模型上下文协议) 的服务器，它允许在安全、容器化的环境中运行 Kubernetes CLI 工具，例如 kubectl、istioctl、helm 和 argocd。

概述

K8s MCP 服务器充当语言模型（如 Claude）和 Kubernetes CLI 工具之间的安全桥梁。它使语言模型能够执行经过验证的 Kubernetes 命令，检索命令文档，并以结构化的方式处理命令输出。

演示：部署和排除 WordPress 故障

会话 1： 使用 k8s-mcp-server 和 Helm CLI 在 claude-demo 命名空间中部署 WordPress 应用程序，然后通过将 MariaDB StatefulSet 缩放到零来故意破坏它。

会话 2： 故障排除会话，我们使用 k8s-mcp-server 通过 kubectl 命令诊断损坏的 WordPress 站点，识别缺少的数据库问题，并通过放大 StatefulSet 和配置入口访问来修复它。

演示

架构

K8s MCP 服务器的设计重点是安全性、性能和可扩展性。该系统包括以下核心组件：

flowchart TD
    A[AI 助手] <-->|HTTP/WebSocket<br>MCP 协议| B[FastMCP 服务器]
    B --> C[工具注册<br>日志记录和上下文]
    B --> D[提示模板]
    C --> E[命令验证]
    E --> F[CLI 执行器]
    F --> G[特定于工具的处理程序]
    G --> H[kubectl]
    G --> I[helm]
    G --> J[istioctl]
    G --> K[argocd]
    F --> L[安全验证器]
    
    classDef core fill:#f9f,stroke:#333,stroke-width:2px
    classDef tools fill:#bbf,stroke:#333,stroke-width:1px
    classDef security fill:#fbb,stroke:#333,stroke-width:1px
    
    class B,C,D,F core
    class G,H,I,J,K tools
    class E,L security

核心组件

  1. 服务器组件：中央控制器，用于初始化 MCP 服务器、注册工具和提示，以及处理客户端请求。

  2. 安全验证器：检查命令结构和内容，以防止潜在的危险操作，并强制执行严格的验证规则。

  3. CLI 执行器：管理所有 Kubernetes CLI 工具的命令执行、超时处理和输出处理。

  4. 特定于工具的处理程序：每个受支持工具（kubectl、helm、istioctl、argocd）的专用函数，提供适当的命令预处理和响应格式化。

  5. 提示模板：用于常见 Kubernetes 操作的预定义自然语言模板，以改善语言模型交互。

命令执行流程

下图说明了命令如何在系统中流动：

sequenceDiagram
    participant LM as 语言模型
    participant MCP as MCP 服务器
    participant Val as 安全验证器
    participant Exec as CLI 执行器
    participant K8s as K8s CLI 工具
    
    LM->>MCP: 通过 MCP 发送工具请求
    MCP->>Val: 验证命令
    
    alt 无效命令
        Val-->>MCP: 验证错误
        MCP-->>LM: 错误响应
    else 有效命令
        Val->>Exec: 执行命令
        Exec->>K8s: 运行 CLI 工具
        K8s-->>Exec: 命令输出
        Exec-->>MCP: 格式化响应
        MCP-->>LM: 成功响应
    end
  1. 语言模型通过 MCP 协议发送命令请求。
  2. 服务器使用安全规则验证命令。
  3. 如果有效，则使用适当的 CLI 工具执行该命令。
  4. 捕获结果或错误，并将其格式化为结构化响应。
  5. 响应返回到语言模型。

特性

  • 通过适当的验证、超时和错误处理安全地执行 Kubernetes CLI 命令
  • 支持多个 Kubernetes CLI 工具：
    • kubectl：Kubernetes 命令行工具
    • istioctl：Istio 服务网格的命令行工具
    • helm：Kubernetes 包管理器
    • argocd：Kubernetes 的 GitOps 持续交付工具
  • 具有常用 Linux CLI 工具的命令管道功能
  • 详细的命令验证和安全检查
  • 可配置的超时和输出限制
  • 全面的文档和帮助检索
  • 上下文和命名空间管理
  • 用于常见 Kubernetes 操作的预构建提示模板

要求

要将 K8s MCP 服务器与 Claude Desktop 一起使用，您需要：

  • 系统上安装了 Docker
  • ~/.kube/config 中有效的 Kubernetes 配置
  • Claude Desktop 应用程序

配置

K8s MCP 服务器可以通过环境变量进行配置，这些环境变量可以传递到 Docker 容器：

环境变量 描述 默认值 是否必需
K8S_MCP_TIMEOUT 命令的默认超时时间（秒） 300 否
K8S_MCP_MAX_OUTPUT 最大输出大小（字符） 100000 否
K8S_MCP_TRANSPORT 要使用的传输协议（“stdio”或“sse”） stdio 否
K8S_CONTEXT 要使用的 Kubernetes 上下文 当前上下文 否
K8S_NAMESPACE 默认 Kubernetes 命名空间 default 否
K8S_MCP_SECURITY_MODE 安全模式（“strict”或“permissive”） strict 否
K8S_MCP_SECURITY_CONFIG 安全配置 YAML 文件的路径 None 否

例如，要使用特定的上下文和命名空间，请修改您的 Claude Desktop 配置：

{
  "mcpServers": {
    "k8s-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-v",
        "~/.kube:/home/appuser/.kube:ro",
        "-e",
        "K8S_CONTEXT=my-cluster",
        "-e",
        "K8S_NAMESPACE=my-namespace",
        "ghcr.io/alexei-led/k8s-mcp-server:latest"
      ]
    }
  }
}

使用自定义安全配置

要使用自定义安全配置文件，请将其挂载到容器中并设置环境变量：

{
  "mcpServers": {
    "k8s-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-v",
        "~/.kube:/home/appuser/.kube:ro",
        "-v",
        "/path/to/my-security-config.yaml:/app/security_config.yaml:ro",
        "-e",
        "K8S_MCP_SECURITY_CONFIG=/app/security_config.yaml",
        "ghcr.io/alexei-led/k8s-mcp-server:latest"
      ]
    }
  }
}

在宽松模式下运行

要在宽松模式下运行（允许所有命令，包括潜在的危险命令）：

{
  "mcpServers": {
    "k8s-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-v",
        "~/.kube:/home/appuser/.kube:ro",
        "-e",
        "K8S_MCP_SECURITY_MODE=permissive",
        "ghcr.io/alexei-led/k8s-mcp-server:latest"
      ]
    }
  }
}

与 Claude Desktop 集成

要将 K8s MCP 服务器与 Claude Desktop 集成，请按照以下步骤操作：

  1. 找到 Claude Desktop 配置文件：

    • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
    • Windows: %APPDATA%\Claude\claude_desktop_config.json

  2. 编辑配置文件 以包含 K8s MCP 服务器：

    {
  "mcpServers": {
    "kubernetes": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-v",
        "~/.kube:/home/appuser/.kube:ro",
        "ghcr.io/alexei-led/k8s-mcp-server:latest"
      ]
    }
  }
}

    注意：请确保将 ~/.kube 替换为 Kubernetes 配置目录的绝对路径，如果使用自定义镜像，请更新镜像名称。

  3. 重新启动 Claude Desktop 以应用更改

    • 重新启动后，您应该在输入框的右下角看到一个锤子 🔨 图标
    • 这表明 K8s MCP 服务器可供使用
flowchart TD
    subgraph "用户设备"
        config[编辑 claude_desktop_config.json]
        claude[Claude Desktop]
        docker[Docker 容器]
        k8s_config[Kubernetes 配置]
    end

    subgraph "Kubernetes 集群"
        k8s[Kubernetes 服务]
    end

    config -->|添加 MCP 服务器配置| claude
    claude -->|Docker 运行命令| docker
    k8s_config -->|挂载为只读| docker
    docker -->|kubectl & 其他 CLI 工具| k8s

在 Claude 中使用 Kubernetes 工具

配置完成后，您可以要求 Claude 执行 Kubernetes 操作：

  • "使用 kubectl 显示我的默认命名空间中的 pod"
  • "帮助我使用 Helm 部署新的应用程序"
  • "检查我的 Istio 服务网格的状态"
  • "列出我所有的 Kubernetes 部署"

Claude 将自动通过 K8s MCP 服务器使用适当的 Kubernetes CLI 工具。

API 参考

该服务器实现了 模型上下文协议 (MCP) 并提供以下工具：

文档工具

每个 Kubernetes CLI 工具都有自己的文档功能：

  • describe_kubectl(command=None)：获取 kubectl 命令的文档
  • describe_helm(command=None)：获取 Helm 命令的文档
  • describe_istioctl(command=None)：获取 Istio 命令的文档
  • describe_argocd(command=None)：获取 ArgoCD 命令的文档

执行工具

每个 Kubernetes CLI 工具都有自己的执行功能：

  • execute_kubectl(command, timeout=None)：执行 kubectl 命令
  • execute_helm(command, timeout=None)：执行 Helm 命令
  • execute_istioctl(command, timeout=None)：执行 Istio 命令
  • execute_argocd(command, timeout=None)：执行 ArgoCD 命令

命令管道

所有执行工具都支持 Unix 命令管道来过滤和转换输出：

execute_kubectl(command="get pods -o json | jq '.items[].metadata.name'")
execute_helm(command="list | grep nginx")

配置选项

环境变量

变量 描述 默认值 备注
K8S_MCP_TIMEOUT 命令执行超时时间（秒） 300 适用于所有命令
K8S_MCP_MAX_OUTPUT 最大输出大小（字符） 100000 如果超过，则截断输出
K8S_MCP_TRANSPORT 传输协议 "stdio" "stdio" 或 "sse"
K8S_CONTEXT Kubernetes 上下文 current 如果为空，则使用 kubectl current-context
K8S_NAMESPACE 默认命名空间 "default" 应用于所有命令
K8S_MCP_SECURITY_MODE 安全验证模式 "strict" "strict" 或 "permissive"
K8S_MCP_SECURITY_CONFIG 安全配置文件的路径 None YAML 配置文件

安全配置文件格式

安全配置文件使用 YAML 格式，具有以下结构：

# 危险命令前缀（基于前缀匹配）
dangerous_commands:
  kubectl:
    - "kubectl delete"
    - "kubectl drain"
    # ...更多危险命令

# 安全模式例外（基于前缀匹配）
safe_patterns:
  kubectl:
    - "kubectl delete pod"
    - "kubectl delete deployment"
    # ...更多安全模式

# 高级正则表达式模式规则
regex_rules:
  kubectl:
    - pattern: "kubectl\\s+delete\\s+(-[A-Za-z]+\\s+)*--all\\b"
      description: "删除某种类型的所有资源"
      error_message: "向用户显示的自定义错误消息"
    # ...更多正则表达式规则

支持的工具和命令

kubectl

执行和管理 Kubernetes 资源：

kubectl get pods
kubectl get deployments
kubectl describe pod my-pod

istioctl

管理 Istio 服务网格配置：

istioctl analyze
istioctl proxy-status
istioctl dashboard

helm

管理 Helm chart 和发布：

helm list
helm install my-release my-chart
helm upgrade my-release my-chart

argocd

管理 ArgoCD 应用程序：

argocd app list
argocd app get my-app
argocd app sync my-app

测试

K8s MCP 服务器包括全面的测试覆盖，包括单元测试和集成测试。测试架构旨在轻量级、快速且代表真实世界的用法。

flowchart TD
    A[测试框架] --> B[单元测试]
    A --> C[集成测试]
    B --> D[模拟执行器]
    B --> E[验证测试]
    B --> F[安全测试]
    C --> G[KWOK 集群]
    C --> H[本地集群]
    
    classDef unit fill:#bbf,stroke:#333,stroke-width:1px
    classDef integ fill:#fbb,stroke:#333,stroke-width:1px
    
    class B,D,E,F unit
    class C,G,H integ

运行集成测试

集成测试验证 k8s-mcp-server 的命令执行和响应处理。默认情况下，测试使用 KWOK (Kubernetes Without Kubelet) 创建一个轻量级的模拟 Kubernetes 集群进行测试。

前提条件

集成测试需要：

  • 安装了 kubectl 并在您的 PATH 中
  • 安装了 kwokctl 以进行默认的基于 KWOK 的测试（见下文）
  • 可选：helm 用于与 Helm 相关的测试
  • 可选：用于高级测试场景的真实 Kubernetes 集群

选项 1：使用 KWOK（推荐）

KWOK (Kubernetes Without Kubelet) 提供了一个 Kubernetes 集群的轻量级模拟，无需实际的节点或容器执行。这是运行集成测试的默认和推荐方法。

  1. 安装 KWOK：

    # 对于带有 Homebrew 的 macOS：
brew install kwokctl

# 对于 Linux 或手动安装：
KWOK_VERSION=$(curl -s https://api.github.com/repos/kubernetes-sigs/kwok/releases/latest | grep tag_name | cut -d '"' -f 4)
curl -Lo kwokctl https://github.com/kubernetes-sigs/kwok/releases/download/${KWOK_VERSION}/kwokctl-$(go env GOOS)-$(go env GOARCH)
curl -Lo kwok https://github.com/kubernetes-sigs/kwok/releases/download/${KWOK_VERSION}/kwok-$(go env GOOS)-$(go env GOARCH)
chmod +x kwokctl kwok
sudo mv kwokctl kwok /usr/local/bin/

  2. 运行集成测试：

    # 运行所有集成测试（将自动创建 KWOK 集群）
pytest tests/integration -v

# 运行特定测试
pytest tests/integration/test_k8s_tools.py::test_kubectl_version -v

# 跳过 KWOK 集群的清理以进行调试
K8S_SKIP_CLEANUP=true pytest tests/integration -v

测试框架将：

  1. 自动为您的测试创建一个 KWOK 集群
  2. 针对此集群运行所有集成测试
  3. 在测试完成后删除集群（除非 K8S_SKIP_CLEANUP=true）

使用 KWOK 的好处：

  • 极其轻量级（没有真正的容器或节点）
  • 快速启动和关闭（几秒钟而不是几分钟）
  • 一致且可重现的测试环境
  • 没有外部依赖项或复杂的基础设施

选项 2：使用 Rancher Desktop

如果您需要针对真实的 Kubernetes 实现进行测试，Rancher Desktop 提供了一种方便的方式在本地运行 Kubernetes：

  1. 在 Rancher Desktop 中启用 Kubernetes：

    • 打开 Rancher Desktop
    • 转到 Preferences → Kubernetes
    • 确保 Kubernetes 已启用并正在运行

  2. 配置环境变量：

    # 必需：告诉测试使用您现有的集群而不是 KWOK
export K8S_MCP_TEST_USE_EXISTING_CLUSTER=true

# 可选：指定 Rancher Desktop 上下文
export K8S_CONTEXT=rancher-desktop

# 可选：跳过测试命名空间的清理
export K8S_SKIP_CLEANUP=true

  3. 运行集成测试：

    pytest tests/integration -v

选项 3：使用另一个现有的 Kubernetes 集群

用于针对类似生产环境或特定 Kubernetes 发行版进行测试：

# 设置必需的环境变量
export K8S_MCP_TEST_USE_EXISTING_CLUSTER=true

# 可选地指定一个上下文
export K8S_CONTEXT=my-cluster-context

# 运行测试
pytest -m integration

此方法适用于任何 Kubernetes 发行版（EKS、GKE、AKS、k3s、k0s 等）。

选项 4：设置用于开发的本地 Kubernetes 集群

对于本地开发，我们建议设置一个轻量级的 Kubernetes 集群：

使用 k3s（推荐用于 Linux）：

k3s 是一个经过认证的轻量级 Kubernetes 发行版：

# 安装 k3s
curl -sfL https://get.k3s.io | sh -

# 获取 kubeconfig（需要 sudo 才能读取配置）
sudo cat /etc/rancher/k3s/k3s.yaml > ~/.kube/k3s-config
# 修复权限
chmod 600 ~/.kube/k3s-config
# 设置 KUBECONFIG 以使用此文件
export KUBECONFIG=~/.kube/k3s-config

# 验证它是否正在运行
kubectl get nodes

使用 k0s（推荐用于所有平台）：

k0s 是一个零摩擦的 Kubernetes 发行版：

# 安装 k0s
curl -sSLf https://get.k0s.sh | sh

# 创建一个单节点集群
sudo k0s install controller --single
sudo k0s start

# 获取 kubeconfig
sudo k0s kubeconfig admin > ~/.kube/k0s-config
chmod 600 ~/.kube/k0s-config
export KUBECONFIG=~/.kube/k0s-config

# 验证它是否正在运行
kubectl get nodes

使用 Minikube：

Minikube 在 VM 或容器中创建一个本地 Kubernetes 集群：

# 安装 Minikube
# macOS with Homebrew:
brew install minikube

# 启动一个集群
minikube start

# 验证它是否正在运行
kubectl get nodes

使用 Kind (Kubernetes in Docker)：

Kind 使用 Docker 容器作为节点运行 Kubernetes 集群：

# 安装 Kind
# macOS with Homebrew:
brew install kind

# 创建一个集群
kind create cluster --name k8s-mcp-test

# 验证它是否正在运行
kubectl get nodes

使用 K3d (Lightweight Kubernetes)：

K3d 是一个轻量级的包装器，用于在 Docker 中运行 k3s：

# 安装 K3d
# macOS with Homebrew:
brew install k3d

# 创建一个集群
k3d cluster create k8s-mcp-test

# 验证它是否正在运行
kubectl get nodes

集成测试的环境变量

您可以使用以下环境变量自定义集成测试：

环境变量 描述 默认值
K8S_MCP_TEST_USE_KWOK 使用 KWOK 创建测试集群 true
K8S_MCP_TEST_USE_EXISTING_CLUSTER 使用现有集群而不是创建新集群 false
K8S_CONTEXT 用于测试的 Kubernetes 上下文 当前上下文
K8S_SKIP_CLEANUP 跳过测试资源的清理 false

用法示例：

# 强制使用 KWOK，即使设置了其他变量
export K8S_MCP_TEST_USE_KWOK=true
pytest -m integration

# 使用具有特定上下文的现有集群
export K8S_MCP_TEST_USE_EXISTING_CLUSTER=true
export K8S_CONTEXT=my-dev-cluster
pytest -m integration

# 跳过测试资源的清理（对调试很有用）
export K8S_SKIP_CLEANUP=true
pytest -m integration

使用 GitHub Actions 进行持续集成

该项目包括 GitHub Actions 工作流程，可自动运行集成测试：

  1. CI 工作流程：在每个 PR 上运行单元测试，以确保代码质量
  2. 集成测试工作流程：设置 KWOK 集群并针对其运行集成测试

集成测试工作流程：

  • 在 CI 运行器上安装 KWOK
  • 创建一个轻量级的模拟 Kubernetes 集群
  • 安装所有必需的 CLI 工具（kubectl、helm、istioctl、argocd）
  • 运行所有标有“integration”标记的测试
  • 完成后清理 KWOK 集群

您还可以从 GitHub Actions 选项卡手动触发集成测试，并可以选择在需要时启用调试。

为什么使用 KWOK 进行测试？

KWOK (Kubernetes Without Kubelet) 为 Kubernetes 命令执行测试提供了显着的优势：

  1. 轻量级和快速：KWOK 集群在几秒钟内启动，无需容器运行时
  2. 专注于 API 交互：非常适合测试 Kubernetes CLI 命令和 API 响应
  3. 一致的环境：为可预测的测试提供确定性响应
  4. 资源效率：消除了运行实际容器或节点的开销
  5. CI/CD 友好：非常适合资源需求最少的持续集成管道

由于我们的集成测试主要验证命令形成、执行和输出解析，而不是实际的工作负载行为，因此 KWOK 提供了保真度和效率的理想平衡。

安全注意事项

该服务器包括多个安全功能：

  • 隔离：在 Docker 中运行时，服务器在隔离的容器环境中运行
  • 只读访问：将 Kubernetes 配置挂载为只读 (-v ~/.kube:/home/appuser/.kube:ro)
  • 非 root 执行：所有进程都以容器内的非 root 用户身份运行
  • 命令验证：潜在的危险命令需要显式的资源名称
  • 上下文分离：自动上下文和命名空间注入命令

安全模式和配置

K8s MCP 服务器支持两种安全模式和可自定义的安全规则：

  • 严格模式（默认）：所有命令都根据安全规则进行验证
  • 宽松模式：跳过安全验证，允许执行所有命令

设置安全模式

要在宽松模式下运行（允许所有命令）：

{
  "mcpServers": {
    "k8s-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-v",
        "~/.kube:/home/appuser/.kube:ro",
        "-e",
        "K8S_MCP_SECURITY_MODE=permissive",
        "ghcr.io/alexei-led/k8s-mcp-server:latest"
      ]
    }
  }
}

自定义安全规则

可以使用 YAML 配置文件自定义安全规则。这比内置规则提供了更大的灵活性。

  1. 创建安全配置文件： 使用您的自定义规则创建一个 YAML 文件（例如，security_config.yaml）：

    # k8s-mcp-server 的安全配置

# 潜在的危险命令模式（基于前缀）
dangerous_commands:
  kubectl:
    - "kubectl delete"
    - "kubectl drain"
    # 在此处添加您的自定义危险命令

# 安全模式覆盖（基于前缀）
safe_patterns:
  kubectl:
    - "kubectl delete pod"
    - "kubectl delete deployment"
    # 在此处添加您的自定义安全模式

# 高级正则表达式模式规则
regex_rules:
  kubectl:
    - pattern: "kubectl\\s+delete\\s+(-[A-Za-z]+\\s+)*--all\\b"
      description: "删除某种类型的所有资源"
      error_message: "删除所有资源受到限制。指定要删除的单个资源。"
    # 在此处添加您的自定义正则表达式规则

  2. 在 Docker 中挂载配置文件：

    {
  "mcpServers": {
    "k8s-mcp-server": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-v",
        "~/.kube:/home/appuser/.kube:ro",
        "-v",
        "/path/to/security_config.yaml:/security_config.yaml:ro",
        "-e",
        "K8S_MCP_SECURITY_CONFIG=/security_config.yaml",
        "ghcr.io/alexei-led/k8s-mcp-server:latest"
      ]
    }
  }
}

配置结构

安全配置 YAML 文件有三个主要部分：

  1. dangerous_commands：每个工具都被认为是危险的命令前缀的字典
  2. safe_patterns：覆盖危险命令的命令前缀的字典（例外）
  3. regex_rules：用于更复杂验证规则的高级正则表达式模式

每个正则表达式规则应包括：

  • pattern：要与命令匹配的正则表达式模式
  • description：规则检查的内容的描述
  • error_message：违反规则时显示的自定义错误消息

示例

示例 1：限制命名空间操作

regex_rules:
  kubectl:
    - pattern: "kubectl\\s+.*\\s+--namespace=kube-system\\b"
      description: "kube-system 命名空间中的操作"
      error_message: "kube-system 命名空间中的操作受到限制。"

示例 2：允许其他安全模式

safe_patterns:
  kubectl:
    - "kubectl delete pod"
    - "kubectl delete job"
    - "kubectl delete cronjob"

示例 3：限制危险的文件系统访问

regex_rules:
  kubectl:
    - pattern: "kubectl\\s+exec\\s+.*\\s+-[^-]*c\\s+.*(rm|mv|cp|curl|wget|chmod)\\b"
      description: "exec 中的危险文件操作"
      error_message: "kubectl exec 中的文件系统操作受到限制。"

项目架构和代码结构

K8s MCP 服务器围绕模块化架构组织，该架构分离了关注点并提高了可维护性：

flowchart TD
    A[__main__.py] --> B[server.py]
    B --> C[config.py]
    B --> D[cli_executor.py]
    B --> E[prompts.py]
    D --> F[security.py]
    D --> G[tools.py]
    D --> H[errors.py]
    B --> I[logging_utils.py]
    
    classDef core fill:#f9f,stroke:#333,stroke-width:2px
    classDef utils fill:#bbf,stroke:#333,stroke-width:1px
    
    class A,B,D core
    class C,E,F,G,H,I utils

主要组件：

  1. server.py：中央组件，用于初始化 MCP 服务器、注册工具和提示，以及管理客户端连接。它实现了模型上下文协议并处理请求/响应生命周期。

  2. cli_executor.py：管理 CLI 命令的执行，包括适当的验证、超时处理和错误捕获。它在抽象工具请求和具体 CLI 命令之间进行转换。

  3. security.py：实现命令验证规则和安全检查，以防止潜在的危险操作。它强制限制允许的命令和参数。

  4. tools.py：定义用于处理 Kubernetes 命令的常用实用程序、数据结构和帮助程序函数。

  5. prompts.py：注册并定义用于常见 Kubernetes 操作的模板提示，以改善 AI 交互。

  6. config.py：管理服务器的配置设置，包括环境变量、默认值和支持的 CLI 工具。

  7. errors.py：提供标准化的错误处理、自定义异常和错误格式化。

  8. logging_utils.py：在整个应用程序中实现一致的日志记录基础设施。

设计原则：

  • 关注点分离：每个模块都有明确定义的职责和角色。
  • 集中式配置：设置通过单个配置模块进行管理。
  • 标准化错误处理：所有组件之间的一致错误处理。
  • 可扩展性：该架构可以轻松地添加对新 Kubernetes CLI 工具的支持。
  • 安全第一：安全验证集成在整个命令生命周期中。
  • 容错能力：强大的错误处理和恢复机制。

这种架构在保持简单性的同时实现了灵活性，组件之间具有清晰的接口和明确定义的职责。

对于贡献者

如果您有兴趣为 K8s MCP 服务器做出贡献，以下是项目结构的概述：

项目结构

k8s-mcp-server/
├── src/
│   └── k8s_mcp_server/
│       ├── server.py       # MCP 服务器初始化和工具注册

推荐服务器

Playwright MCP Server

Playwright MCP Server

一个模型上下文协议服务器，它使大型语言模型能够通过结构化的可访问性快照与网页进行交互，而无需视觉模型或屏幕截图。

官方
精选
TypeScript
Magic Component Platform (MCP)

Magic Component Platform (MCP)

一个由人工智能驱动的工具，可以从自然语言描述生成现代化的用户界面组件，并与流行的集成开发环境（IDE）集成，从而简化用户界面开发流程。

官方
精选
本地
TypeScript
MCP Package Docs Server

MCP Package Docs Server

促进大型语言模型高效访问和获取 Go、Python 和 NPM 包的结构化文档，通过多语言支持和性能优化来增强软件开发。

精选
本地
TypeScript
Claude Code MCP

Claude Code MCP

一个实现了 Claude Code 作为模型上下文协议（Model Context Protocol, MCP）服务器的方案，它可以通过标准化的 MCP 接口来使用 Claude 的软件工程能力（代码生成、编辑、审查和文件操作）。

精选
本地
JavaScript
@kazuph/mcp-taskmanager

@kazuph/mcp-taskmanager

用于任务管理的模型上下文协议服务器。它允许 Claude Desktop（或任何 MCP 客户端）在基于队列的系统中管理和执行任务。

精选
本地
JavaScript
mermaid-mcp-server

mermaid-mcp-server

一个模型上下文协议 (MCP) 服务器，用于将 Mermaid 图表转换为 PNG 图像。

精选
JavaScript
Jira-Context-MCP

Jira-Context-MCP

MCP 服务器向 AI 编码助手（如 Cursor）提供 Jira 工单信息。

精选
TypeScript
Linear MCP Server

Linear MCP Server

一个模型上下文协议（Model Context Protocol）服务器，它与 Linear 的问题跟踪系统集成，允许大型语言模型（LLM）通过自然语言交互来创建、更新、搜索和评论 Linear 问题。

精选
JavaScript
Sequential Thinking MCP Server

Sequential Thinking MCP Server

这个服务器通过将复杂问题分解为顺序步骤来促进结构化的问题解决，支持修订，并通过完整的 MCP 集成来实现多条解决方案路径。

精选
Python
Curri MCP Server

Curri MCP Server

通过管理文本笔记、提供笔记创建工具以及使用结构化提示生成摘要，从而实现与 Curri API 的交互。

官方
本地
JavaScript