Cluster Insights MCP Rs

群集洞察MCP服务器

通过模型上下文协议（MCP）进行Kubernetes集群资源分析和管理

  

一个用Rust开发的生产就绪模型上下文协议（MCP）服务器，提供智能Kubernetes集群分析和资源管理功能。该项目演示了LLM如何通过标准化的MCP接口与实时Kubernetes集群进行交互。

为什么要为Kubernetes提供MCP服务器？

挑战： 管理Kubernetes集群需要了解复杂的资源分配、容量规划和解决资源限制问题。平台工程师、SRE和开发人员经常问这样的问题：

• *“我们是否有足够的资源来部署这个新的工作负载？”*
• *“哪些吊舱消耗的资源最多？”*
• *“为什么我的命名空间容量不足？”*
• *“我们集群的资源利用率是多少？”*

解决方案： 此MCP服务器弥合了会话式AI和Kubernetes集群管理之间的差距，实现了将自然语言查询转化为实时集群见解。

优点：

• 自然语言接口：用简单的英语提问，而不是复杂的kubectl命令
• 实时洞察：直接通过kubeconfig查询实时集群数据
• AI驱动的分析：让LLM解释资源数据并提供建议
• 生产就绪：采用Rust构建，性能、安全性和可靠性高
• 安全：使用现有的kubeconfig凭据-不需要额外的身份验证

⚠️ 免责声明

这是一个演示/示例项目 它连接到实时Kubernetes集群。该软件：

• 需要正确的kubeconfig设置 访问您的集群
• 仅执行READ操作 -不修改群集状态
• 应首先在非生产环境中进行测试
• 作为MCP服务器实现的技术示例
• 不受Kubernetes、Red Hat或OpenShift的正式支持

对于生产部署，确保适当的RBAC权限和安全审查。

介绍

管理Kubernetes的平台团队（包括OpenShift、EKS、GKE、AKS）在资源分配和容量规划方面面临着持续的挑战。传统工具需要专业知识和多个命令来回答简单的问题。

此MCP服务器启用 会话式集群管理 通过为AI助手提供六个强大的Kubernetes洞察功能，可以通过现有的kubeconfig查询实时集群数据

🎯 特性

• 6 Kubernetes洞察功能：实时集群资源分析和容量规划
• 实时集群集成：通过kubeconfig连接到任何Kubernetes集群
• 零集群修改：只读操作确保集群安全
• 资源分析：跨节点和命名空间的CPU、内存和pod指标
• 容量规划：部署前检查工作负载是否合适
• 复制品规划：扩展应用程序的智能容量检查
• 容器化：生产就绪的Podman/Docker设置
• Claude桌面集成：MCPB封装，实现无缝AI助手集成
• 专业版本管理：与货物放行自动版本同步
• CI/CD管道：全面的GitHub操作工作流程
• 生产等级：采用Rust构建，性能可靠

📚 快速参考

📋 可用功能

备注：所有函数都通过kubeconfig查询实时集群数据-没有模拟，真正的见解！

查询示例

📊 集群容量概述

自然语言查询： *“我的Kubernetes集群的总容量是多少？”*

示例响应：

{
  "total_cpu_cores": 24.0,
  "total_memory_gb": 96.0,
  "allocated_cpu_cores": 12.5,
  "allocated_memory_gb": 48.2,
  "available_cpu_cores": 11.5,
  "available_memory_gb": 47.8,
  "node_count": 3,
  "explanation": "Cluster has 3 nodes. Total capacity: 24.00 CPU cores, 96.00 GB memory. 
                  Allocated (requests): 12.50 CPU cores (52.1%), 48.20 GB memory (50.2%). 
                  Available: 11.50 CPU cores, 47.80 GB memory."
}

✅ 资源匹配检查

自然语言查询： *“我可以部署需要4个CPU内核和16GB内存的工作负载吗？”*

示例响应：

