stronghold/references/server-managers.md
robojerk c31e48e2b1 Proof of concept: Container management with FastAPI backend
- FastAPI backend with REST API endpoints
- SQLite database for container metadata
- Docker/Podman SDK integration with label filtering
- Frontend: Server creation form and management page
- Container operations: create, list, start, stop, delete
- Single container deployment (nginx + Python + supervisor)
- Support for Docker and Podman (rootless)
- Volume management for persistent data
2025-10-31 11:50:31 -07:00

207 lines
6.2 KiB
Markdown

# Server Management Web UIs Reference
These are existing web-based Minecraft server management tools that can provide inspiration for Stronghold's UI/UX and feature set.
## Crafty (CraftyControl)
**Website**: https://craftycontrol.com
### Overview
Web-based Minecraft server management tool. Stronghold takes inspiration from Crafty's approach to server management.
### Notable Features (based on common patterns)
- Web-based interface for managing servers
- Docker-based server hosting
- Server creation and configuration UI
- Console access
- File browser/editor
- Backup management
- Plugin/mod management
- User management (multi-user support)
- Server templates/presets
### Design Philosophy
- User-friendly interface
- Simplified server management
- Docker containerization
- Self-hosted solution
### Lessons for Stronghold
- Keep the UI clean and intuitive (KISS principle)
- Make common tasks easy to accomplish
- Provide good defaults with customization options
- Focus on Docker-based deployment
---
## Pterodactyl Panel
**GitHub**: https://github.com/pterodactyl/panel
### Overview
Open-source game server management panel. Supports multiple game types including Minecraft. Uses a client-server architecture with Wings (daemon) and Panel (web UI).
### Architecture
- **Panel**: Web UI (Laravel/PHP)
- **Wings**: Daemon running on game servers (Go)
- **API**: RESTful API between Panel and Wings
- **Database**: MySQL/PostgreSQL
### Key Features
- Multi-server management
- User management and permissions
- Resource allocation (CPU, memory, disk)
- File manager with code editor
- Console access
- Backup system
- Server templates
- Plugin/mod installation
- Resource monitoring
- SFTP access
- Multi-node support (Wings daemons on multiple hosts)
### Technology Stack
- Backend: Laravel (PHP)
- Daemon: Go
- Frontend: React/Vue components
- Database: MySQL/PostgreSQL
### Lessons for Stronghold
- **Pros**:
- Comprehensive feature set
- Multi-user with permissions
- Good separation of concerns (Panel/Daemon)
- Resource management
- **Cons/Considerations**:
- Complex architecture (may violate KISS)
- Requires database
- More overhead than needed for single-host Docker setup
- Can be over-engineered for simple use cases
**Takeaway**: Consider simplified version - Pterodactyl is powerful but complex. Stronghold can be simpler since it's focused on Docker containers rather than multi-node deployments.
---
## Fork (ForkGG)
**GitHub**: https://github.com/ForkGG/Fork
### Overview
Windows-based Minecraft server manager (not web-based). Built with .NET.
### Key Features
- Simple, intuitive UI
- Server creation wizard
- Console management
- File browser
- Plugin/mod installation
- Server templates
- Backup management
- Resource monitoring
### Design Philosophy
- Windows-focused
- User-friendly
- Simplified workflows
### Lessons for Stronghold
- Good UX patterns for server management
- Simple workflows for common tasks
- Focus on ease of use
- Wizard-based server creation (good for beginners)
**Note**: Being Windows-focused limits direct applicability, but UX patterns are valuable.
---
## MCSManager
**GitHub**: https://github.com/MCSManager/MCSManager
### Overview
Open-source Minecraft server management panel. Built with Node.js.
### Architecture
- **Web UI**: React-based frontend
- **Backend**: Node.js/Express API
- **Agent**: Daemon running on servers (also Node.js)
- **Database**: MongoDB (or can use file-based)
### Key Features
- Web-based interface
- Multi-server management
- Console access
- File manager
- Task scheduling
- Backup system
- User management
- Server templates
- Remote server management (via agents)
- REST API
### Technology Stack
- Backend: Node.js/Express
- Frontend: React
- Database: MongoDB (optional, can use files)
- Agents: Node.js daemons
### Lessons for Stronghold
- **Pros**:
- Node.js stack (good for web-based tools)
- Can work without database (file-based)
- REST API architecture
- Good separation (UI/API/Agent)
- **Considerations**:
- Agent-based architecture (may not be needed for Docker-only)
- Can be complex
- MongoDB dependency (unless using file mode)
**Takeaway**: Node.js stack could work well for Stronghold. The agent model might be overkill if we're just managing Docker containers directly.
---
## setupmc.com
**Website**: https://setupmc.com/java-server/
### Overview
Web UI for generating docker-compose.yml files for itzg docker-minecraft-server. Not open source but provides a good example of a configuration generator.
### Key Features
- Interactive web form for server configuration
- Generates docker-compose.yml files
- Handles various server types
- Configuration presets
- Downloadable configuration files
### Lessons for Stronghold
- **Inspiration**: This is essentially a subset of what Stronghold should do
- Shows how to make Docker configuration user-friendly
- Good example of configuration UI patterns
- Proves the value of simplifying Docker setup
**Takeaway**: Stronghold should go beyond just generating configs - should also manage the actual containers, but this is a good reference for the configuration UI.
---
## Comparison Summary
| Feature | Crafty | Pterodactyl | Fork | MCSManager | setupmc.com |
|---------|--------|-------------|------|------------|-------------|
| Web UI | ✅ | ✅ | ❌ | ✅ | ✅ |
| Docker-based | ✅ | ❌ (Wings) | ❌ | ❌ (Agents) | ✅ |
| Multi-user | ✅ | ✅ | ❌ | ✅ | ❌ |
| Complexity | Medium | High | Low | Medium | Low |
| Database | Yes | Yes | No | Optional | No |
| Architecture | Simple | Panel/Daemon | Desktop | UI/API/Agent | Static site |
### Recommendations for Stronghold
1. **KISS Principle**: Keep architecture simple - Docker API directly, no agents/daemons needed
2. **Database**: Start without database (file-based config), add later if needed
3. **Stack**: Node.js/Express + React could be good (like MCSManager but simpler)
4. **Features**: Focus on essential features first:
- Server CRUD operations
- Configuration UI
- Console access
- File browser
- Basic backups
5. **Multi-user**: Can add later, not essential for MVP
6. **UI Patterns**: Study Crafty and Fork for UX inspiration
7. **Configuration**: Use setupmc.com as reference for config UI patterns