# Kuboard: Kubernetes Multi-Cluster Management UI and Its Documentation Site

> Kuboard is a free Kubernetes management UI that handles multiple clusters from a single interface, covering Kubernetes versions 1.15 through 1.34. This repository is the source code for the Kuboard v4 official documentation site, which is a static site built from Markdown and served at kuboard.cn.

**eip-work/kuboard-press** — Kuboard 是基于 Kubernetes 的微服务管理界面。同时提供 Kubernetes 免费中文教程，入门教程，最新版本的 Kubernetes v1.23.4 安装手册，(k8s install) 在线答疑，持续更新。

- Repository: https://github.com/eip-work/kuboard-press
- Website: https://kuboard.cn/
- Stars: 25,250 · Forks: 1,595
- Language: HTML
- License: not declared
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/eip-work-kuboard-press

## What Kuboard Does and Who It Is For

Kuboard is a Kubernetes management UI designed for teams that operate Kubernetes in production and want a visual interface for daily operations. The README describes its core purpose as making Kubernetes installation and maintenance "simple, intuitive, and efficient." It is free for individuals and small to medium-sized businesses.

The platform is not a Kubernetes distribution or installer; it connects to existing clusters and provides a UI layer on top of them. It supports clusters running Kubernetes versions 1.15 through 1.34, which covers a wide span of the Kubernetes release history. The multi-cluster feature lets a single Kuboard instance manage several clusters from one browser interface, replacing the need to switch kubectl contexts between clusters.

The README targets two kinds of users: operations engineers who manage clusters day-to-day, and developers who occasionally need to inspect pods, view logs, or access a terminal inside a container. The browser-based approach means no additional client software is required beyond a modern web browser.

## About This Repository: The Documentation Site

The eip-work/kuboard-press repository is the source code for Kuboard's official documentation site, hosted at kuboard.cn. The README states it is "based on VitePress" and contains both Chinese and English documentation. The repository is organized with separate directories for guides, installation instructions, and version-specific documentation.

The root package.json shows scripts for running the documentation site locally:

```bash
pnpm install
pnpm docs:dev
```

Running `pnpm docs:dev` starts a local development server for the documentation. Building a production-ready static site uses:

```bash
pnpm docs:build
```

The repository structure includes a `v4/` directory for the current Kuboard v4 documentation, along with older `guide/`, `guide-v2/`, `install/`, and `learning/` directories. There is also a `glossary/` directory, an `overview/` directory with overview materials, and a `support/` directory. The documentation site itself is what this repository produces; Kuboard, the application that manages Kubernetes clusters, is a separate software project distributed as a Docker image under the `eipwork/kuboard` image name.

Contributors who want to improve the documentation or translate content can clone this repository, run the local dev server, and submit pull requests to the eip-work/kuboard-press GitHub repository. The static site architecture means no backend is required to test documentation changes locally.

## Kuboard's Core Feature Set

The README lists Kuboard's features in seven categories. Multi-cluster management covers connecting and managing multiple Kubernetes clusters from the same interface, querying across clusters, and operating resources without switching kubectl contexts.

Resource management covers the full range of Kubernetes objects: workloads (Deployment, StatefulSet, DaemonSet, Job, CronJob, Pod, HPA), configuration and storage (ConfigMap, Secret, PVC, PV, StorageClass), and networking (Service, Ingress, NetworkPolicy, Gateway API). These are managed through a visual interface.

The built-in operations tools are the most distinctive features for day-to-day debugging. NodeShell provides shell access to cluster nodes without requiring SSH configuration. Debug Container injects a troubleshooting container into a running pod without modifying the pod's existing image. KuboardProxy provides temporary browser-accessible routes into services inside the cluster. These three tools address a specific gap: getting inside a cluster when normal access paths are restricted.

Security features include an authorization model the README describes as simple and clear, operation audit logging, and MFA (multi-factor authentication). All significant operations leave an auditable record.

Local caching of common Kubernetes objects makes fuzzy search respond in milliseconds. The README notes this as a specific performance design decision.

## The MCP Server for AI-Assisted Operations

Kuboard v4 includes a built-in MCP (Model Context Protocol) server, listed in the README as the "Kuboard MCP" feature. This server allows AI agents to interact directly with cluster operations. The README describes the design constraint clearly: all write operations require mandatory human approval. Read operations can proceed without approval.

This architecture reflects a deliberate trade-off. Enabling an AI agent to query cluster state, check pod health, and inspect logs without approval is useful for diagnostic workflows. Requiring human approval for any state-changing operation (creating resources, deleting pods, scaling deployments) prevents automated mistakes in production. The README frames this as "safety and efficiency together."

The MCP server is an embedded component, not a separate process to deploy. It is part of the standard Kuboard installation. The README does not document the specific MCP endpoints or the protocol version, but points to kuboard.cn for the full documentation.

For teams already using AI-driven DevOps tooling, this integration is a concrete feature rather than a roadmap item. The mandatory approval gate is a hard design choice: fully autonomous write operations are not supported, which means workflows that require zero-touch deployments cannot be automated through the Kuboard MCP server alone.

## Running the Documentation Site Locally

Developers who want to contribute to Kuboard's documentation or run it offline can clone this repository and serve it locally. The quick start sequence from the README is:

```bash
pnpm install
pnpm docs:dev       # 本地开发
pnpm docs:build     # 构建站点
```

The docs:dev command starts a local development server with live reload. The docs:build command produces a static site output. There is no backend or database; the documentation is entirely static content.

For running the documentation as a Docker container, the repository includes a Dockerfile and a docker-compose.yaml. The Dockerfile copies the built documentation into an nginx image and exposes port 80:

```dockerfile
FROM docker.m.daocloud.io/nginx:1.17.1

RUN rm -f /etc/nginx/nginx.conf \
    && rm -f /etc/nginx/conf.d/default.conf
COPY docker/nginx.80.conf /etc/nginx/conf.d/nginx.80.conf
COPY docker/nginx.conf /etc/nginx/nginx.conf

EXPOSE 80

COPY ./docs /usr/share/nginx/html

ENTRYPOINT ["nginx", "-g", "daemon off;"]
```

This Dockerfile is for the documentation site, not for Kuboard the application. Kuboard itself is installed separately.

## Kuboard vs. Kubernetes Dashboard and Other UIs

The most direct comparison is with the official Kubernetes Dashboard project (kubernetes/dashboard), which is the CNCF-maintained reference UI. Kubernetes Dashboard focuses on single-cluster management and provides a read-oriented view of resources. Kuboard's multi-cluster support and built-in operations tools (NodeShell, Debug Container, KuboardProxy) go beyond what Kubernetes Dashboard offers by default. The Kubernetes Dashboard does not include a built-in MCP server or operation audit logging as Kuboard does.

KubeSphere appears in the related search data as a common comparison. KubeSphere is a full Kubernetes platform distribution that includes its own installer and additional services. Kuboard is not a distribution; it connects to an existing cluster without replacing the control plane. Teams that want to add a UI to an existing cluster without changing how it was installed will find Kuboard easier to adopt than a full platform replacement.

Lens (Kubernetes Lens) is another frequently compared tool. Lens is a desktop application that connects to clusters from a local machine. Kuboard is browser-based and server-side, which means it can be accessed from any device on the network without installing a client. The trade-off is that Kuboard requires a running server; Lens does not.

The licensing difference matters: Kubernetes Dashboard is Apache 2.0 licensed. Kuboard's licence terms are stated as free software for individuals and SMEs on kuboard.cn, but the specific licence is not identified in this repository. Teams with legal requirements around open source licensing should verify the current terms at kuboard.cn before deploying.

## Conclusion

Kuboard is a practical choice for teams running multiple Kubernetes clusters who need a visual management layer without paying for enterprise tooling. The free-for-individuals-and-SMEs positioning means there is no licensing cost for most users. The built-in MCP server for AI-assisted operations is a specific differentiator, though all write operations require human approval, which limits how much automation is possible. Teams that need CLI-first workflows over a visual UI will find Kuboard adds overhead rather than saving it. Anyone evaluating Kuboard should start with the read-only demo at demo.kuboard.cn (user: demo, password: demo123) before running the installation, since the demo covers the full feature set in a live cluster. The last push to this repository was on 2026-09-27.

## FAQ

### How do I install Kuboard on a Kubernetes cluster?

The README states that Kuboard can be started with a single docker compose command and completed in three steps. The full installation instructions are in the Kuboard documentation at kuboard.cn. A read-only demo environment is available at demo.kuboard.cn (user: demo, password: demo123) for evaluating the interface before installing.

### What is the difference between Kuboard and Kubernetes Dashboard?

Kubernetes Dashboard is a single-cluster UI maintained by the CNCF. Kuboard adds multi-cluster management, browser-based NodeShell for node access without SSH, Debug Container injection, and a built-in MCP server for AI-assisted operations. Kuboard covers Kubernetes versions 1.15 through 1.34.

### Does Kuboard support multi-cluster management?

Yes. The README lists multi-cluster unified management as the first feature: connecting and managing multiple Kubernetes clusters from a single interface, with cross-cluster queries and operations without switching kubectl contexts. Kuboard supports cluster versions 1.15 through 1.34.

## Sources

- [eip-work/kuboard-press on GitHub](https://github.com/eip-work/kuboard-press)
- [Issues](https://github.com/eip-work/kuboard-press/issues)
- [Project website](https://kuboard.cn/)
- [README](https://github.com/eip-work/kuboard-press/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/eip-work-kuboard-press