cilikube

Project Support

We appreciate your interest in CiliKube. If you find this project valuable for your Kubernetes management needs, please consider starring the repository ⭐. Community support drives continuous development and improvement.

Stay updated with the latest releases and technical insights by following our WeChat Official Account 希里安.

Contributors

We extend our gratitude to all contributors who have helped improve CiliKube through code contributions, bug reports, and feature suggestions.

Sponsorship

This project's CDN acceleration and security protection services are generously sponsored by Tencent EdgeOne.

Overview

CiliKube is an open-source Kubernetes multi-cluster management platform built with React, TypeScript, Go, and Gin.
From v1.0, login lands on the AI workspace first; the resource console is still there — just no longer the only door.

In one line:

AI is the navigator / read-only investigator; the console remains the source of truth.

Ask “how is it now / what’s broken,” follow resource clues into detail, logs, or a terminal — AI stays read-only by default and does not mutate the cluster for you.

v1.5.0 (current)

• Marketplace: a Helm chart catalog you can search, read (chart README and default values), and install from — promoted to a three-way top switcher (AI / Console / Marketplace) rather than buried in the console; repositories and installed releases are managed in the same place
• Resource coverage: 15 more kinds — ReplicaSets, ReplicationControllers, PodTemplates, Endpoints, EndpointSlices, IngressClasses, ServiceCIDRs, PriorityClasses, RuntimeClasses, Leases, Mutating/ValidatingWebhooks, VolumeAttachments, CSIDrivers, CSINodes
• Node operations: cordon / uncordon / drain with eviction progress, taint and label editing
• Environments / Applications: app-group surfaces and access-scope management
• Configurable navigation: admins hide sidebar groups per role (a blocklist, so new features stay visible by default); each user can then reorder or hide what remains in their own browser
• Scoped context bar: cluster and namespace pickers left the crowded topbar and now appear only on routes that are actually scoped
• UI overhaul: reworked typography and spacing, denser tables, and two neutral themes (graphite, carbon) joining the existing eight
• Login: redesigned lattice / particle field that reacts to the page layout
• Fonts simplified to browser default + Maple Mono (Maple Mono CN applies one face to every surface)
• License moved to AGPL-3.0-only

v1.0.1

• Topology (Observe): Ingress → Service → Workload → Pod graph, Traffic mode with RPS flow (incl. fan-out to pods)
• Timeline (Observe): status segments + live Event markers; Showcase backfills demo history
• Nav UX: collapsible sidebar groups; reliable detail Back / browser history with Logs console
• Showcase: kube-dns ↔ coredns wiring so Topology Traffic demos cleanly

v1.0.0

Highlights vs earlier releases:

• AI workspace: home after login, Skills (Featured / Inspect / Troubleshoot / Navigate + / menu + custom prompts), Investigate with AI from resources
• Fleet overview: multi-cluster health cards, per-card / fleet inspect
• Resource console: workloads / networking (incl. Gateway API) / config / storage / RBAC, logs & web terminal
• Monitoring: metrics-server snapshots + Prometheus series (Showcase curves on the public demo)
• Desktop apps: Windows / macOS / Linux with embedded backend reading local kubeconfig
• Themes: tron / paper / matrix / amber / nord / sakura / midnight-violet / solarized

More screenshots (chart detail · nodes · pods · monitoring · sidebar · login · themes)

✨ Key Differentiators

1. Triage first, deep dive second: land on AI after login, with Console and Marketplace one click away in the top bar; resource pages and fleet cards can throw context back to the investigator
2. See the path, then the history: Topology (Traffic) for Service → Workload → Pod flow; Timeline for status segments and event markers
3. Clear read-only boundary: default agent is the cluster investigator; writes, approvals, and backups still go through the console and your existing process
4. Browser + desktop: same UI; desktop reads local kubeconfig without standing up a web stack first

Target Audience

• Cloud-native / DevOps: lightweight, customizable multi-cluster UI with ask-first workflows
• Frontend developers: hands-on React + TypeScript + Tailwind
• Backend developers: Go + Gin and client-go integration
• Learners: understand Kubernetes resource models and troubleshooting paths by using them

Project Genesis

CiliKube started as a full-stack learning project that grew into a product you can actually open.
v1.0 adds an entry that matches how people troubleshoot — ask first, then change.

Online Demo

• Demo: https://cilikube.cillian.website
  (Public demo is a Showcase fake fleet; login can fill demo accounts in one click — not a production ops console)

Documentation

• Demo / product site: cilikube.cillian.website
• Intro post: CiliKube 1.0.0

Technology Stack

System Requirements:

• Node.js >= 20.0.0 (developed and tested with v24.14.1)
• Go >= 1.26.0 (developed and tested with v1.26.4)
• PNPM >= 10.x
• Kubernetes / kubectl 1.36.2 (client-go aligned)

Frontend Architecture:

• Core: React 19 TypeScript 7 Vite 8 Tailwind CSS 4
• Data / Routing: TanStack Query React Router
• Motion / Charts: Framer Motion Recharts
• HTTP Client: Axios
• The previous Vue UI remains in cilikube-web

Backend Architecture:

