Skip to content
crossplane-contribPublic

About

A web-based dashboard for visualizing, monitoring, and troubleshooting Crossplane resources across Kubernetes clusters, with real-time updates, resource relationships, and infrastructure insights.

Topics

Resources

Code of conduct

Contributing

Security policy

Stars

290 stars

Watchers

0 watching

Forks

Crossview Logo

Crossview - Crossplane Dashboard

A modern React-based dashboard for managing and monitoring Crossplane resources in Kubernetes. Visualize, search, and manage your infrastructure-as-code with ease.

Join Crossview on Slack Join Crossview on Coidea

GitHub stars License: Apache 2.0 Artifact Hub View on KikPlate

Bootstrapped with the KikPlate fullstack composed template.

Support this project: Buy Me a Coffee

Crossview Dashboard

Demo Video

📹 Watch Demo Video

Table of Contents

Features

  • Real-Time Resource Watching: Monitor any Kubernetes resource in real-time with event-driven updates using Kubernetes Informers
  • Multi-Cluster Support: Manage and switch between multiple Kubernetes contexts seamlessly
  • Resource Visualization: Browse and visualize Crossplane resources (providers, XRDs, compositions, claims, etc.)
  • Resource Graph: Browse theme-aware list columns arranged as XRDs, compositions, functions above composite resources in a shared column, and composed resources. Compositions connect directly to the adjacent functions and composite resources; composite resources connect directly to composed resources, with spacious connection gutters and filled-circle endpoints. Hover or focus a row to highlight its connections and related resources, or select it to open details. Filters and resource limits remain available; there is no graph canvas, panning, or zooming.
  • Infrastructure Dashboard: View snapshot metrics, readiness and creation charts, namespace distribution, package health, composition usage, resources needing attention, and recently created resources. Use the Panels menu to show or hide panels, reorder them, resize them, or reset the layout; preferences are saved in your browser.
  • Resource Details: View comprehensive resource information including status conditions, metadata, events, and relationships
  • Modern UI: Built with React and Chakra UI with dark mode support
  • Persistent Navigation: The main sidebar remembers whether it is collapsed or expanded across page reloads in the same browser.
  • High Performance: Backend built with Go and Gin framework for optimal performance
  • WebSocket Support: Real-time updates via WebSocket connections
  • SSO Integration: Support for OIDC and SAML authentication

The dashboard loads a snapshot for the selected Kubernetes context; use Refresh to reload it. Failed collections are reported as unavailable or partial, and totals include successfully loaded resources only. Creation charts show surviving resources by creation date (UTC), not an audit log or historical health.

Dashboard panels and Graph columns show placeholders while their first snapshot loads; headers and controls stay visible. Recent snapshots are reused in memory for the same repository and Kubernetes context for 60 seconds. Older snapshots stay visible while a background request refreshes them, and refresh errors are shown without discarding the previous snapshot. Refresh explicitly reloads the snapshot; the backend may still serve managed resources from its own cache. The in-memory cache holds at most six snapshots, is cleared on logout, and does not survive a browser reload.

The existing Graph search searches all loaded resources, including those hidden by display limits. Selecting a result or using Focus shows only that resource's relationship path, without unrelated rows. Focus takes precedence over name, kind, namespace, health, and type filters and shows the complete path up to the 10,000-resource rendering safety limit. Larger paths still use resource limits and show a partial-view warning. Use Show all resources to leave focus.

The dashboard was originally copied byte-for-byte from Crossview Enterprise. The open-source loading and snapshot-cache improvements intentionally diverge from that copy; the enterprise repository is not modified. The existing crossview.enterprise.dashboard.layout browser storage key is retained to preserve saved panel preferences.

Getting Started

Prerequisites

  • Node.js 20+ (for frontend development)
  • Go 1.24+ (for backend server)
  • PostgreSQL database — required for local username/password login. Session-based OIDC SSO also supports database.enabled: false (see SSO Setup). For local development without authentication, set server.auth.mode: none in config/config.yaml (see config/examples/config-none.yaml.example).
  • Kubernetes config file at ~/.kube/config (or set KUBECONFIG env var)

Install Dependencies

npm install

Configuration

Copy the example config file and update with your settings:

cp config/config.yaml.example config/config.yaml

Edit config/config.yaml with your database credentials:

  • Database port: 8920 (or your port)
  • Database password: password (or your password)

Alternatively, use environment variables (they take precedence):

export DB_HOST=localhost
export DB_PORT=8920
export DB_NAME=crossview
export DB_USER=postgres
export DB_PASSWORD=password

Development

Run Frontend and Backend separately:

Terminal 1 - Frontend:

npm install
npm run dev

Terminal 2 - Backend (Go server):

cd crossview-go-server
go run main.go app:serve

The app will be available at http://localhost:5173 (frontend proxies /api requests to backend at http://localhost:3001)

Build

Build for production:

npm run build

This creates a dist/ folder with the compiled frontend.

Production Mode

To run in production mode:

  1. Build the frontend:
npm run build
  1. Run the Go server (it will serve the frontend from the dist/ folder):
cd crossview-go-server
go run main.go app:serve

The app will be available at http://localhost:3001 (both frontend and API)

Backend API

