🌡️ LMSensors Kubernetes Monitor

Real-time hardware monitoring for Kubernetes clusters with dynamic configuration and beautiful web interface

✨ Features

🔥 Real-time Monitoring: Live hardware sensor data from all cluster nodes
🎨 Modern UI: Beautiful terminal-style web interface with dark theme
⚙️ Dynamic Configuration: ConfigMap-based node management with hot-reload
🚀 Cloud Native: Kubernetes-first design with DaemonSet architecture
📱 Responsive: Works perfectly on desktop and mobile devices
🔄 Smart Discovery: Configurable auto-discovery with manual node control
📊 Multi-Node: Monitor temperature, voltage, and system info across your entire cluster
🛠️ Management Tools: CLI tools for easy configuration management
⚡ Lightweight: Optimized containers with minimal resource footprint

🏗️ Architecture

This project uses a dynamic configuration microservice architecture:

Component	Purpose	Image	Deployment
Sensor DaemonSet	Hardware data collection	`ghcr.io/michaeltrip/lmsensors-daemonset-container`	Runs on every node
Web Dashboard	Modern web interface	`ghcr.io/michaeltrip/lmsensors-web`	Centralized deployment
ConfigMap	Dynamic node configuration	Built-in Kubernetes	Configuration storage

🔧 Sensor DaemonSet

Purpose: Collects hardware sensor data from each node
Technology: Ubuntu + lm_sensors + fastfetch
Deployment: Runs on every node via DaemonSet
Data: Temperature, voltage, fan speeds, system information
Schedule: Updates every 60 seconds
Output: Standardized file format (lmsensors-{node}.txt, fastfetch-{node}.txt)

🌐 Web Dashboard

Purpose: Modern web interface with dynamic configuration
Technology: nginx + responsive HTML/CSS/JS + ConfigMap integration
Features: Real-time updates, configurable nodes, mobile-friendly
Configuration: Loads node definitions from ConfigMap endpoint
Access: Single deployment with service endpoint

⚙️ Dynamic Configuration

Purpose: Centralized node management without code changes
Technology: Kubernetes ConfigMap + custom nginx endpoints
Features: Hot-reload, CLI management, backup/restore
Control: Define which nodes to display with metadata

🚀 Quick Start

Get up and running in under 2 minutes with dynamic configuration:

# Clone the repository
git clone https://github.com/MichaelTrip/lmsensors-container.git
cd lmsensors-container

# Deploy with dynamic configuration
./deploy-dynamic.sh

# Access the dashboard
kubectl port-forward service/sensordash-service 8080:80 -n sensordash

Then open http://localhost:8080 in your browser! 🎉

⚙️ Configuration Management

🎛️ Node Configuration

Define your nodes in the ConfigMap with rich metadata:

{
  "nodes": [
    {
      "name": "virt1",
      "displayName": "Virtual Node 1",
      "description": "Primary virtual machine",
      "status": "online"
    },
    {
      "name": "worker-01",
      "displayName": "Production Worker 01",
      "description": "Main production workload node",
      "status": "online"
    }
  ],
  "settings": {
    "refreshInterval": 30000,
    "fallbackNodes": ["node-001", "node-002"],
    "autoDiscovery": true,
    "displayMode": "terminal"
  }
}

🛠️ Management Tools

Interactive Configuration Manager

# View current configuration
./config-manager.sh view

# Add a new node
./config-manager.sh add worker-02 "Production Worker 02"

# Remove a node
./config-manager.sh remove old-node

# Edit configuration interactively
./config-manager.sh edit

# Backup configuration
./config-manager.sh backup

# Show example configuration
./config-manager.sh example

Direct kubectl Management

# View current node configuration
kubectl get configmap sensordash-config -n sensordash -o jsonpath='{.data.nodes\.json}' | jq .

# Edit configuration directly
kubectl edit configmap sensordash-config -n sensordash

# Apply new configuration
kubectl apply -f deployment-files/configmap.yaml -n sensordash

🔧 Configuration Options