{
  "fits": true,
  "available_cpu_cores": 11.5,
  "available_memory_gb": 47.8,
  "cpu_utilization_percent": 68.8,
  "memory_utilization_percent": 66.9,
  "explanation": "Resources FIT in cluster. Requested: 4.00 CPU cores, 16.00 GB memory. 
                  Available: 11.50 CPU cores, 47.80 GB memory. 
                  After allocation, cluster would be at 68.8% CPU and 66.9% memory utilization."
}

🖥️ 节点分解

自然语言查询： *“显示集群中每个节点的资源细分”*

示例响应：

{
  "nodes": [
    {
      "name": "node-1",
      "total_cpu_cores": 8.0,
      "total_memory_gb": 32.0,
      "allocated_cpu_cores": 4.2,
      "allocated_memory_gb": 16.5,
      "available_cpu_cores": 3.8,
      "available_memory_gb": 15.5,
      "pod_count": 24
    },
    {
      "name": "node-2", 
      "total_cpu_cores": 8.0,
      "total_memory_gb": 32.0,
      "allocated_cpu_cores": 4.8,
      "allocated_memory_gb": 17.2,
      "available_cpu_cores": 3.2,
      "available_memory_gb": 14.8,
      "pod_count": 28
    },
    {
      "name": "node-3",
      "total_cpu_cores": 8.0,
      "total_memory_gb": 32.0,
      "allocated_cpu_cores": 3.5,
      "allocated_memory_gb": 14.5,
      "available_cpu_cores": 4.5,
      "available_memory_gb": 17.5,
      "pod_count": 20
    }
  ],
  "total_nodes": 3,
  "explanation": "Cluster has 3 nodes. Each node shows total capacity, allocated resources (requests), 
                  available resources, and pod count."
}

📦 命名空间使用情况

自然语言查询： *“哪些命名空间使用的资源最多？”*

示例响应：

{
  "namespaces": [
    {
      "namespace": "production",
      "cpu_requests_cores": 6.5,
      "memory_requests_gb": 24.0,
      "cpu_limits_cores": 12.0,
      "memory_limits_gb": 48.0,
      "pod_count": 35
    },
    {
      "namespace": "staging",
      "cpu_requests_cores": 3.2,
      "memory_requests_gb": 12.8,
      "cpu_limits_cores": 6.0,
      "memory_limits_gb": 24.0,
      "pod_count": 18
    },
    {
      "namespace": "development",
      "cpu_requests_cores": 2.8,
      "memory_requests_gb": 11.4,
      "cpu_limits_cores": 5.0,
      "memory_limits_gb": 20.0,
      "pod_count": 22
    }
  ],
  "total_namespaces": 3,
  "explanation": "Cluster has 3 namespaces. Resource usage shows CPU/memory requests and limits for each namespace, 
                  sorted by CPU requests (descending)."
}

🔝 顶级资源消耗Pod

自然语言查询： *“哪些吊舱消耗的资源最多？”*

示例响应：

{
  "top_pods": [
    {
      "name": "postgres-db-0",
      "namespace": "production",
      "cpu_requests_millicores": 2000,
      "memory_requests_mb": 4096,
      "cpu_limits_millicores": 4000,
      "memory_limits_mb": 8192,
      "node": "node-1"
    },
    {
      "name": "redis-cluster-0",
      "namespace": "production",
      "cpu_requests_millicores": 1500,
      "memory_requests_mb": 3072,
      "cpu_limits_millicores": 3000,
      "memory_limits_mb": 6144,
      "node": "node-2"
    }
  ],
  "total_pods": 72,
  "sorted_by": "CPU requests (descending)",
  "explanation": "Showing top 20 pods (out of 72) by CPU requests. Each pod shows CPU/memory requests and limits, 
                  along with the node it's scheduled on."
}

🔄 检查副本容量（新增！）

自然语言查询： *“在命名空间默认值中，我是否有足够的容量再容纳10个应用程序副本？”*

它的作用：

• 在指定的命名空间中查找与您的应用程序名称匹配的现有pod
• 计算每个副本的资源需求
• 检查群集是否有足够的容量来容纳所请求的额外副本数量
• 提供关于预计利用率的详细分析

示例响应（成功）：