The backend API is built with Go using the Gin framework and runs on port 3001. It provides the following endpoints:

  • GET /api/health - Health check and connection status
  • GET /api/contexts - List available Kubernetes contexts
  • GET /api/contexts/current - Get current Kubernetes context
  • POST /api/contexts/current - Set Kubernetes context
  • GET /api/resources?apiVersion=&kind=&namespace=&context= - List resources
  • GET /api/resource?apiVersion=&kind=&name=&namespace=&context= - Get single resource
  • GET /api/events?kind=&name=&namespace=&context= - Get resource events
  • GET /api/managed?context= - List managed resources
  • GET /api/watch - WebSocket endpoint for real-time resource watching
  • POST /api/auth/login - User login
  • POST /api/auth/logout - User logout
  • GET /api/auth/check - Check authentication status

The backend uses the Go Kubernetes client with Informers for efficient, event-driven resource monitoring:

When running in a Kubernetes pod:

  • Automatically uses service account token (no config file needed)
  • Accesses the same cluster the pod is running in
  • Uses /var/run/secrets/kubernetes.io/serviceaccount/

When running locally:

  • ~/.kube/config (default)
  • KUBECONFIG environment variable

See Kubernetes Deployment Guide for deployment examples.

Helm Chart

Crossview can be deployed using Helm, which simplifies Kubernetes deployment and management.

Add the Helm Repository

helm repo add crossview https://crossplane-contrib.github.io/crossview
helm repo update

Install with Helm

helm install crossview crossview/crossview \
  --namespace crossview \
  --create-namespace \
  --set secrets.dbPassword=your-db-password \
  --set secrets.sessionSecret=$(openssl rand -base64 32)

For more details, see:

Docker

Build the Docker Image

docker build -t ghcr.io/crossplane-contrib/crossview:latest .

Images are published to GHCR (ghcr.io/crossplane-contrib/crossview) on each release.

Run with Environment Variables (Recommended)

Environment variables take precedence over config files:

docker run -p 3001:3001 \
  -e DB_HOST=host.docker.internal \
  -e DB_PORT=8920 \
  -e DB_NAME=crossview \
  -e DB_USER=postgres \
  -e DB_PASSWORD=password \
  -e KUBECONFIG=/app/.kube/config \
  -e SESSION_SECRET=your-secret-key-here \
  -v ~/.kube/config:/app/.kube/config:ro \
  ghcr.io/crossplane-contrib/crossview:latest

Run with Config File

Mount your config file as a volume:

docker run -p 3001:3001 \
  -v $(pwd)/config/config.yaml:/app/config/config.yaml:ro \
  -e KUBECONFIG=/app/.kube/config \
  -v ~/.kube/config:/app/.kube/config:ro \
  ghcr.io/crossplane-contrib/crossview:latest

Run with Docker Compose

Create a docker-compose.yml:

services:
  crossview:
    build: .
    ports:
      - "3001:3001"
    environment:
      - DB_HOST=postgres
      - DB_PORT=5432
      - DB_NAME=crossview
      - DB_USER=postgres
      - DB_PASSWORD=password
      - KUBECONFIG=/app/.kube/config
      - SESSION_SECRET=your-secret-key-here
    volumes:
      - ./config/config.yaml:/app/config/config.yaml:ro
      - ~/.kube/config:/app/.kube/config:ro
    depends_on:
      - postgres

  postgres:
    image: postgres:latest
    environment:
      - POSTGRES_DB=crossview
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password
    ports:
      - "8920:5432"
    volumes:
      - postgres_data:/var/lib/postgresql

volumes:
  postgres_data:

Then run:

docker-compose up

Configuration Priority

The application loads configuration in this order (highest to lowest priority):

  1. Environment variables (e.g., DB_HOST, DB_PORT, DB_PASSWORD)
  2. Config file (config/config.yaml - mounted or included in image)
  3. Default values (fallback)

Required Environment Variables for Docker

  • DB_HOST - Database host (use host.docker.internal for local DB, or service name in Docker Compose)
  • DB_PORT - Database port (default: 5432)
  • DB_NAME - Database name
  • DB_USER - Database user
  • DB_PASSWORD - Database password
  • KUBECONFIG or KUBE_CONFIG_PATH - Path to Kubernetes config file inside container
  • SESSION_SECRET - Secret for session encryption (optional, has default)

Documentation

Getting Started

Deployment

Configuration

Support

Community

Tech Stack

Frontend

  • React - UI library
  • Vite - Build tool and dev server
  • Chakra UI - Component library
  • React Router - Routing
  • WebSocket - Real-time updates

Backend

  • Go - Programming language
  • Gin - Web framework
  • Kubernetes client-go - Kubernetes API client
  • Kubernetes Informers - Event-driven resource watching
  • PostgreSQL - Database (via GORM)

Contributing

Contributions are welcome. Please read the Contributing Guide for development setup, PR guidelines, and how to report issues. By participating, you agree to our Code of Conduct. To see where the project is headed, check the Roadmap.

Community

Join the Crossview topic on Coidea to follow the latest Crossview posts and updates, explore new ideas, and connect with the community.

Anyone can publicly browse ideas shared in the topic. Request to join if you would like to publish your own Crossview ideas, find collaborators, or start discussions around those ideas.

For code contributions, bug reports, and pull requests, continue to use the Contributing Guide and GitHub.

License

This project is open source and available under the Apache License 2.0.

About

A web-based dashboard for visualizing, monitoring, and troubleshooting Crossplane resources across Kubernetes clusters, with real-time updates, resource relationships, and infrastructure insights.

Topics

Resources

Code of conduct

Contributing

Security policy

Stars

290 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages