k8s_pilot: Your Central Kubernetes Control Plane – Powered by UBOS

In today’s complex cloud landscape, managing multiple Kubernetes clusters can feel like herding cats. The sheer volume of configurations, deployments, and services across different environments demands a solution that offers centralized visibility, control, and automation. Enter k8s_pilot, a lightweight yet powerful Kubernetes Control Plane server designed to streamline multi-cluster management and empower developers with intuitive APIs and robust tools.

Built on the Model Context Protocol (MCP), k8s_pilot acts as a central pilot, enabling you to observe and control all your Kubernetes fleets from a single, unified cockpit. Whether you’re managing deployments across development, staging, and production environments or orchestrating complex microservices architectures, k8s_pilot simplifies the process and accelerates your Kubernetes journey.

Why k8s_pilot?

• Simplified Multi-Cluster Management: Say goodbye to the headaches of juggling multiple kubectl contexts and configuration files. k8s_pilot provides a single pane of glass for interacting with all your Kubernetes clusters, allowing you to seamlessly switch between contexts and manage resources with ease.
• Enhanced Visibility and Control: Gain real-time insights into the health and status of your clusters, deployments, and services. k8s_pilot provides a comprehensive view of your Kubernetes landscape, enabling you to quickly identify and resolve issues before they impact your applications.
• Automated Workflows: Automate common Kubernetes tasks, such as deployments, scaling, and rollbacks, with k8s_pilot’s intuitive APIs. Define custom workflows to streamline your operations and reduce the risk of human error.
• Integration with Claude AI: Leverage the power of Claude AI, an advanced AI model, to interact with your Kubernetes clusters in a natural language. Ask questions, execute commands, and troubleshoot issues using simple, conversational prompts.
• Built on MCP: k8s_pilot leverages the Model Context Protocol (MCP), ensuring seamless integration with other MCP-compatible tools and services. MCP standardizes how applications provide context to LLMs, enabling AI models to access and interact with external data sources and tools.

Key Features in Detail:

• Multi-Cluster Context Switching:
  • Effortlessly switch between multiple Kubernetes clusters, eliminating the need to manually manage kubectl contexts.
  • Maintain a consistent view of your entire Kubernetes infrastructure, regardless of the number of clusters.
  • Simplify troubleshooting and debugging across different environments.
• CRUD Operations for Kubernetes Resources:
  • Perform Create, Read, Update, and Delete (CRUD) operations on a wide range of Kubernetes resources, including Deployments, Services, Pods, ConfigMaps, Secrets, Ingresses, StatefulSets, DaemonSets, Roles, ClusterRoles, PersistentVolumes, and Claims.
  • Manage your Kubernetes resources with ease, using k8s_pilot’s intuitive API and command-line interface.
  • Automate resource management tasks to reduce manual effort and improve efficiency.
• Namespace Operations:
  • Create and delete namespaces to logically isolate your applications and resources.
  • List all resources within a namespace to gain a comprehensive view of its contents.
  • Manage labels and resource quotas to enforce policies and optimize resource utilization.
• Node Management:
  • View detailed information about your Kubernetes nodes, including their status, capacity, and utilization.
  • Cordon and uncordon nodes to temporarily remove them from the scheduling pool for maintenance or troubleshooting.
  • Label and taint nodes to influence pod placement and ensure optimal resource allocation.
  • List all pods running on a specific node to identify potential bottlenecks or resource conflicts.

Use Cases:

• Simplified Multi-Environment Management:
  • Manage deployments across development, staging, and production environments with a single tool.
  • Promote code from development to production with confidence, knowing that your configurations are consistent across all environments.
  • Quickly identify and resolve issues in any environment, without having to switch between multiple tools and interfaces.
• Centralized Microservices Management:
  • Orchestrate complex microservices architectures with ease, using k8s_pilot’s intuitive API and automated workflows.
  • Monitor the health and performance of your microservices in real-time, using k8s_pilot’s comprehensive dashboard.
  • Scale your microservices up or down based on demand, using k8s_pilot’s automated scaling capabilities.
• Hybrid Cloud Management:
  • Manage Kubernetes clusters running on-premises, in the cloud, or in a hybrid environment with a single tool.
  • Migrate workloads between different environments with ease, using k8s_pilot’s automated migration capabilities.
  • Maintain a consistent view of your entire Kubernetes infrastructure, regardless of where your clusters are located.
• AI-Powered Kubernetes Management:
  • Use natural language commands to interact with your Kubernetes clusters, leveraging the power of Claude AI.
  • Ask questions about your Kubernetes infrastructure and receive intelligent answers from Claude AI.
  • Troubleshoot issues with your Kubernetes clusters using Claude AI’s diagnostic capabilities.

Getting Started with k8s_pilot:

To get started with k8s_pilot, you’ll need the following prerequisites:

• Python 3.13 or higher
• uv package manager
• Access to Kubernetes clusters (via ~/.kube/config or in-cluster config)

Once you have the prerequisites installed, you can install k8s_pilot by following these steps:

1. Clone the repository:

   bash git clone https://github.com/bourbonkk/k8s-pilot.git cd k8s-pilot

2. Launch with uv + MCP:

   bash uv run --with mcp[cli] mcp run k8s_pilot.py

Using k8s_pilot with Claude Desktop:

To use k8s_pilot with Claude Desktop, you’ll need to configure Claude to connect to the k8s_pilot MCP server. You can do this by adding the following configuration to your Claude settings:

{ “mcpServers”: { “k8s_pilot”: { “command”: “uv”, “args”: [ “–directory”, “/k8s-pilot”, “run”, “–with”, “mcp[cli]”, “mcp”, “run”, “k8s_pilot.py” ] } } }

Replace <path-to-cloned-repo> with the actual directory where you cloned the repository.

k8s_pilot and UBOS: A Powerful Combination

k8s_pilot aligns perfectly with the mission of UBOS, a full-stack AI Agent Development Platform. UBOS empowers businesses to orchestrate AI Agents, connect them with enterprise data, and build custom AI Agents with their LLM models and Multi-Agent Systems. By using k8s_pilot to manage the Kubernetes infrastructure that often underlies AI agent deployments, UBOS users gain a more streamlined and efficient development and deployment process.

Specifically, UBOS can leverage k8s_pilot to:

• Automate the deployment and scaling of AI Agents: UBOS can use k8s_pilot’s API to automatically deploy and scale AI Agents across multiple Kubernetes clusters, ensuring optimal performance and availability.
• Monitor the health and performance of AI Agents: UBOS can use k8s_pilot’s monitoring capabilities to track the health and performance of AI Agents in real-time, identifying and resolving issues before they impact users.
• Manage the resources used by AI Agents: UBOS can use k8s_pilot’s resource management features to allocate resources efficiently to AI Agents, optimizing cost and performance.

Conclusion:

k8s_pilot is a game-changer for Kubernetes multi-cluster management. Its intuitive interface, powerful features, and seamless integration with Claude AI and the UBOS platform make it the ideal solution for developers and operations teams looking to simplify their Kubernetes workflows and accelerate their AI initiatives. Embrace the future of Kubernetes management with k8s_pilot and UBOS.