{
  "fits": true,
  "reference_pod": "my-application-7f8b5c9d6-abc12",
  "cpu_per_replica_cores": 0.5,
  "memory_per_replica_gb": 1.0,
  "total_cpu_required_cores": 5.0,
  "total_memory_required_gb": 10.0,
  "available_cpu_cores": 11.5,
  "available_memory_gb": 47.8,
  "current_pod_count": 3,
  "projected_cpu_utilization_percent": 72.9,
  "projected_memory_utilization_percent": 60.6,
  "explanation": "✓ Capacity CHECK PASSED: You can add 10 more replicas of 'my-application' in namespace 'default'.
  
  Reference pod: my-application-7f8b5c9d6-abc12
  - CPU per replica: 0.500 cores
  - Memory per replica: 1.000 GB
  
  Total required for 10 replicas:
  - CPU: 5.000 cores
  - Memory: 10.000 GB
  
  Cluster availability:
  - Available CPU: 11.500 cores (enough for 23 replicas)
  - Available Memory: 47.800 GB (enough for 47 replicas)
  
  Projected utilization after adding replicas:
  - CPU: 72.9% (current: 52.1%)
  - Memory: 60.6% (current: 50.2%)
  
  Current pods matching 'my-application': 3"
}

示例响应（容量不足）：

{
  "fits": false,
  "reference_pod": "my-application-7f8b5c9d6-abc12",
  "cpu_per_replica_cores": 2.0,
  "memory_per_replica_gb": 4.0,
  "total_cpu_required_cores": 20.0,
  "total_memory_required_gb": 40.0,
  "available_cpu_cores": 11.5,
  "available_memory_gb": 47.8,
  "current_pod_count": 3,
  "projected_cpu_utilization_percent": 135.4,
  "projected_memory_utilization_percent": 92.1,
  "explanation": "✗ Capacity CHECK FAILED: Cannot add 10 replicas of 'my-application' in namespace 'default'.
  
  Reference pod: my-application-7f8b5c9d6-abc12
  - CPU per replica: 2.000 cores
  - Memory per replica: 4.000 GB
  
  Total required for 10 replicas:
  - CPU: 20.000 cores
  - Memory: 40.000 GB
  
  Issues:
  CPU shortage: Need 20.000 cores but only 11.500 available (shortfall: 8.500 cores). Maximum possible replicas based on CPU: 5
  
  Current pods matching 'my-application': 3"
}

主要优势：

• ✅ 一步容量检查 -无需手动计算副本资源
• ✅ 自动资源发现 -查找现有Pod并提取需求
• ✅ 明确的建议 -显示可能的副本数量
• ✅ 预计利用率 -查看扩展后的集群状态
• ✅ 可操作的见解 -立即回答是/否，并给出详细的推理

💡 LLM集成的使用技巧

使用此MCP代理查询LLM时：

1. 用自然语言提问 -无需了解Kubernetes API的详细信息

- *“在命名空间默认值中，我是否有足够的容量再容纳10个应用程序副本？”* - *“哪个命名空间占用了所有内存？”* - *“显示所有节点的资源利用率”*

1. 容量规划方案

- *“我需要部署5个Pod，每个Pod有500万CPU和1GB RAM——它们合适吗？”* - *“我当前的集群利用率是多少？”* - *“有多少CPU可用于新的工作负载？”*

1. 故障排除

- *“为什么我不能在开发命名空间中安排更多的Pod？”* - *“我应该考虑缩小哪些Pod以释放资源？”* - *“是否有任何节点被严重过度分配？”*

1. 资源优化

- *“比较生产命名空间和暂存命名空间之间的资源使用情况”* - *“查找资源最密集的前5个应用程序”* - *“我的节点上的资源分布情况如何？”*

1. 结合人工智能建议

- LLM可以分析原始数据并提供智能见解 - 根据当前的利用模式征求建议 - 获取资源优化和再平衡建议

🚀 快速开始

先决条件

• 锈蚀1.70+(安装Rust)
• 货物（含铁锈）
• Kubernetes集群访问 有效的 ~/.kube/config
• jq 用于JSON处理(安装jq)
• cargo-release 对于版本管理： cargo install cargo-release
• NodeJS 19+用于测试 MCP 检查员 （可选）