Setting	Description	Default	Example
`refreshInterval`	Update frequency (ms)	`30000`	`60000`
`fallbackNodes`	Placeholder nodes when no data	`[]`	`["node-001", "node-002"]`
`autoDiscovery`	Auto-add discovered nodes	`true`	`false`
`displayMode`	UI theme	`"terminal"`	`"terminal"`

🏷️ Node Properties

Property	Required	Description	Example
`name`	✅	Node identifier (matches sensor files)	`"worker-01"`
`displayName`	❌	Human-readable name	`"Production Worker 01"`
`description`	❌	Node description (shown in tooltips)	`"Main production node"`
`status`	❌	Default status indicator	`"online"`

📦 Container Images

Container	Registry	Latest Version
DaemonSet	`ghcr.io/michaeltrip/lmsensors-daemonset-container:latest`
Web UI	`ghcr.io/michaeltrip/lmsensors-web:latest`

🔧 Requirements

Kubernetes cluster (1.19+)
Persistent volume support (ReadWriteMany)
Privileged container support (for hardware access)
jq command-line tool (for config-manager.sh)

📋 What You'll Monitor

🌡️ CPU Temperature - Real-time thermal monitoring
⚡ Voltage Rails - Power supply monitoring
🌀 Fan Speeds - Cooling system status
💾 System Info - Hardware specifications
📊 Node Status - Health indicators with custom metadata
🔄 Live Updates - Configurable auto-refresh intervals
🏷️ Custom Labels - User-defined display names and descriptions

🛠️ Deployment Options

🚀 Dynamic Configuration (Recommended)

# Deploy with ConfigMap-based dynamic configuration
./deploy-dynamic.sh

# Manage nodes with CLI tool
./config-manager.sh view
./config-manager.sh add worker-03 "Worker Node 03"

📁 Project Structure

├── sensor-container/         # DaemonSet container source
├── web-container/           # Web interface container source
├── deployment-files/        # Kubernetes manifests
│   ├── configmap.yaml      # Dynamic node configuration
│   ├── webserver-modern.yaml # Web deployment with ConfigMap
│   ├── daemonset.yaml      # Sensor collection DaemonSet
│   └── pvc.yaml           # Persistent volume claim
├── deploy-dynamic.sh        # Quick deployment with ConfigMap
├── config-manager.sh        # Configuration management CLI
├── .github/workflows/       # CI/CD pipelines
└── cleanup.sh              # Cleanup script

🛠️ Manual Deployment

Click to expand manual deployment steps

# 1. Create namespace
kubectl create namespace sensordash

# 2. Deploy dynamic configuration
kubectl apply -f deployment-files/configmap.yaml -n sensordash

# 3. Deploy persistent volume claim
kubectl apply -f deployment-files/pvc.yaml -n sensordash

# 4. Deploy sensor collection DaemonSet
kubectl apply -f deployment-files/daemonset.yaml -n sensordash

# 5. Deploy web dashboard with ConfigMap integration
kubectl apply -f deployment-files/webserver-modern.yaml -n sensordash

# 6. Access the dashboard
kubectl port-forward service/sensordash-service 8080:80 -n sensordash

🎯 Configuration Examples

Basic Node Setup

{
  "nodes": [
    {
      "name": "control-plane",
      "displayName": "Control Plane",
      "description": "Kubernetes master node",
      "status": "online"
    },
    {
      "name": "worker-01",
      "displayName": "Worker Node 01",
      "description": "Production workload node",
      "status": "online"
    }
  ]
}

Advanced Configuration

{
  "nodes": [
    {
      "name": "gpu-node-01",
      "displayName": "🎮 GPU Worker 01",
      "description": "NVIDIA RTX 4090 - ML Training Node",
      "status": "online"
    },
    {
      "name": "storage-node",
      "displayName": "💾 Storage Node",
      "description": "High-capacity storage with NVMe arrays",
      "status": "warning"
    }
  ],
  "settings": {
    "refreshInterval": 15000,
    "fallbackNodes": ["placeholder-01", "placeholder-02"],
    "autoDiscovery": false,
    "displayMode": "terminal"
  }
}

