Open-Atlas-Node: Manage Your Homelab Like a Cloud Provider

If you've ever used AWS, DigitalOcean, or other cloud platforms, you know how convenient it is to manage servers through a web dashboard. But what if you could have that same experience for your local servers, homelab, or on-premise infrastructure?

Enter Open-Atlas-Node (also called AtlasNode) - a self-hosted, open-source platform that brings cloud-style management to your local machines.

What is Open-Atlas-Node?

Open-Atlas-Node is a centralized monitoring and management system that lets you:

• Monitor multiple servers from a single dashboard
• Execute commands remotely without SSH'ing into each machine
• Access web-based SSH terminals directly in your browser
• Track system metrics in real-time (CPU, memory, disk, network)
• Manage users with role-based access control
• Deploy agents automatically via SSH with zero manual configuration

Think of it as your own private cloud control panel for managing physical servers, VMs, or any Linux/Windows machines you own.

Why It's Useful

1. Unified Dashboard for All Your Machines

Instead of:

# SSH into each machine individually
ssh user@server1
ssh user@server2
ssh user@server3

You get a single web interface showing all your machines, their status, and metrics at a glance.

2. Real-Time Monitoring Without Complexity

No need to set up Prometheus, Grafana, or complex monitoring stacks. Open-Atlas-Node provides:

• Live metrics: CPU, RAM, disk usage, network traffic
• WebSocket updates: Changes reflected instantly
• Historical data: Track trends over time
• Visual graphs: Using Recharts for easy interpretation

Perfect for homelabs where you want monitoring without the overhead of enterprise tools.

3. Web-Based SSH Terminal

Access any managed machine directly from your browser using XTerm.js:

Dashboard → Select Machine → Click "Terminal" → Full shell access

No need to:

• Open separate terminal applications
• Remember IP addresses
• Manage SSH keys locally
• Install VPN clients

Especially useful when you're away from your main workstation or helping someone troubleshoot remotely.

4. Zero-Touch Agent Installation

Adding a new machine is remarkably simple:

1. Click "Add Machine" in the dashboard
2. Enter SSH credentials (password or key)
3. Wait 30 seconds

The installer automatically:

• Detects OS and architecture (Linux, Windows, x64, ARM)
• Installs Node.js if missing
• Downloads and configures the agent
• Sets up systemd/Windows service for auto-start
• Establishes secure communication with the control server

No manual commands. No config file editing. It just works.

5. Remote Control Actions

Execute common operations without SSH:

• Reboot: Restart machines remotely
• Shutdown: Power down safely
• Execute commands: Run scripts or one-off commands
• All logged: Full audit trail of who did what

Great for:

• Managing headless servers
• Scheduled maintenance
• Emergency interventions
• Delegating access to team members

6. Role-Based Access Control

Not everyone needs full admin access:

• Admin role: Full control (add/remove machines, execute commands, manage users)
• Viewer role: Read-only monitoring (see metrics, view logs)

Perfect for:

• Teams where junior members need visibility but not control
• Clients who want to monitor their infrastructure
• Auditors who need read-only access

7. Docker-First Architecture

The entire control server runs in Docker containers:

git clone https://github.com/Aletech-Solutions/Open-Atlas-Node.git
cd atlasnode
./scripts/setup.sh
# Done! Running on http://localhost:3000

Benefits:

• Easy deployment and updates
• Isolated environment
• PostgreSQL database included
• Consistent across environments

8. Secure by Default

Security features built-in:

• JWT authentication: Secure API access
• bcrypt password hashing: No plaintext passwords
• Token-based agent auth: Each agent has a unique token
• Encrypted credentials: SSH passwords stored securely
• Audit logging: Every action tracked
• HTTPS ready: Works behind reverse proxies (Nginx, Caddy)

Architecture Overview

Open-Atlas-Node has three main components:

Control Server (Dashboard)

• Backend: Express.js REST API + WebSocket server
• Frontend: React 18 with TailwindCSS
• Database: PostgreSQL for persistence
• Runs in: Docker containers

Agent (Installed on Each Machine)

• Lightweight: Node.js service (~20MB)
• Collects metrics: Using systeminformation library
• Exposes API: REST endpoints for remote control
• Heartbeat: Regular check-ins to control server
• Auto-start: systemd (Linux) or Windows Service