🔐 群集访问设置

此MCP服务器通过kubeconfig读取集群数据。确保您有权访问：

# Verify cluster access
kubectl cluster-info
kubectl get nodes

# The MCP server will use the current context in ~/.kube/config
kubectl config current-context

支持的Kubernetes平台：

• 香草Kubernetes
• 红帽OpenShift
• 亚马逊EKS
• 谷歌GKE
• Azure AKS
• 任何与kubeconfig兼容的集群

📥 安装

# Clone the repository
git clone https://github.com/alpha-hack-program/cluster-insights-mcp-rs.git
cd cluster-insights-mcp-rs

🏗️ 构建

# Build all servers
make build-all

# Or build individually
make build-mcp      # MCP HTTP Server
make build-stdio    # STDIO Server for Claude

🧪 单元测试

# Run all tests
make test

🏃‍♂️ 跑步

注： 默认情况下 BIND_ADDRESS=127.0.0.1:8001 为了 流式HTTP 但在 *生成文件* test-mcp 目标集 BIND_ADDRESS=0.0.0.0:8001

# MCP Streamable HTTP Server
make test-mcp

# Or directly
RUST_LOG=info BIND_ADDRESS=127.0.0.1:8003 ./target/release/mcp_server

🧪 使用MCP检验员进行测试

让我们在一个终端中使用Streamable HTTP传输运行MCP服务器：

make test-mcp

输出：

2024-10-18T10:15:32.123Z INFO  Cluster Insights MCP Server starting...
2024-10-18T10:15:32.125Z INFO  Streamable HTTP server listening on http://0.0.0.0:8001

使用以下命令运行MCP检查器 make inspector:

注： 必须安装NodeJS 19+

$ make inspector
npx @modelcontextprotocol/inspector
Starting MCP inspector...
⚙️ Proxy server listening on 127.0.0.1:6277
🔑 Session token: 6f0fdc22e2a9775a95d60c976b37b873bffec1816002fc702ca8ec7186a7c338
Use this token to authenticate requests or set DANGEROUSLY_OMIT_AUTH=true to disable auth

🔗 Open inspector with token pre-filled:
   http://localhost:6274/?MCP_PROXY_AUTH_TOKEN=6f0fdc22e2a9775a95d60c976b37b873bffec1816002fc702ca8ec7186a7c338

🔍 MCP Inspector is up and running at http://127.0.0.1:6274 🚀

打开浏览器，指向预先填充令牌的URL。

MCP Inspector

确保：

• 运输类型： SSE
• 网址： http://localhost:8003/sse

然后单击 connect.

MCP Inspector Connect

现在点击 List Tools，然后您应该看到工具列表：

MCP Inspector List Tools

最后点击 get_cluster_capacity 然后单击 Run tool:

MCP Inspector Run Tool

您应该从Kubernetes集群中看到真实的集群容量数据！

预期产量：

{
  "total_cpu_cores": 24.0,
  "total_memory_gb": 96.0,
  "allocated_cpu_cores": 12.5,
  "allocated_memory_gb": 48.2,
  "available_cpu_cores": 11.5,
  "available_memory_gb": 47.8,
  "node_count": 3,
  "explanation": "Cluster has 3 nodes. Total capacity: 24.00 CPU cores..."
}

祝贺您的Cluster Insights工具已准备好供启用MCP的代理使用。

📦 Claude桌面集成

包装

# Create MCP Bundle (MCPB) package for Claude Desktop
$ make pack
cargo build --release --bin stdio_server
   Compiling cluster-insights-mcp-server v1.0.8 (/Users/.../cluster-insights-mcp-rs)
    Finished `release` profile [optimized] target(s) in 18.23s
Packing MCP server for Claude Desktop...
chmod +x ./target/release/stdio_server
zip -rX cluster-insights-mcp-server.mcpb -j mcpb/manifest.json ./target/release/stdio_server
updating: manifest.json (deflated 49%)
updating: stdio_server (deflated 63%)

克劳德配置示例

