KubeRDE

Kubernetes-native Remote Development Environments

Access your development workspace from anywhere with just a browser - no VPN required.

---

🚀 What is KubeRDE?

KubeRDE is a lightweight, production-ready platform for managing remote development environments on Kubernetes. It securely exposes development workspaces behind NAT/firewalls using WebSocket tunneling, enabling teams to access powerful development environments from anywhere.

Perfect for:

• 🏢 Remote Teams - Provide isolated development environments with centralized management
• 💻 Organizations with Network Restrictions - Access internal resources without VPN complexity
• 🔬 Data Science Teams - Share GPU resources efficiently with automatic idle shutdown
• 🎓 Educational Institutions - Offer pre-configured coding environments to students
• 🌐 Distributed Development - Standardize development environments across teams

✨ Key Features

• 🔐 Secure by Default

  • OIDC/OAuth2 authentication with Keycloak
  • Team-based Multi-tenancy: Shared control plane with isolated team namespaces
  • JWT-based authorization for all connections
  • Audit logging for compliance

• 🌐 Access Anywhere

  • Web-based access through browser - no client installation
  • WebSocket + Yamux multiplexing for efficient connections
  • Works behind NAT and corporate firewalls
  • Custom subdomain routing per workspace

• 🎯 Resource Control

  • Fine-grained CPU, memory, and GPU quotas per user
  • Declarative resource limits via Kubernetes CRDs
  • Real-time resource usage tracking
  • Cost allocation and reporting

• ⚡ Auto-scaling Intelligence

  • Automatic sleep/wake based on activity (TTL-based)
  • Scale-to-zero for cost optimization
  • Operator-managed lifecycle automation
  • Configurable idle timeouts per service

• 🛠️ Multiple IDEs

  • VS Code Server (Coder)
  • JupyterLab for data science
  • SSH terminal access
  • Web-based file browser

• 📊 Full Observability

  • Comprehensive audit logs for all operations
  • Resource usage metrics and dashboards
  • User activity tracking
  • Integration with Prometheus/Grafana

• 🎨 Self-Service UI

  • React-based management console
  • Workspace and service management
  • User quota configuration
  • Template-based workspace creation
  • Agent status monitoring

🎛️ Advanced Features

GPU Resource Management

KubeRDE provides flexible GPU resource management for AI/ML workloads:

• Custom GPU Resource Types: Configure GPU resources with custom Kubernetes resource names (e.g., nvidia.com/gpu, amd.com/gpu, intel.com/gpu)
• Node Scheduling Labels: Set node selector labels (e.g., nvidia.com/gpu.product=NVIDIA-A100-80GB) to schedule workloads on specific GPU types
• Multi-GPU Support: Define different GPU types for heterogeneous clusters (A100, H100, RTX 4090, etc.)
• One-Click Quota Sync: Users can click SYNC on their profile page to automatically inherit all resource types from the system's resource management configuration

How it works:

1. Administrators configure GPU resource types in Resource Management with resource name and node labels
2. Users click SYNC on their personal page to get all available resource types
3. User quotas can be customized after sync to set specific limits per GPU type
4. When creating services (agents), users can specify GPU resources to power AI/ML workloads

GPU-Enabled Services for AI Development

Services (agents) in KubeRDE fully support GPU resource allocation for AI research and development:

• Per-Service GPU Allocation: Each service can request specific GPU resources based on user quota
• AI/ML Workloads: Run training jobs, inference servers, or GPU-accelerated Jupyter notebooks
• Flexible Resource Requests: Specify CPU, memory, storage, and GPU resources independently per service
• Automatic Scheduling: Kubernetes schedules GPU workloads to appropriate nodes based on configured labels

Custom Agent Templates

Create reusable workspace templates with pre-configured settings for your team:

• Template Import/Export: Share templates across environments with JSON export/import
• Pre-configured Services: Define Docker images, ports, environment variables, and volume mounts
• Security Context: Configure UID/GID and other security settings per template
• Multiple Agent Types: Support for SSH, web-based IDEs, Jupyter notebooks, and custom services

Example Template (Claude Code UI):

{
    "exported_at": "2026-01-03T00:01:37Z",
    "template": {
        "name": "claude-code-ui",
        "agent_type": "web",
        "description": "Claude Code UI",
        "docker_image": "soloking/claude-code-ui",
        "default_local_target": "localhost:3001",
        "default_external_port": 3001,
        "env_vars": {
            "PORT": 3001,
            "NODE_ENV": "production"
        },
        "security_context": {},
        "volume_mounts": [
            {
                "name": "workspace",
                "readOnly": false,
                "mountPath": "/home/claudeui"
            }
        ]
    },
    "version": "1.0"
}

Template fields:

