🚀 Kubernetes and GitOps management platform with integrated monitoring, PASETO authentication, and single binary deployment.

A comprehensive web-based platform for managing Kubernetes clusters and GitOps workflows. Provides real-time cluster monitoring, automated deployments, and integrated observability with a single binary deployment model.

• Kubernetes Management: Pods, deployments, nodes, scaling, logs with virtualized tables
• GitOps Operations: Full Gitea API integration, repository sync, CI/CD workflows
• Monitoring & Metrics: Real-time metrics, historical trends, live log streaming
• Performance Optimized: Handles 50,000+ rows with smooth scrolling and filtering
• Customizable Dashboard: Hide/show UI sections, multiple view modes
• Authentication: PASETO v4 tokens, role-based access control, anti-SEO protection
• Single Binary: Embedded React SPA, SQLite database, zero external dependencies

Click to expand: more Screenshots

• Backend: Go 1.24 + SQLite + PASETO auth
• Frontend: React 19 + TypeScript + Tailwind CSS + Vite
• Deployment: Single Docker image, Kubernetes-ready
• Database: SQLite (embedded, no external services)

denshimon/
├── backend/           # Go REST API server
│   ├── cmd/server/    # Main application entry
│   ├── internal/      # Business logic
│   │   ├── api/       # HTTP handlers
│   │   ├── auth/      # Authentication service
│   │   ├── database/  # SQLite operations
│   │   ├── gitops/    # GitOps management
│   │   ├── k8s/       # Kubernetes client
│   │   └── metrics/   # Monitoring service
│   └── pkg/config/    # Configuration
├── frontend/          # React SPA
│   ├── src/
│   │   ├── components/ # UI components
│   │   ├── stores/     # State management
│   │   └── types/      # TypeScript definitions
│   └── dist/          # Build output (embedded in Go)
├── docker-compose.yml # Development setup
├── Dockerfile         # Production image
└── build.sh          # Local build script

• Colors: Matrix green (#00FF00), yellow (#FFFF00), cyan (#00FFFF) on black
• Typography: Monospace fonts for terminal aesthetic
• Layout: Responsive grid system with border outlines
• Components: Custom charts, tables, modals with cyberpunk styling

• Cluster Overview: Real-time resource metrics and health status
• Pod Management: List, restart, delete, view logs with filtering
• Deployment Control: Scale replicas, view status, manage rollouts
• GitOps Dashboard: Repository sync status, application deployments
• Resource Analytics: CPU/memory/storage trends with interactive charts

# Pod Operations
GET    /api/k8s/pods              # List all pods (virtualized tables)
DELETE /api/k8s/pods/{name}       # Delete specific pod
POST   /api/k8s/pods/{name}/restart # Restart pod
GET    /api/k8s/pods/{name}/logs  # Stream logs

# Deployment Control  
GET   /api/k8s/deployments        # List deployments
PATCH /api/k8s/deployments/{name}/scale # Scale replicas

# Cluster Monitoring
GET /api/k8s/nodes                # List nodes with metrics
GET /api/k8s/health               # Cluster health check
GET /ws                           # WebSocket for real-time updates

# Repository Management
GET  /api/gitea/repositories      # List repositories
GET  /api/gitea/repositories/{owner}/{repo} # Get repository details
GET  /api/gitea/repositories/{owner}/{repo}/commits # List commits
GET  /api/gitea/repositories/{owner}/{repo}/branches # List branches
GET  /api/gitea/repositories/{owner}/{repo}/pulls # List pull requests
GET  /api/gitea/repositories/{owner}/{repo}/releases # List releases
GET  /api/gitea/repositories/{owner}/{repo}/actions/runs # List workflow runs

# Deployment Operations
POST /api/gitea/repositories/{owner}/{repo}/deploy # Trigger deployment
POST /api/gitea/webhook           # Webhook receiver (no auth)

# Resource Metrics
GET /api/metrics/cluster          # Cluster-wide usage
GET /api/metrics/nodes            # Per-node metrics
GET /api/metrics/pods             # Pod resource usage
GET /api/metrics/history          # Historical trends

# Authentication
POST /api/auth/login              # Login with credentials
GET  /api/auth/me                 # Get current user
POST /api/auth/logout             # Logout

Perfect for teams using GitHub Actions → Gitea Registry → Kubernetes:

graph LR
    A[GitHub Repo] --> B[GitHub Actions]
    B --> C[Gitea Registry]  
    C --> D[Denshimon]
    D --> E[Kubernetes Cluster]
    
    B -.->|Build & Push| C
    D -.->|Deploy & Manage| E

Workflow:

1. Developer pushes code to GitHub
2. GitHub Actions builds Docker image
3. Image pushed to Gitea private registry
4. Denshimon detects changes, deploys to cluster
5. Monitor deployment status and metrics

Manage dev/staging/prod environments from single interface:

• Environment Isolation: Separate namespaces and configs
• Progressive Deployment: Deploy to dev → staging → prod
• Resource Monitoring: Track usage across environments
• Access Control: Role-based permissions per environment

Daily cluster operations and troubleshooting:

• Resource Management: Scale deployments based on metrics
• Troubleshooting: View logs, restart failed pods
• Capacity Planning: Monitor node resources and usage trends
• Security: Audit logs and access control

Empower developers with safe cluster access:

• Deployment Control: Deploy and rollback applications
• Log Access: Debug issues without kubectl access
• Resource Monitoring: Track application performance
• Environment Management: Manage feature branch deployments

Centralized management of infrastructure as code:

• Repository Sync: Auto-sync K8s manifests from Git
• Application Lifecycle: Deploy, update, delete applications
• Configuration Management: Manage ConfigMaps and Secrets
• Compliance: Track changes and maintain audit trail

• Admin: Full cluster access (create, read, update, delete)
• Operator: Deploy and manage applications (read, update, scale, sync)
• Viewer: Read-only access to resources and metrics

Username: admin     Password: password  # Full access
Username: operator  Password: password  # Limited admin  
Username: viewer    Password: password  # Read-only

• PASETO v4 token authentication
• SQLite-based session management
• Role-based API endpoint protection
• Kubernetes RBAC integration
• Audit logging for all operations

# Run with Docker
docker run -d \
  -p 8080:8080 \
  -v denshimon-data:/app/data \
  -v ~/.kube:/home/denshimon/.kube:ro \
  --name denshimon \
  denshimon:latest

# Deploy with persistent volume
kubectl apply -f k8s-deployment.yaml

# Access via port-forward  
kubectl port-forward svc/denshimon 8080:80

# Clone repository
git clone https://github.com/archellir/denshimon.git
cd denshimon

# Install dependencies
cd backend && go mod tidy
cd ../frontend && pnpm install

# Development mode (2 terminals for hot reload)
# Terminal 1: Backend API
cd backend && DATABASE_PATH=./test-app.db go run cmd/server/main.go

# Terminal 2: Frontend with hot reload
cd frontend && pnpm run dev

# Access at http://localhost:5173
# Login: admin / password

# Production build (single binary)
cd frontend && pnpm run build && cp -r dist/* ../backend/cmd/server/spa/
cd ../backend && DATABASE_PATH=./test-app.db go run cmd/server/main.go

# Core Configuration
PORT=8080                           # Server port
DATABASE_PATH=/app/data/denshimon.db # SQLite database
PASETO_SECRET_KEY=your-32-byte-key  # Auth signing key
TOKEN_DURATION=24h                  # Token expiration
LOG_LEVEL=info                      # Logging level
ENVIRONMENT=production              # Runtime environment

# Gitea Integration (Optional)
GITEA_URL=https://gitea.example.com # Gitea server URL
GITEA_TOKEN=your-api-token          # Gitea API token
GITEA_WEBHOOK_SECRET=webhook-secret # Optional webhook verification

# Mount kubeconfig for cluster access
-v ~/.kube:/home/denshimon/.kube:ro

# Or use in-cluster service account
# Automatically detected when running in K8s pod

• Cluster Resources: CPU, memory, storage utilization
• Node Health: Status, capacity, resource pressure
• Pod Metrics: Resource usage, restart counts, status
• Application Health: Deployment status, replica counts
• GitOps Sync: Repository sync status, last sync times

• Prometheus: Metrics scraping endpoints
• Grafana: Custom dashboards for Denshimon metrics
• Alerting: Webhook integration for notifications
• Audit Logs: SQLite-based audit trail for compliance

• React SPA with cyberpunk UI and proper routing
• PASETO v4 authentication with role-based access
• SQLite database with proper schema
• Kubernetes mock data and interfaces
• GitOps service structure
• Development mode with hot reload
• Single binary deployment capability
• Authentication flow with proper redirects
• Protected routes and token validation
• Dashboard with metrics tabs (overview, nodes, pods, etc.)
• Comprehensive mock data for testing

• Virtualized tables for 50,000+ rows with smooth scrolling
• Live log streaming with search and filtering
• Full Gitea API integration with secure backend architecture
• Dashboard customization (hide/show sections and tabs)
• Anti-SEO protection for internal services
• WebSocket real-time updates for metrics
• Card/table view toggles for different screen sizes
• TypeScript strict mode with comprehensive typing

• Pod exec terminal (WebSocket)
• Real Kubernetes cluster integration
• Port forwarding through web interface
• Custom resource definitions (CRDs)
• Helm chart management
• Custom metrics dashboard builder

• Multi-cluster management
• LDAP/OAuth integration
• Advanced RBAC policies
• Backup and restore
• High availability setup

• Backend Documentation - Go API server details
• Frontend Documentation - React SPA development
• API Reference - Complete endpoint documentation
• Deployment Guide - Production setup instructions

1. Fork the repository
2. Create feature branch (git checkout -b feature/amazing-feature)
3. Commit changes (git commit -m 'Add amazing feature')
4. Push to branch (git push origin feature/amazing-feature)
5. Open a Pull Request

This project is licensed under the MIT License - see the LICENSE file for details.

Made with ❤️ for the Kubernetes community

A modern, secure, and intuitive way to manage your Kubernetes infrastructure with GitOps workflows.