打开克劳德桌面并转到 Settings->Extensions 下降区域。

备注：这展示了MCP集成模式，不适用于实际数据的生产使用。

拖放 MCPB 文件。

Install extension

点击 Install:

Install extension

点击 Install:

Install extension

点击 Configure 然后关闭对话框。

Install extension

您已经准备好了，打开一个新的聊天：

Install extension

使用此示例查询： *“我的Kubernetes集群的当前容量是多少？请显示总资源以及当前分配的资源量。”*

Install extension

祝贺Cluster Insights工具现在与Claude Desktop配合使用，可以分析您的实时Kubernetes集群。

🔧 配置

环境变量

# Logging level (debug, info, warn, error)
RUST_LOG=info           

# Or use BIND_ADDRESS directly
BIND_ADDRESS=127.0.0.1:8000

示例用法

MCP服务器使用以下命令自动连接到Kubernetes集群 ~/.kube/config.

查询集群容量

通过MCP检查员或克劳德： 只需问： *“我的集群容量是多少？”*

该工具将从集群返回实时数据，显示总CPU/内存、分配的资源和可用性。

检查资源匹配度

通过MCP检查员： 使用 check_resource_fit 带有参数的工具：

{
  "cpu_cores": 4.0,
  "memory_gb": 16.0
}

通过克劳德/法学硕士： 问： *“我可以部署需要4个CPU内核和16GB内存的工作负载吗？”*

重要：所有查询都会从实际的Kubernetes集群返回实时数据。

🐳 容器化

构建并运行

这需要 podman 或 docker配置是通过以下方式进行管理的 .env 文件。

# Build container image
scripts/image.sh build

# Run locally
scripts/image.sh run

# Run from remote registry
scripts/image.sh push
scripts/image.sh run-remote

# Show container information
scripts/image.sh info

容器的环境变量

# Production configuration with kubeconfig
podman run -p 8001:8001 \
  -v ~/.kube/config:/app/.kube/config:ro \
  -e KUBECONFIG=/app/.kube/config \
  -e BIND_ADDRESS=0.0.0.0:8001 \
  -e RUST_LOG=info \
  quay.io/atarazana/cluster-insights-mcp-server:latest

安全说明：容器需要对kubeconfig具有读取权限才能查询集群。未经适当身份验证，切勿公开此容器。

🛠️ 发展

可用命令

🏗️ 构建命令

make build-all              # Build all servers
make build-mcp              # Build MCP server (streamable-http)
make build-stdio            # Build stdio server
make pack                   # Pack MCP server for Claude Desktop

🚀 放行命令（货物放行）

make release-patch          # Create patch release (1.0.6 → 1.0.7)
make release-minor          # Create minor release (1.0.6 → 1.1.0)
make release-major          # Create major release (1.0.6 → 2.0.0)
make release-dry-run        # Show what release-patch would do
make sync-version           # Manually sync version to all files

🧪 测试命令

make test                   # Run all tests
make test-mcp               # Test MCP server locally

🔧 开发命令

make clean                  # Clean build artifacts
make help                   # Show all available commands

项目结构

├── src/                                    # Source code
│   ├── common/
│   │   ├── cluster_insights.rs            # Kubernetes cluster analysis logic
│   │   ├── metrics.rs                     # Prometheus metrics
│   │   └── mod.rs
│   ├── mcp_server.rs                      # MCP HTTP Server
│   └── stdio_server.rs                    # STDIO Server
├── scripts/                               # Utility scripts
│   ├── sync-manifest-version.sh           # Version sync for cargo-release
│   └── image.sh                          # Container management script
├── mcpb/
│   └── manifest.json                      # Claude Desktop manifest
├── .github/workflows/                     # CI/CD pipelines
│   └── ci.yml                            # GitHub Actions workflow
├── docs/                                  # Documentation
├── .env                                   # Environment variables
├── Containerfile                          # Container definition
├── Cargo.toml                            # Rust package manifest
└── Makefile                              # Build commands

功能参数

get_cluster_capacity

无需参数

退货：