• agent_type: Service type (ssh, web, jupyter, coder, file-browser)
• docker_image: Container image to use
• default_local_target: Internal service address
• default_external_port: Exposed port for external access
• env_vars: Environment variables passed to the container
• volume_mounts: Persistent storage configuration
• security_context: Container security settings (UID, GID, capabilities)

🎬 See It In Action

📺 Watch 5-minute overview

🏃 Quick Start

Try It Locally (5 Minutes)

📺 Watch local deployment demo

The fastest way to try KubeRDE without any cloud setup:

# install helm
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-4 | bash

# Using k3s or k3d (Kubernetes in Docker)
# Install k3s
curl -sfL https://get.k3s.io | sh - 
# Or install k3d and create a cluster if you have docker installed
# curl -s https://raw.githubusercontent.com/k3d-io/k3d/main/install.sh | bash
# k3d create cluster kuberde

# Check for Ready node, takes ~30 seconds 
k3s kubectl get node -o wide

# Check k3d cluster load balancer ip
k3s kubectl get svc -A -o wide | grep traefik

# Copy kubeconfig to local (optional for k3d)
cat /etc/rancher/k3s/k3s.yaml > ~/.kube/config

# Deploy KubeRDE ( assume the ip address is 192.168.139.82)
helm upgrade --install kuberde charts/kuberde -f charts/kuberde/values-http.yaml --namespace kuberde --create-namespace \
  --set global.domain=192.168.139.82.nip.io \
  --set global.keycloakDomain=sso.192.168.139.82.nip.io \
  --set global.agentDomain=192.168.139.82.nip.io \
  --set global.protocol=http

# Access at http://192.168.139.82.nip.io
# Login: admin / password

See Local Kubernetes Guide for detailed instructions with kind, minikube, k3d, or Docker Desktop.

🏗️ Architecture

Key Components:

• Server: Public relay with REST API, handles authentication and routes traffic
• Agent: Kubernetes pod that bridges traffic to internal services (SSH, Jupyter, VS Code)
• Operator: Custom Kubernetes operator managing agent lifecycle, PVCs, and TTL-based scaling
• CLI: User utility for OIDC authentication and SSH tunneling
• Web UI: React-based management console

View detailed architecture →

📚 Documentation

Getting Started

• 📖 Quick Start Guide - Get running in 15 minutes
• 🎓 Concepts and Architecture - Understand how it works
• 🔧 Configuration Reference - All configuration options

Platform Guides

• Google Cloud (GKE) - GCE Ingress, Cloud DNS, managed certificates
• AWS (EKS) - ALB Controller, Route53, ACM certificates
• Azure (AKS) - Application Gateway, Azure DNS
• Local Kubernetes - kind, minikube, k3d, Docker Desktop

Operations

• 🛠️ Operations Runbook - Running in production
• 📊 Monitoring and Alerts - Observability setup
• 🔒 Security Best Practices - Hardening your deployment
• 💾 Backup and Recovery - Disaster recovery

Development

• 💻 Developer Guide - Build from source, contribute code
• 🧪 Testing Guide - Run tests, write tests
• 🏗️ Building and Deploying - Local development workflow

Reference

• 📝 API Documentation - REST API reference (coming soon)
• ⚙️ CRD Reference - RDEAgent custom resource
• 🔑 Environment Variables - All env vars

🤝 Contributing

We welcome contributions! KubeRDE is an open-source project and we'd love your help.

Ways to contribute:

• 🐛 Report bugs
• 💡 Suggest features
• 📝 Improve documentation
• 🔧 Submit pull requests
• ⭐ Star the project

Getting Started:

1. Read the Contributing Guide
2. Check out good first issues
3. Join our community discussions

Please read our Code of Conduct before contributing.

💬 Community

• 💬 Discussions: GitHub Discussions - Ask questions, share ideas
• 🐛 Issues: Issue Tracker - Report bugs, request features
• 📧 Email: maintainers@kuberde.io - Contact maintainers

🛣️ Roadmap

See our GitHub Projects for upcoming features and current progress.

Upcoming features:

• Helm chart for easy installation
• Terraform modules for all major cloud providers
• Enhanced Web UI with resource usage graphs
• Multi-cluster support
• Plugin system for custom integrations

📄 License

KubeRDE is licensed under the MIT License.

🙏 Acknowledgments

KubeRDE is built with amazing open source projects:

• Kubernetes - Container orchestration
• Keycloak - Identity and access management
• PostgreSQL - Reliable database
• React - UI framework
• Go - Backend language
• Yamux - Connection multiplexing

Special thanks to all our contributors!

🔗 Related Projects

• frp - Fast reverse proxy (inspiration)
• code-server - VS Code in the browser
• JupyterHub - Multi-user Jupyter environments
• Telepresence - Local Kubernetes development

---

Made with ❤️ by the KubeRDE community

⭐ Star us on GitHub!