kubectl apply -f deployment-files/webserver-modern.yaml

4. Access the dashboard

kubectl port-forward service/sensordash-service 8080:80


</details>

## 🧹 Cleanup

Remove all components safely:

```bash
./cleanup.sh

# Or manual cleanup
kubectl delete namespace sensordash --cascade=foreground

The cleanup script will:

Remove all deployments and services
Delete the sensordash namespace
Optionally preserve your sensor data
Confirm before destructive operations

🔄 Configuration Updates

Hot Reload Configuration

Changes to the ConfigMap are automatically picked up by the web interface:

# Method 1: Use the management tool
./config-manager.sh add new-node "New Node Display Name"

# Method 2: Edit directly
kubectl edit configmap sensordash-config -n sensordash

# Method 3: Apply updated file
kubectl apply -f deployment-files/configmap.yaml -n sensordash

Backup and Restore

# Backup current configuration
./config-manager.sh backup
# Creates: sensordash-config-backup-YYYYMMDD-HHMMSS.json

# Restore from backup
./config-manager.sh restore sensordash-config-backup-20250910-143022.json

🚀 CI/CD Pipeline

This project uses semantic versioning with conventional commits:

🎯 Automatic versioning based on commit messages
🏗️ Parallel container builds for optimal speed
📦 Multi-platform support (linux/amd64)
🔄 Auto-deployment file updates
🏷️ Smart tagging with semantic versions

Commit Convention

feat: add new sensor support     # → Minor version bump
fix: resolve memory leak         # → Patch version bump
feat!: breaking API change       # → Major version bump

👨‍💻 Development

Local Development

# Build containers locally
docker build -t lmsensors-daemonset:dev sensor-container/
docker build -t lmsensors-web:dev web-container/

# Test with docker-compose (if available)
docker-compose up

# Test configuration changes
kubectl apply -f deployment-files/configmap.yaml -n sensordash
./config-manager.sh view

Contributing

🍴 Fork the repository
🌿 Create a feature branch
📝 Use conventional commits
🧪 Test your changes
� Test ConfigMap functionality
�📤 Submit a pull request

Testing Configuration Changes

# Test configuration manager
./config-manager.sh example
./config-manager.sh add test-node "Test Node"
./config-manager.sh view
./config-manager.sh remove test-node

# Test web interface updates
kubectl port-forward service/sensordash-service 8080:80 -n sensordash
# Visit http://localhost:8080 and verify changes

📖 Advanced Usage

Custom nginx Configuration

The ConfigMap includes nginx configuration for serving the node configuration:

# Custom endpoint in ConfigMap
location /config/nodes.json {
    alias /etc/sensordash/nodes.json;
    add_header Content-Type application/json;
    add_header Cache-Control "no-cache, no-store, must-revalidate";
}

Integration with Monitoring Tools

Export configuration for external tools:

# Get configuration in various formats
kubectl get configmap sensordash-config -n sensordash -o jsonpath='{.data.nodes\.json}' | jq .

# Export for Prometheus labels
kubectl get configmap sensordash-config -n sensordash -o jsonpath='{.data.nodes\.json}' | jq -r '.nodes[] | "\(.name)=\(.displayName)"'

Multi-Environment Setup

Use different ConfigMaps per environment:

# Development
kubectl apply -f configmaps/dev-config.yaml -n sensordash-dev

# Production
kubectl apply -f configmaps/prod-config.yaml -n sensordash-prod

📸 Screenshots

🖥️ Desktop View

Modern terminal-style interface with real-time sensor data

🤝 Support

📖 Documentation: Check our Wiki
🐛 Issues: Report bugs
💡 Features: Request features
💬 Discussions: Community discussions

📄 License

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

⭐ Show Your Support

If this project helped you, please consider:

⭐ Starring the repository
🍴 Forking for your own use
📢 Sharing with others
🐛 Contributing improvements

Built with ❤️ for the Kubernetes community

Caution

Running containers with privileged access can pose security risks. Be cautious where and how you use such configurations.

FilesExpand file tree

README.md

Latest commit

History