Skip to content
Back to search

aliangboard

An open-source, AI-native Kubernetes panel — full multi-cluster management via a Vue 3 + Node gateway, with a built-in Agent workbench and MCP server that lets LLMs read, write, and operate your cluster.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/aliang-one/aliangboard with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/aliang-one/aliangboard'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/aliang-one--aliangboard/badge.svg)](/listings/aliang-one--aliangboard)

HTML

<a href="/listings/aliang-one--aliangboard"><img src="/api/listings/aliang-one--aliangboard/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Kubernetes (recommended)

One command installs into the `aliangboard` namespace (NodePort exposure, 1Gi PVC dynamically provisioned by the default StorageClass):

kubectl apply -f https://raw.githubusercontent.com/aliang-one/aliangboard/main/deployment.yaml
kubectl -n aliangboard get svc aliangboard   # read the NodePort from the PORT(S) column, e.g. 8787:31234/TCP

Open `http://<any-node-IP>:<NodePort>` in your browser.

- Default administrator `admin` / `admin` — seeded via `ADMIN_USERNAME` / `ADMIN_PASSWORD` on first start only (changing the env after seeding has no effect); set strong credentials before applying in production - Panel data (API keys, cluster credentials, audit log, workbench repository) persists in the `aliangboard-data` PVC; the SQLite store is single-replica — do not scale `replicas` - When running inside a Kubernetes cluster, use `https://kubernetes.default.svc` as the API address, but the default ServiceAccount has no RBAC (you will get 403): create your own ServiceAccount with the required RBAC, obtain a token with `kubectl create token`, and supply the cluster CA certificate (or skip verification with the insecure option, development only) - Uninstalling removes all data: `kubectl delete ns aliangboard` (namespace deletion cascades to the PVC)

Docker

Images are published on GHCR:

docker pull ghcr.io/aliang-one/aliangboard:latest
docker run -d --name aliangboard \
  -p 8787:8787 \
  -v aliangboard-data:/app/data \
  ghcr.io/aliang-one/aliangboard:latest

Or build locally:

docker build -t aliangboard .
docker run -d --name aliangboard -p 8787:8787 -v aliangboard-data:/app/data aliangboard

Open `http://localhost:8787` in your browser. The SQLite database and the workbench git repository persist in the `aliangboard-data` volume — **it contains credentials, keep it safe**.

From source

Requires Node.js 25+ (the server uses the built-in `node:sqlite` module, which is flag-free from Node 25; on 22–24 it is experimental and needs `--experimental-sqlite`). You also need network access to the target Kubernetes API server and a token or account with the required RBAC permissions.

git clone https://github.com/aliang-one/aliangboard.git aliangboard && cd aliangboard
npm install
npm run server   # terminal 1: API gateway
npm run dev      # terminal 2: frontend dev server (Vite proxies /api → 127.0.0.1:8787)