• Framework: Go Gin
• Kubernetes Integration: client-go
• Authentication: JWT
• Real-time Communication: Gorilla WebSocket
• Configuration: Viper
• Logging: Zap Logger
• AI: mock / OpenAI-compatible SSE (read-only tool calls)

✨ Current Features

• AI workspace: home after login, SSE chat, read-only tools, Skills (/ + custom), Investigate-with-AI, session history, jump into console
• Marketplace: Helm chart catalog with search and repository management, chart README / default values, install and upgrade, installed releases with rollback and uninstall
• Fleet overview: multi-cluster health cards, env tags, per-card / fleet AI inspect
• Auth & RBAC: JWT login, optional GitHub OAuth, Casbin roles; user / role / settings admin; security audit log
• Navigation: per-role sidebar visibility for admins, per-user reordering and hiding, context bar scoped to the route
• Multi-cluster: import and switch clusters, local kubeconfig context import
• Overview & search: global resource search, Events stream
• Cluster resources:
  • Nodes (cordon / uncordon / drain, taints and labels) / Namespaces / CRDs
  • Workloads: Pods (logs / web terminal), Deployments, StatefulSets, DaemonSets, ReplicaSets, ReplicationControllers, PodTemplates, Jobs, CronJobs, HPA, PDB
  • Network: Services, Endpoints, EndpointSlices, Ingress, IngressClasses, ServiceCIDRs, GatewayClasses, Gateways, HTTPRoutes, NetworkPolicies
  • Config: ConfigMaps, Secrets, ServiceAccounts, ResourceQuotas, LimitRanges, Mutating / ValidatingWebhooks
  • Storage: PV / PVC / StorageClass, VolumeAttachments, CSIDrivers, CSINodes
  • Scheduling: PriorityClasses, RuntimeClasses, Leases
  • Access: Roles, RoleBindings, ClusterRoles, ClusterRoleBindings
• Observe & ops: Monitoring (Prometheus), Topology, Timeline, Audit, API Proxy, resource YAML view / edit
• Themes / Chinese UI

️ Desktop (Windows / macOS / Linux)

Double-click app: Electron shell + embedded Go API, using your local kubeconfig (~/.kube/config or %USERPROFILE%\.kube\config).

Latest: v1.0.0-desktop.1

Platform	Asset
Windows x64	setup / portable
macOS Apple Silicon	DMG
Linux x64	AppImage

• First login: admin / 12345678 (forced password change on first login)
• Notes: builds are unsigned (Windows SmartScreen / macOS Gatekeeper may warn). Intel Mac DMG not yet published.
• Build: push a desktop tag (CI builds all three platforms; SQLite needs CGO on each runner):

git tag v1.0.0-desktop.1
git push origin v1.0.0-desktop.1

Local Development

Environment Preparation

1. Install Node.js (>=20) and pnpm (>=10)
2. Install Go (>=1.26)
3. Have a Kubernetes cluster and configure the kubeconfig file (defaults to reading ~/.kube/config)

Running the Frontend

# Navigate to the frontend directory (monorepo path: web/)
cd web
# Install dependencies
pnpm install
# Start the development server
pnpm dev

Visit http://localhost:8888 to see the frontend interface.

Running the Backend

# From the repository root
# (Optional) Update Go dependencies
go mod tidy
# Run the backend service (listens on port 8080 by default)
# Configuration files are modified in configs/config.yaml
go run cmd/server/main.go

Building the Project

# Build frontend production package (output to web/dist)
cd web
pnpm build

# Build backend executable
cd ..
go build -o bin/cilikube cmd/server/main.go

Docker Deployment

Using Official Images

# Backend
docker run -d --name cilikube -p 8080:8080 -v ~/.kube:/root/.kube:ro ghcr.io/ciliverse/cilikube:v1.5.0

# Frontend
docker run -d --name cilikube-web -p 80:80 ghcr.io/ciliverse/cilikube-web:v1.5.0

Using Docker Compose

docker-compose up -d

Visit http://localhost to access the interface.

☸️ Kubernetes Deployment (Helm)

Environment Preparation

• Install Helm (>=3.0)
• Have a Kubernetes cluster and configure the kubeconfig file
• Install kubectl (>=1.36.2)

Deployment Steps

# Add Helm repository
helm repo add ciliverse https://charts.cillian.website

# Update Helm repository
helm repo update

# Install CiliKube
helm install cilikube ciliverse/cilikube -n cilikube --create-namespace

# Check service status
kubectl get svc cilikube -n cilikube

Previous UI (Vue)

Click to view historical Vue screenshots

Login Interface

Dashboard Overview

Navigation Menu

Cluster Management

Pod Management

Web Terminal

Contribution Guide

We welcome contributions of all forms! If you'd like to help improve CiliKube, please:

1. Fork this repository
2. Create your feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'feat: Add some AmazingFeature') - Please follow the Git Commit Guidelines
4. Push your branch to your fork (git push origin feature/AmazingFeature)
5. Submit a Pull Request

Git Commit Guidelines

Please follow the Conventional Commits specification:

• feat: Add new features
• fix: Fix issues/bugs
• perf: Optimize performance
• style: Change the code style without affecting the running result
• refactor: Refactor code
• revert: Revert changes
• test: Test related, does not involve changes to business code
• docs: Docume