Auto-Installer

• SSH-based: Connects to target machines
• Zero-touch: Fully automated installation
• Smart detection: OS, architecture, Node.js availability
• Service setup: Configures auto-start on boot

Real-World Use Cases

Homelab Management

You have 5 Raspberry Pis, 2 old laptops running Linux, and a NAS. Instead of SSH'ing into each one to check disk space or update packages, you:

1. Install Open-Atlas-Node on your "main" server
2. Add all machines via the dashboard
3. Monitor everything from your phone/laptop/tablet

Small Business IT

A small company with 10-20 servers (mix of physical and VMs):

• IT team gets admin access for management
• Developers get viewer access to monitor their services
• Remote work: Access machines securely from anywhere
• No VPN needed: Just HTTPS + authentication

Learning Environment

Students learning Linux/DevOps can:

• Practice on multiple VMs
• Monitor resource usage in real-time
• Learn SSH, systemd, process management
• See the impact of their commands on system metrics

Edge Computing

Managing IoT devices or edge servers:

• Deploy agents on ARM devices (Raspberry Pi, etc.)
• Monitor temperature, CPU, network
• Reboot remotely if something hangs
• Execute maintenance scripts

Key Features Breakdown

Feature	Benefit	Use Case
Real-time Metrics	Instant visibility into system health	Catch issues before they cause downtime
Web SSH Terminal	No local terminal needed	Access from any device with a browser
Auto-Installer	Save hours on setup	Add 10 machines in minutes
WebSocket Updates	Live status changes	See machine offline/online instantly
Audit Logs	Compliance & security	Track who rebooted production server
Docker Deployment	Easy updates	docker-compose pull && docker-compose up -d
RBAC	Secure delegation	Give interns read-only access
Cross-Platform	Works everywhere	Linux, Windows, macOS, ARM

Getting Started

Prerequisites

• Docker & Docker Compose installed
• A server to run the control panel (can be one of your managed machines)
• Linux, macOS, or Windows with WSL2

Installation (5 minutes)

# Clone the repository
git clone https://github.com/Aletech-Solutions/Open-Atlas-Node.git
cd atlasnode

# Run setup script
chmod +x scripts/setup.sh
./scripts/setup.sh

The setup script will:

1. Generate secure JWT secret and database password
2. Ask for your server's IP address (for agent communication)
3. Create .env configuration file
4. Build and start Docker containers

Access Dashboard

http://localhost:3000

Or from another machine:

http://YOUR_SERVER_IP:3000

Add Your First Machine

1. Click "Add Machine" button
2. Enter details:
   • Name: "My Home Server"
   • IP Address: 192.168.1.50
   • SSH Port: 22
   • Username: your_user
   • Password or SSH Key
3. Click "Install Agent"
4. Wait ~30 seconds
5. Done! Machine appears in dashboard with live metrics

Configuration

The .env file controls everything:

# Database
DB_NAME=atlasnode
DB_USER=atlasnode
DB_PASSWORD=secure_password_here

# Authentication
JWT_SECRET=your_long_random_secret
JWT_EXPIRES_IN=7d

# Ports
BACKEND_PORT=5000
FRONTEND_PORT=3000

# CRITICAL: Agent Communication
BACKEND_HOST=192.168.1.100  # Your server's IP

Important: Set BACKEND_HOST to your server's actual IP address, not localhost, or agents won't be able to connect back to the control server.

Technology Stack

Backend:

• Express.js (REST API)
• WebSocket (ws library) - real-time updates
• PostgreSQL - data persistence
• SSH2 - agent installation
• JWT - authentication

Frontend:

• React 18
• Vite (fast build tool)
• TailwindCSS (modern styling)
• Recharts (metric visualization)
• XTerm.js (web terminal)
• Axios (HTTP client)

Agent:

• Node.js
• Express (lightweight API)
• systeminformation (cross-platform metrics)

Infrastructure:

• Docker & Docker Compose
• Nginx (optional, for production)

Security Best Practices

When deploying Open-Atlas-Node:

1. Change default credentials in .env immediately
2. Use strong JWT secret: Generate with openssl rand -hex 32
3. Enable HTTPS with reverse proxy (Caddy, Nginx)
4. Firewall rules: Restrict agent port (7777) to control server only
5. SSH key authentication: Prefer keys over passwords
6. Regular updates: Keep dependencies current
7. Monitor audit logs: Review regularly for suspicious activity

Comparison with Alternatives

Feature	Open-Atlas-Node	Cockpit	Webmin	Portainer
Multi-machine	✅ Central dashboard	❌ Per-machine	❌ Per-machine	✅ (Docker only)
Auto-install agents	✅ SSH-based	❌ Manual	❌ Manual	N/A
Web SSH terminal	✅ Built-in	✅ Built-in	✅ Built-in	❌
Real-time metrics	✅ WebSocket	⚠️ Refresh-based	⚠️ Refresh-based	✅
RBAC	✅ Admin/Viewer	✅ Complex	✅ Complex	✅
Docker-first	✅	❌	❌	✅
Focus	Server fleet	Single system	Single system	Containers

When to choose Open-Atlas-Node:

• You manage multiple machines (2+)
• You want centralized monitoring
• You prefer modern web UI over traditional dashboards
• You want easy agent deployment

When to choose alternatives:

• Cockpit/Webmin: Single machine, need deep system configuration
• Portainer: Only managing Docker containers

Roadmap & Future Features

The project is actively developed with planned features:

• Docker container monitoring: Manage containers like Portainer
• Proxmox integration: VM management
• Alert system: Email/webhook notifications for issues
• Mobile app: Native iOS/Android
• Plugin system: Extensibility
• Ansible playbook execution: Configuration management
• Network topology visualization: See your infrastructure

Troubleshooting Common Issues

Agent Shows Offline

# Check agent status
systemctl status atlasnode-agent

# View logs
journalctl -u atlasnode-agent -f

# Verify configuration
cat /opt/atlasnode-agent/config.json

# Ensure auto-start enabled
systemctl is-enabled atlasnode-agent

Installation Fails

• Verify SSH credentials are correct
• Check network connectivity: ping target_machine
• Ensure sudo access on target machine
• Review backend logs: docker-compose logs backend

WebSocket Not Connecting

• Check browser console for errors
• Verify firewall allows WebSocket connections
• Check CORS settings in backend
• Try different browser (test if browser-specific)

Backup & Restore

Backup Database

./scripts/backup.sh
# Creates: backups/atlasnode_backup_TIMESTAMP.sql.gz

Restore Database

gunzip < backups/atlasnode_backup_TIMESTAMP.sql.gz | \
  docker-compose exec -T database psql -U atlasnode atlasnode

Recommendation: Set up automated backups via cron:

# Daily backups at 2 AM
0 2 * * * cd /path/to/atlasnode && ./scripts/backup.sh

Contributing

Open-Atlas-Node is open-source (MIT License) and welcomes contributions:

• Report bugs: GitHub Issues
• Request features: GitHub Discussions
• Submit PRs: Fork, branch, commit, push, PR
• Improve docs: Help others get started

Conclusion

Open-Atlas-Node fills a unique gap: enterprise-style server management for personal and small-scale infrastructure.

You should use it if:

• ✅ You manage 2+ machines (homelab, small business, edge devices)
• ✅ You want cloud-like management for local infrastructure
• ✅ You prefer self-hosted over SaaS
• ✅ You need real-time monitoring without complexity
• ✅ You want to access machines from anywhere (via web)

You can skip it if:

• ❌ You only have one machine (use Cockpit or Webmin)
• ❌ You only manage Docker containers (use Portainer)
• ❌ You already have Prometheus/Grafana/Nagios working
• ❌ You need advanced configuration management (use Ansible/SaltStack)

For homelabbers, small IT teams, and anyone tired of SSH'ing into dozens of machines, Open-Atlas-Node is a game-changer. It brings the convenience of cloud platforms to your own infrastructure—without the monthly bills.

Resources

• GitHub Repository: Open-Atlas-Node
• License: MIT
• Documentation:
  • Configuration Guide
  • API Documentation
  • Agent Setup Guide
  • Contributing Guide

---

Open-Atlas-Node is actively maintained by Aletech Solutions and the open-source community. Star the project on GitHub if you find it useful!