• total_cpu_cores：群集CPU总容量
• total_memory_gb：群集内存总容量
• allocated_cpu_cores：Pod已请求CPU
• allocated_memory_gb：Pod已请求内存
• available_cpu_cores：可用CPU容量
• available_memory_gb：可用内存容量
• node_count：节点数量
• explanation：人类可读摘要

check_resource_fit

退货：

• fits：布尔值，指示资源是否合适
• available_cpu_cores：可用CPU
• available_memory_gb：可用内存
• cpu_utilization_percent：预计CPU利用率
• memory_utilization_percent：预计内存利用率
• explanation：人类可读摘要

get_node_分解

无需参数

退货：

• nodes：节点信息数组

- name：节点名称 - total_cpu_cores：节点CPU容量 - total_memory_gb：节点内存容量 - allocated_cpu_cores：分配的CPU - allocated_memory_gb：分配的内存 - available_cpu_cores：可用CPU - available_memory_gb：可用内存 - pod_count：节点上的Pod数量

• total_nodes：节点总数
• explanation：人类可读摘要

get_namespace_usage

无需参数

退货：

• namespaces：命名空间信息数组

- namespace：命名空间名称 - cpu_requests_cores：CPU请求总数 - memory_requests_gb：总内存请求数 - cpu_limits_cores：CPU总限制 - memory_limits_gb：总内存限制 - pod_count：吊舱数量

• total_namespaces：命名空间总数
• explanation：人类可读摘要

get_pod_resource_stats

无需参数

退货：

• top_pods：按CPU请求排列的前20个Pod数组

- name：Pod名称 - namespace：Pod命名空间 - cpu_requests_millicores：CPU请求（以毫内核为单位） - memory_requests_mb：内存请求（MB） - cpu_limits_millicores：CPU限制（以毫内核为单位） - memory_limits_mb：内存限制（MB） - node：计划pod的节点

• total_pods：总吊舱数
• sorted_by：使用的排序标准
• explanation：人类可读摘要

🔒 安全

• 只读操作：仅对集群执行读取操作，从不修改资源
• Kubeconfig身份验证：使用具有适当RBAC的现有kubeconfig凭据
• 输入验证：具有类型检查的严格JSON模式
• 非root用户：容器以用户身份运行 1001
• 安全审计: cargo audit 在CI/CD管道中
• 最小图像：基于UBI 9最小值，以减少攻击面

所需的Kubernetes RBAC权限

运行此服务器的服务帐户或用户需要以下权限：

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: cluster-insights-reader
rules:
- apiGroups: [""]
  resources: ["nodes", "pods", "namespaces"]
  verbs: ["get", "list"]

备注：只需要读取权限。服务器从不修改群集资源。

🤝 贡献

开发流程

1. 分叉项目
2. 创建特征分支: git checkout -b feature/new-feature
3. 进行更改和测试: make test
4. 提交更改: git commit -am 'Add new feature'
5. 推送到分支: git push origin feature/new-feature
6. 创建拉取请求

专业发布流程

1. 发展：进行更改，测试 make test
2. 版本颠簸：使用 make release-patch/minor/major
3. 构建：使用 make pack 用于Claude Desktop集成
4. 容器：使用 make image-build 集装箱化

指南

• 代码质量：关注 cargo fmt 并通过 cargo clippy
• 测试：添加新功能的测试
• 版本管理：让货物放行处理版本控制
• CI/CD：确保所有GitHub操作都通过
• 文档：根据需要更新README.md
• 专业结构：保留脚本 scripts/ 目录

⚙️ 版本管理

此项目使用 货物放行 用于跨所有配置文件自动同步的专业版本管理。

自 Cargo.toml 发布配置：

[package.metadata.release]
# Don't publish to crates.io (since this is a binary project)
publish = false
# Don't push git tags (you can enable this if you want)
push = false
# Run pre-release hook
pre-release-hook = ["scripts/sync-manifest-version.sh"]
# Create git tag with 'v' prefix
tag-name = "v{{version}}"
# Sign tags (optional)
sign-tag = false

🔄 版本同步系统

