Atlas - Kubernetes Cluster Dashboard

Atlas is a fast, lightweight, read-only Kubernetes monitoring dashboard for SREs and developers. Named after the Titan who holds up the celestial sphere, Atlas provides a comprehensive view of your entire Kubernetes infrastructure.

✨ Key Features

• Read-Only & Safe - Zero write operations, perfect for production monitoring
• High Performance - Optimized for 50+ concurrent users with intelligent caching
• Comprehensive Views - Pods, Deployments, Services, Ingresses, ConfigMaps, Secrets, PV/PVC, CRDs
• Resource Relationships - Track dependencies and connections between resources
• Health Dashboard - Real-time cluster health with node monitoring and events
• Modern UI - Dark theme with collapsible sections and responsive design

Namespace Specific Dashboard

Resources Relationship Explorer

Release View

Easy Navigation between resources.

🚀 Quick Start

Prerequisites

• Go 1.21+
• Access to Kubernetes cluster
• kubectl configured

Installation

```bash git clone https://github.com/Fanatic-zer0/atlas.git cd atlas make build ./bin/atlas ```

Access dashboard at http://localhost:8080

Configuration

Environment Variables:

• PORT - Server port (default: 8080)
• KUBECONFIG - Path to kubeconfig (default: ~/.kube/config)

📡 Main API Endpoints

Endpoint	Description
GET /api/cluster	Cluster information
GET /api/health/{namespace}	Health dashboard with nodes & events
GET /api/resources/{namespace}	All resources with filtering
GET /api/ingresses/{namespace}	Ingresses with Kong plugins
GET /api/services/{namespace}	Services with endpoints
GET /api/pods/{namespace}	Pods with status
GET /api/deployments/{namespace}	Deployments with replicas
GET /api/configmaps/{namespace}	ConfigMaps
GET /api/secrets/{namespace}	Secrets metadata
GET /api/pvpvc/{namespace}	PV/PVC with pod usage
GET /api/crds	Custom Resource Definitions
GET /api/cache/stats	Cache statistics
POST /api/cache/clear	Clear cache

🎨 UI Tabs

Tab	Features
Health	Resource summary, pod/deployment/service health, cluster events
Cluster	Nodes with system info, conditions, and addresses
Resources	Unified view with type filtering and search
Ingresses	LoadBalancer IPs, Kong plugins, routing rules
Services	Endpoints, ports, selectors
Pods	Status, containers, restarts, IP, node
Deployments	Replicas, images, resources
ConfigMaps/Secrets	Keys, usage tracking
PV/PVC	Storage types, capacity, pod usage
CRDs	Versions, scope, categories

🐳 Docker Deployment

Build

# Single-arch (current platform)
make docker-build

# Multi-arch (linux/amd64 + linux/arm64) — requires a registry
make docker-buildx IMAGE=yourrepo/atlas:latest

# Multi-arch local test build (current arch only, no registry needed)
make docker-buildx-load

Run with a kubeconfig file

Mount your local kubeconfig into the container and point KUBECONFIG at it:

make docker-run

Which expands to:

docker run -p 8080:8080 \
  -v ~/.kube/config:/home/appuser/.kube/config:ro \
  -e KUBECONFIG=/home/appuser/.kube/config \
  atlas:latest

Tip: If your kubeconfig references local certificate files (e.g. certificate-authority: /Users/you/...), use embedded credentials instead (certificate-authority-data in base64). EKS, GKE, and AKS kubeconfigs typically do this already.

---

3. Authentication

Atlas has no built-in authentication. For multi-user access, place an authenticating reverse proxy in front of it. Two common options:

Option A — oauth2-proxy (SSO via Google / GitHub / OIDC)

# Add to your Ingress annotations (nginx example)
nginx.ingress.kubernetes.io/auth-url: "https://oauth2-proxy.monitoring.svc/oauth2/auth"
nginx.ingress.kubernetes.io/auth-signin: "https://atlas.example.com/oauth2/start?rd=$escaped_request_uri"

Deploy oauth2-proxy as a sidecar or separate deployment, configured for your identity provider (Google Workspace, GitHub Org, Okta, etc.).

Option B — Basic auth via Ingress

# Create htpasswd secret
htpasswd -c auth admin
kubectl create secret generic atlas-basic-auth --from-file=auth -n monitoring

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: atlas
  namespace: monitoring
  annotations:
    nginx.ingress.kubernetes.io/auth-type: basic
    nginx.ingress.kubernetes.io/auth-secret: atlas-basic-auth
    nginx.ingress.kubernetes.io/auth-realm: "Atlas — Kubernetes Dashboard"
spec:
  rules:
  - host: atlas.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: atlas
            port:
              number: 80

For production, Option A (SSO) is strongly preferred — it ties access to your existing identity provider and supports audit logging.

🛡️ Security & RBAC

Read-Only Operations:

• Only List() and Get() operations
• No Create, Update, Delete, or Patch

Minimal RBAC:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: atlas-viewer
rules:
- apiGroups: ["", "apps", "batch", "networking.k8s.io", "apiextensions.k8s.io"]
  resources: ["*"]
  verbs: ["get", "list"]

📈 Performance

Concurrent Users	Response Time	Notes
10-30	<100ms	Excellent
30-50	100-200ms	Good
50-70	200-300ms	Acceptable

Optimizations:

• ResourceVersion-based change detection (50-70% fewer API calls)
• 30-second intelligent caching
• Concurrent resource fetching (3-6x faster)
• Connection pool tuning (200 max idle, 50 QPS, 100 burst)

🔧 Development

make deps      # Install dependencies
make build     # Build binary
make run       # Run locally
make test      # Run tests
make fmt       # Format code

📝 License

MIT License

---

Made with ❤️ for SREs and Platform Engineers

Atlas - Supporting your entire Kubernetes world.