A modern Kubernetes multi-cluster management platform based on Go and React, providing an intuitive web interface to simplify Kubernetes resource management and operations.

中文文档 | English

• Multi-cluster support and management
• Cluster connection testing
• Cluster resource overview
• Cluster health monitoring

• Node status monitoring and details viewing
• Node resource usage visualization
• Node drain operations
• Scheduling control (Cordon/Uncordon)
• Node taints management
• Node labels management
• Node pools creation and management

• Pod viewing, details and deletion
• Real-time Pod logs viewing
• Pod terminal connection
• Pod resource monitoring (CPU, Memory, Disk usage)
• Pod metrics historical data visualization
• Pod events viewing

• Deployment creation and management
• Deployment scaling and restart
• Deployment details viewing
• Deployment update strategy configuration
• Deployment health check configuration
• Deployment resource limits configuration
• Deployment node affinity configuration

• StatefulSet basic management
• StatefulSet scaling
• StatefulSet details viewing

• Service creation and management
• Service details viewing
• Service endpoints monitoring

• Real-time resource monitoring
• Metrics data visualization
• Cluster and node resource overview
• Pod performance metrics history

• Chinese and English multi-language support
• Dynamic language switching

• Go - Main programming language
• Gin - Web framework
• client-go - Kubernetes client library
• WebSocket - Real-time communication
• Logrus - Logging

• React 18 - Frontend framework
• TypeScript - Type safety
• Ant Design - UI component library
• Vite - Build tool
• React Router - Routing
• Axios - HTTP client
• ECharts - Data visualization

The platform adopts a front-end and back-end separation architecture:

• Frontend: React SPA application, communicating with backend through RESTful APIs and WebSocket
• Backend: Go microservice, interacting with multiple Kubernetes clusters via client-go
• Real-time Communication: WebSocket support for real-time log viewing and terminal connections

• Multi-cluster support
• High-performance caching
• Secure authentication
• Real-time monitoring
• Internationalization

kube-tide/
├── cmd/                    # Application entry points
│   ├── kube-tide/          # CLI entry
│   └── server/             # Server entry
├── configs/                # Configuration files
├── docs/                   # Documentation
│   ├── architecture.md     # Architecture documentation
│   ├── code_arch.md        # Code architecture
│   └── images/             # Documentation images
├── internal/               # Internal packages
│   ├── api/                # API handlers and routes
│   │   └── middleware/     # HTTP middlewares
│   ├── core/               # Core business logic
│   │   └── k8s/            # Kubernetes resource management
│   └── utils/              # Utility functions
│       ├── i18n/           # Internationalization
│       └── logger/         # Logging utilities
├── pkg/                    # Exportable packages
│   └── embed/              # Embedded resources
├── web/                    # Frontend code
│   ├── public/             # Static resources
│   └── src/                # Source code
│       ├── api/            # API client
│       ├── components/     # React components
│       ├── i18n/           # Internationalization
│       ├── layouts/        # Page layouts
│       ├── pages/          # Page components
│       └── utils/          # Utility functions
└── Makefile                # Build scripts

• Go 1.19 or higher
• Node.js 16 or higher
• pnpm package manager
• Accessible Kubernetes cluster

1. Clone the repository

   git clone https://github.com/bpzhang/kube-tide.git
   cd kube-tide

2. Build and run

   # Build production version (frontend and backend)
   make build-prod
   
   # Run the application
   make run-prod

3. Access the web interface

   http://localhost:8080
   

1. Backend Development

   # Install Go dependencies
   go mod download
   
   # Run backend in development mode
   make dev

2. Frontend Development

   cd web
   pnpm install
   pnpm dev

• make build - Build the project (frontend and backend)
• make build-prod - Build production version
• make build-web - Build frontend only
• make build-backend - Build backend only
• make run - Run the application
• make run-prod - Run production version
• make dev - Run in development mode
• make test - Run tests
• make verify - Run verification (Maven-style)
• make clean - Clean build artifacts

The application can be configured through:

• Environment variables
• Configuration file (configs/config.yaml)
• Command line flags

Key configuration options:

• Server port and host
• Kubernetes cluster configurations
• Logging levels
• Frontend build settings

• Architecture Documentation
• Code Architecture
• TODO List

• ConfigMap and Secret management
• Storage management (PV, PVC, StorageClass)
• Monitoring system integration (Prometheus)
• RBAC permission management
• CI/CD integration
• Helm Chart support

See the complete TODO list for detailed planning.

We welcome contributions! Please feel free to submit Pull Requests or Issues to improve the project.

• Follow Go official code standards
• Include appropriate tests for new features
• Update documentation when necessary
• Ensure TypeScript type safety for frontend code

This project is licensed under the MIT License.

• Kubernetes - The amazing container orchestration platform
• client-go - Official Kubernetes Go client library
• Ant Design - Excellent React UI library
• Gin - High-performance Go web framework