• 单一真相来源: Cargo.toml 版本控制一切
• 自动同步：更新 mcpb/manifest.json 和 .env 自动地
• Git集成：自动创建提交和标记

📦 发布工作流

处理你的代码，然后当你满意的时候：

# 1. Make your changes and commit them
git add -A && git commit -m "feat: your changes"

# 2. Create a release (choose appropriate version bump)
make release-patch     # Bug fixes: 1.0.6 → 1.0.7
make release-minor     # New features: 1.0.6 → 1.1.0  
make release-major     # Breaking changes: 1.0.6 → 2.0.0

# 3. Build and package
make pack
make image-build
make image-push

# 4. Push to repository
git push && git push --tags

🔍 预览更改

# See what would happen without making changes
make release-dry-run

🛠️ 手动版本同步（开发）

# Sync version from Cargo.toml to other files manually
make sync-version

💬 LLM查询示例

当将此MCP代理与LLM一起使用时，用户可以询问有关其Kubernetes集群的自然语言问题。以下是现实情况：

📊 容量规划

查询1：基本容量检查

查询： *“我的集群当前的容量和利用率是多少？”*

法学硕士将致电 get_cluster_capacity 并用自然语言解释结果，帮助您了解集群的使用情况。

问题2：部署前检查

查询： *“我计划部署一个需要8个CPU内核和32GB内存的应用程序。我有足够的资源吗？”*

法学硕士将致电 check_resource_fit 使用指定的参数，并告诉您部署是否会成功。

🔍 故障排除

问题3：资源调查

查询： *“我在生产命名空间中遇到了pod调度失败。你能帮我理解原因吗？”*

LLM将调用多个函数(get_cluster_capacity, get_namespace_usage, get_node_breakdown)分析情况并提供见解。

问题4：资源猪识别

查询： *“哪些应用程序使用了我集群中最多的资源？”*

LLM将使用 get_pod_resource_stats 和 get_namespace_usage 以识别资源密集型工作负载。

🎯 优化

查询5：节点余额检查

查询： *“我的工作负载是否均匀分布在节点上？”*

LLM将使用 get_node_breakdown 分析资源分配，并在必要时提出再平衡建议。

查询6：命名空间比较

查询： *“比较我的生产环境和暂存环境之间的资源使用情况”*

LLM将使用 get_namespace_usage 比较资源消耗并提供建议。

🚀 高级场景

问题7：多步分析

查询： *“我需要部署一个服务的5个副本，每个副本需要2个CPU和4GB RAM。你能告诉我它是否合适吗？如果合适，部署后我的利用率是多少？”*

法学硕士将：

1. 计算总需求（10个CPU，20GB RAM）
2. 呼叫 check_resource_fit 有了这些价值观
3. 解释预计的利用率百分比

查询8：综合集群报告

查询： *“给我一个集群资源状态的完整概述”*

LLM将调用所有可用函数，以提供一份全面的报告，包括容量、节点细分、命名空间使用情况和顶级资源消耗者。

主要优势：

• 自然语言：无需了解Kubernetes API的详细信息
• 上下文感知：法学硕士根据您的问题解释结果
• 多功能：LLM可以为复杂的查询链接多个工具调用
• 建议：LLM可以根据数据提供可操作的建议

📄 许可证

此项目根据MIT许可证获得许可-请参阅 许可证 了解详情。

CI/CD管道

该项目包括一个全面的GitHub Actions工作流程：

• ✅ 自动化测试：单元测试和集成测试
• ✅ 版本同步验证：测试货物释放功能
• ✅ 集装箱建筑：测试集装箱化过程
• ✅ 工件管理：构建和上传发布工件
• ✅ 与跨平台支持：在Ubuntu上使用多容器运行时进行测试

🙋 支持

• 问题:
• 文档: 维基工程
• CI/CD：通过GitHub Actions进行自动化测试和部署

🏷️ 标签

mcp model-context-protocol rust kubernetes cluster-management capacity-planning resource-analysis openshift devops sre platform-engineering claude cargo-release containerization ci-cd observability

______________________________________________________________________

与开发❤️ 通过 阿尔法黑客集团