Production build: `npm run build` (output in `dist/`, served same-origin by the gateway's `server/static.mjs`).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 327 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. **English** | [简体中文](README.zh-CN.md)
  2. # AliangBoard
  3. [![CI](https://github.com/aliang-one/aliangboard/actions/workflows/docker.yml/badge.svg)](https://github.com/aliang-one/aliangboard/actions/workflows/docker.yml)
  4. [![ghcr](https://img.shields.io/badge/ghcr-aliangboard-blue)](https://github.com/aliang-one/aliangboard/pkgs/container/aliangboard)
  5. [![Node](https://img.shields.io/badge/node-25%2B-339933)](https://nodejs.org)
  6. [![Vue](https://img.shields.io/badge/vue-3-42b883)](https://vuejs.org)
  7. [![License](https://img.shields.io/badge/license-Apache--2.0-blue)](./LICENSE)
  8. [![Live Demo](https://img.shields.io/badge/live-demo-brightgreen)](https://demo-aliangboard.aliang.one/)
  9. > Open-source, AI-native Kubernetes management panel — natural-language
  10. > operations on top of full multi-cluster management.
  11. AliangBoard turns an LLM into an operator for your clusters: with the built-in **Agent workbench** and **MCP server**, you can ask in natural language to read pod logs, debug containers, roll back a release, or modify resources. At the same time it is a complete Kubernetes panel covering the full resource lifecycle, exec / port-forward / debug-container injection, and multi-cluster switching.
  12. Tech stack in one line: a Vue 3 + Vite + Pinia frontend (plain JS, no TypeScript) and a Node transparent Kubernetes API gateway (zero extra runtime dependencies).
  13. ## 🌐 Live Demo
  14. | Item | Value |
  15. | --- | --- |
  16. | **Demo site** | [🚀 Open the live demo](https://demo-aliangboard.aliang.one/) |
  17. | **Username** | `admin` |
  18. | **Password** | `admin123` |
  19. > The demo is a public, shared instance: anything you create or change is visible to other visitors, so please do not put anything sensitive on it.
  20. ## 📸 Screenshots
  21. **Namespace Overview** — layered topology of a namespace (monitoring / business / database / storage layers) with health at a glance:
  22. ![Namespace Overview](screenshots/screen1.png)
  23. **Workload Overview** — a single workload at a glance: replicas, ready pods, image, events, CPU / memory and containers:
  24. ![Workload Overview](screenshots/screen2.png)
  25. ## ✨ Features
  26. ### 🤖 AI Operations
  27. - Agent workbench + MCP server (Streamable HTTP, API-key auth)
  28. - Tiered tools: read (free) / operator / admin (human-approved); writes are always human-approved
  29. - Full audit log (who / verb / resource / HTTP code)
  30. - Park a chat in the background and reopen it anytime from the floating entry point
  31. ### 🔌 Cluster & Multi-Cluster
  32. - Bearer Token / Basic Auth connection validation, session restore, logout
  33. - Connected clusters are persisted; one-click switch or remove
  34. ### 🗂 Full Resource Lifecycle
  35. - 30+ resource types synced; structured creation forms (20 built-in kinds) persisted via Server-Side Apply
  36. - YAML editing / export; optimistic delete with rollback on failure; apply multi-document YAML in one shot
  37. - Resource coverage table (see below)
  38. | Category | Resources |
  39. |---|---|
  40. | Core Workloads | Pod · Deployment · StatefulSet · DaemonSet |
  41. | Networking | Service · Ingress · Endpoints · NetworkPolicy · IngressClass |
  42. | Config & Storage | ConfigMap · Secret · PVC · PV · StorageClass |
  43. | RBAC | Role · ClusterRole · RoleBinding · ClusterRoleBinding · ServiceAccount |
  44. | Cluster & Policy | Namespace · Node · Event · RuntimeClass · PriorityClass · ResourceQuota · LimitRange · PDB |
  45. | Autoscaling | HPA |
  46. | Extensions | CRD + custom resources (API-discovery driven) |
  47. ### 🖥 Pod Deep Operations
  48. - exec terminal (xterm.js, **tmux-backed: survives a page refresh**)
  49. - attach · port-forward (Service / Deployment resolved to backend pods via endpoints)
  50. - File browsing (upload / download with progress) · kubectl debug injection (ephemeral containers)
  51. ### 🔁 Rollout & Node Ops
  52. - scale · rolling restart · rollout undo · CronJob manual trigger
  53. - Node cordon / uncordon / drain (policy/v1 Eviction)
  54. ### 🔍 Navigation & Insights
  55. - Global search across resources and namespaces · ownerReferences ownership topology with clickable jumps
  56. - Events live watch + involvedObject filtering
  57. - Namespace application layers (presentation / gateway / microservices / middleware / persistence, heuristic by default, exact via label `layer.aliangboard.io`)
  58. - Metrics charts (CPU / memory sampling, 15-min persisted window)
  59. ## 🚀 Quick Start
  60. ### Kubernetes (recommended)
  61. One command installs into the `aliangboard` namespace (NodePort exposure, 1Gi PVC dynamically provisioned by the default StorageClass):
  62. ```bash
  63. kubectl apply -f https://raw.githubusercontent.com/aliang-one/aliangboard/main/deployment.yaml
  64. kubectl -n aliangboard get svc aliangboard # read the NodePort from the PORT(S) column, e.g. 8787:31234/TCP
  65. ```
  66. Open `http://<any-node-IP>:<NodePort>` in your browser.
  67. - Default administrator `admin` / `admin` — seeded via `ADMIN_USERNAME` / `ADMIN_PASSWORD` on first start only (changing the env after seeding has no effect); set strong credentials before applying in production
  68. - Panel data (API keys, cluster credentials, audit log, workbench repository) persists in the `aliangboard-data` PVC; the SQLite store is single-replica — do not scale `replicas`
  69. - When running inside a Kubernetes cluster, use `https://kubernetes.default.svc` as the API address, but the default ServiceAccount has no RBAC (you will get 403): create your own ServiceAccount with the required RBAC, obtain a token with `kubectl create token`, and supply the cluster CA certificate (or skip verification with the insecure option, development only)
  70. - Uninstalling removes all data: `kubectl delete ns aliangboard` (namespace deletion cascades to the PVC)
  71. ### Docker
  72. Images are published on GHCR:
  73. ```bash
  74. docker pull ghcr.io/aliang-one/aliangboard:latest
  75. docker run -d --name aliangboard \
  76. -p 8787:8787 \
  77. -v aliangboard-data:/app/data \
  78. ghcr.io/aliang-one/aliangboard:latest
  79. ```
  80. Or build locally:
  81. ```bash
  82. docker build -t aliangboard .
  83. docker run -d --name aliangboard -p 8787:8787 -v aliangboard-data:/app/data aliangboard
  84. ```
  85. Open `http://localhost:8787` in your browser. The SQLite database and the workbench git repository persist in the `aliangboard-data` volume — **it contains credentials, keep it safe**.
  86. ### From source
  87. Requires Node.js 25+ (the server uses the built-in `node:sqlite` module, which is flag-free from Node 25; on 22–24 it is experimental and needs `--experimental-sqlite`). You also need network access to the target Kubernetes API server and a token or account with the required RBAC permissions.
  88. ```bash
  89. git clone https://github.com/aliang-one/aliangboard.git aliangboard && cd aliangboard
  90. npm install
  91. npm run server # terminal 1: API gateway
  92. npm run dev # terminal 2: frontend dev server (Vite proxies /api → 127.0.0.1:8787)
  93. ```
  94. Production build: `npm run build` (output in `dist/`, served same-origin by the gateway's `server/static.mjs`).
  95. ## 🤖 AI Workbench & MCP
  96. AliangBoard turns an LLM into a cluster operator via two paths.
  97. ### Built-in Agent Workbench
  98. Chat with your cluster directly in the admin console ("Agent Console"). The agent calls a set of Kubernetes tools through a bound ServiceAccount:
  99. - **Read (no approval)**: pod logs · list / get resources and YAML · events · `can-i` RBAC self-check · rollout history
  100. - **Operator (human approval)**: scale (1..20, no scaling to 0) · rolling restart
  101. - **Admin (human approval)**: exec commands · read / browse container files · apply / delete resources · update image · kubectl debug injection · rollback to a specific revision
  102. **Every write goes through a human-approval checkpoint** — the agent proposes, you confirm, nothing changes your cluster silently.
  103. ### MCP Server (external AI clients)
  104. AliangBoard is also an **MCP server** (`POST /mcp`, Streamable HTTP, API-key auth) that exposes the same toolset to external AI clients such as Claude Code:
  105. ```bash
  106. claude mcp add --transport http aliangboard {HOST}/mcp \
  107. --header "Authorization: Bearer <YOUR_API_KEY>"
  108. ```
  109. Remove it with: `claude mcp remove aliangboard`
  110. ### Bring Your Own LLM
  111. The agent speaks the **OpenAI-compatible protocol**. Set `baseURL` + `apiKey` + `model` in the admin console ("LLM Settings"), or set the environment variables `LLM_BASE_URL` / `LLM_MODEL`. OpenAI, DeepSeek, Qwen, GLM, and local vLLM / Ollama (with an OpenAI-compatible endpoint) all work.
  112. ### Security Model
  113. - Every API key is **bound to one ServiceAccount**; tool calls are constrained by that SA's Kubernetes RBAC
  114. - Tools are tiered **read / operator / admin**; `minTier` filters the tools available to each key
  115. - Writes and workbench file writes **always require human approval**
  116. - Every call is recorded in the **audit log** (who / verb / resource / HTTP code)
  117. ## ⚙️ Configuration
  118. Backend environment variables:
  119. | Variable | Default | Description |
  120. | --- | --- | --- |
  121. | `HOST` | `127.0.0.1` | API gateway listen address |
  122. | `PORT` | `8787` | API gateway listen port |
  123. | `CORS_ORIGIN` | `*` | Allowed frontend origins; set to your actual domain in production |
  124. | `SESSION_TTL_MS` | `28800000` | In-memory session lifetime, 8 hours by default |
  125. | `MAX_PLATFORM_SESSIONS_PER_USER` | `10` | Max platform sessions kept per user; the least recently active one is evicted on login when exceeded, disabled when < 1 |
  126. | `K8S_REQUEST_TIMEOUT` | `15000` | Kubernetes API request timeout, in milliseconds |
  127. | `K8S_ALLOWED_HOSTS` | empty | Comma-separated allowlist of API server hosts |
  128. | `K8S_INSECURE_SKIP_TLS_VERIFY` | `false` | Skip cluster certificate verification **for K8s sessions only**; does not disable process-level TLS (LLM/version checks unaffected). Use only in development with self-signed clusters |
  129. | `PORT_FORWARD_HOST` | `127.0.0.1` | Port-forward local listen address (same as kubectl port-forward; local to the gateway host, the browser must be able to reach it) |
  130. | `LLM_BASE_URL` | empty | OpenAI-compatible baseURL for the LLM (can also be set in the admin console "LLM Settings") |
  131. | `LLM_MODEL` | empty | LLM model name (can also be set in the admin console) |
  132. Frontend environment variables:
  133. | Variable | Default | Description |
  134. | --- | --- | --- |
  135. | `VITE_API_BASE_URL` | empty | Full address of the API gateway; keep empty for same-origin deployments |
  136. | `ALIANGBOARD_API_URL` | `http://127.0.0.1:8787` | Vite dev proxy target |
  137. To connect to a cluster with a self-signed certificate during development, you can temporarily run:
  138. ```bash
  139. K8S_INSECURE_SKIP_TLS_VERIFY=true npm run server
  140. ```
  141. **Note:** This variable only affects K8s session verification (TLS to the cluster API server). It does not disable process-level TLS verification for LLM calls or version checks. Use only in development/self-signed environments.
  142. ## 🔒 Production Deployment Security Requirements
  143. ### TLS Termination
  144. **Production deployments MUST terminate TLS at an edge layer** (reverse proxy or Ingress Controller). The default NodePort exposure in `deployment.yaml` is intended for internal network evaluation only.
  145. - **Ingress (recommended):** See `deploy/ingress-tls.yaml` for a complete nginx Ingress + TLS example
  146. - TLS is terminated at the Ingress layer
  147. - Backend Service remains plain HTTP (containerPort: 8787)
  148. - Supports cert-manager automation or manual TLS secrets
  149. - **Alternative reverse proxy:** Configure nginx/HAProxy/Envoy with TLS termination, proxying to the NodePort or Service
  150. ### K8s Session TLS
  151. The `K8S_INSECURE_SKIP_TLS_VERIFY` environment variable has **session-scoped semantics**:
  152. - **Purpose:** Only controls TLS verification for K8s cluster connections (session-level)
  153. - **Does NOT affect:** Process-level TLS (LLM API calls, version checks, etc.)
  154. - **Use case:** Development/self-signed clusters only
  155. - **Production:** Configure a trusted CA and `K8S_ALLOWED_HOSTS` instead
  156. Do not skip TLS verification in production without proper security review.
  157. ## 🔐 RBAC Recommendations
  158. Do not use long-lived `cluster-admin` tokens. Create a dedicated ServiceAccount and grant only what your usage actually needs:
  159. - `get`, `list`, `watch` on resources
  160. - `create`, `update`, `patch`, `delete` on the resources you need to edit
  161. - `get` on pod logs
  162. - `create` on pod eviction
  163. - `patch` for node operations
  164. - `pods/exec` (`create`) for the exec terminal
  165. - `pods/portforward` (`get` / `create`) for port forwarding
  166. - `pods/ephemeralcontainers` (`update`) for debug container injection
  167. - `pods/attach` (`create`) for pod attach
  168. - `jobs` (`create`) for CronJob manual trigger
  169. The API gateway keeps cluster credentials and sessions in memory by default, so all login sessions are lost on restart (with container deployment, credentials persist in the `/app/data` volume). For multi-instance production deployments, move sessions and encrypted cluster credentials to dedicated storage.
  170. ## 🐳 Container Deployment & Release
  171. The repository ships a multi-stage `Dockerfile`: a single Node process serves both the frontend static files and the API gateway, ready to run out of the box.
  172. Container variables (they override the backend variables of the same name):
  173. | Variable | Default | Description |
  174. | --- | --- | --- |
  175. | `HOST` | `0.0.0.0` | Listen address inside the container (set by the image; do not change it back to 127.0.0.1) |
  176. | `PORT` | `8787` | Listen port |
  177. | `ALIANG_DB` | `/app/data/aliangboard.db` | SQLite database path (inside the volume) |
  178. | `ALIANG_WORKBENCH_DIR` | `/app/data/workbench` | Workbench git repository directory (inside the volume) |
  179. | `ALIANG_STATIC_DIR` | `/app/dist` | Frontend static directory (rarely needs changing) |
  180. > The runtime image is based on `node:25-alpine` (hard requirement for `node:sqlite`) with `git` built in (needed for the workbench repository). It runs as the non-root user `node`.
  181. ### Release & CI
  182. - Builds are triggered **only** by pushing a `v*` tag (e.g. `v1.2.3`) or by a manual `workflow_dispatch` from the Actions page. Regular pushes do not build images.
  183. - Published image tags on GHCR:
  184. - `ghcr.io/aliang-one/aliangboard:latest` — follows the newest release
  185. - `ghcr.io/aliang-one/aliangboard:1.2.3` — immutable semver pin, for exact version lock
  186. - `ghcr.io/aliang-one/aliangboard:1.2` — rolls with each minor release
  187. - Multi-platform `linux/amd64` + `linux/arm64`; authentication uses the built-in `GITHUB_TOKEN`, no extra secrets required
  188. - Historical images can be pruned via the manual cleanup workflow (`.github/workflows/cleanup-ghcr.yml`, dry-run by default)
  189. - Current release: `v1.0.3`
  190. ## 🖥 SSH Server Management
  191. Manage SSH servers alongside Kubernetes clusters — credentials stored AES-256-GCM encrypted (key file kept separate from the database).
  192. - **Server inventory**: host/port/credentials (password or private key + sudo password), optional cluster association and tags; connection test detects the distro (Ubuntu/Debian/Arch/Alpine/Rocky…) and shows its icon plus a health badge.
  193. - **Workbench terminals**: interactive floating terminals with gateway-side keepalive — refreshing the page replays scrollback and resumes the same shell.
  194. - **SFTP**: browse/upload/download with progress.
  195. - **AI access (opt-in per server)**: each server has an "expose to AI" toggle with an approval policy (`always` = every command human-approved, `readonly` = read-only commands auto-allowed, `none` = unrestricted). Exposed servers appear in the AI ledger (`read_server_ledger`) where the agent records each server's role/deployments (`write_server_notes`, human-approved).
  196. **Authorization model (deliberately simple, open-source edition)**:
  197. - Server CRUD, credentials and the ledger are **admin-only**; terminals, SFTP and AI access are **admin-only as well**.
  198. - API keys can be granted SSH access with a single boolean (`SSH server access` when creating/editing a key). Granted keys reach MCP tools `wb_ssh_exec` / `wb_ssh_read_file` / `read_server_ledger` for servers that are exposed to AI; each server's approval policy applies in a fail-closed way (`always` denies exec on the key channel since no human approver exists there). No grouping or per-user permission management.
  199. ## ⚠️ Known Limitations
  200. - The exec terminal, port forwarding, and file browsing only work when a real cluster is connected; without one, the related entry points show an empty state.
  201. - Port forwarding opens a local TCP listener on the gateway host (default `127.0.0.1`, same as kubectl port-forward). When the panel runs on a remote host, the browser cannot reach that port directly — use an SSH tunnel or similar.
  202. - The exec terminal runs `/bin/sh` by default (adjustable via the component's `command` prop); for shell-less images such as distroless, use kubectl debug to inject an ephemeral container with a shell (requires Kubernetes 1.25+; EphemeralContainers is enabled by default).
  203. - Multi-cluster switching reuses the gateway session; sessions are lost when the gateway restarts, so saved clusters must be logged into again. Session credentials live only in the browser's localStorage — do not use them on shared devices.
  204. - The "Audit" page shows cluster Events as the activity record; full user-level auditing (who / verb / IP / HTTP code) requires cluster audit logging wired to a log backend — the standard Kubernetes API does not provide it.
  205. - Helm, GitOps, and alerting are not integrated yet.
  206. - HPA / PDB depend on specific API versions (e.g. autoscaling/v2, policy/v1); on older clusters the corresponding creation fails with a toast message.
  207. - When deployed inside a Kubernetes cluster, the port-forward listener opens in the panel Pod's network namespace and the browser cannot reach it directly; this capability targets Docker / source deployments and is unavailable for in-cluster installs (a gateway-side proxy may come later).
  208. ## 🛠 Tech Stack
  209. **Frontend** — Vue 3 · Vite · Pinia · Vue Router · @tanstack/vue-query · vue-i18n · xterm.js · marked · DOMPurify (plain JS, no TypeScript)
  210. **Backend** — Node.js 25 (built-in `node:sqlite`) · @kubernetes/client-node · transparent Kubernetes API gateway with zero extra runtime dependencies
  211. **Testing** — server and pure-logic tests on an in-house zero-dependency runner + `node --test`; frontend unit tests with vitest + @vue/test-utils + happy-dom
  212. **Packaging** — a single multi-stage Docker image (`node:25-alpine`), one process serving API + SPA same-origin
  213. ## 🤝 Contributing
  214. Issues and PRs are welcome. Local development:
  215. ```bash
  216. npm install
  217. npm run server # API gateway
  218. npm run dev # frontend
  219. npm test # server + pure-logic tests
  220. npm run test:unit # frontend unit tests (vitest)
  221. npm run typecheck # node --check syntax baseline
  222. ```
  223. **Bilingual sync rule:** any change to `README.md` must update `README.zh-CN.md` in the same PR.
  224. ## License
  225. [Apache License 2.0](./LICENSE). Commercial use, modification, distribution, and private use are permitted, provided the copyright and license notices are retained.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.