Deploying Minus Games

Introduction

Minus Games is a self-hosted game server management platform designed to simplify the deployment and administration of multiplayer game servers. It provides a unified web interface for managing multiple game servers, monitoring performance, and configuring server settings without requiring deep technical knowledge of each game’s server requirements.

The platform supports a wide variety of popular multiplayer games and provides features like automatic updates, scheduled restarts, backup management, and resource monitoring. Minus Games abstracts away the complexity of running game servers, making it accessible to gaming communities and server administrators alike.

Key highlights of Minus Games:

Multi-Game Support: Host servers for various popular multiplayer games from a single management interface
Web-Based Dashboard: Intuitive browser-based control panel for all server administration tasks
Automatic Updates: Keep game servers up-to-date automatically with configurable update schedules
Resource Monitoring: Track CPU, memory, and network usage for each game server instance
Backup Management: Create and restore server backups with scheduled backup jobs
Player Management: View connected players and manage bans across supported games
Scheduled Tasks: Configure automatic restarts, updates, and maintenance windows
Multi-User Access: Grant team members access with role-based permissions
Docker Native: Built for containerized deployments with easy scaling capabilities

This guide walks through deploying Minus Games on Klutch.sh using Docker, configuring the web interface, and setting up your first game server.

Why Deploy Minus Games on Klutch.sh

Deploying Minus Games on Klutch.sh provides several advantages for game server management:

Simplified Deployment: Klutch.sh automatically detects your Dockerfile and builds Minus Games without complex server configuration. Push to GitHub, and your game server manager deploys automatically.

Persistent Storage: Attach persistent volumes for game server data, configurations, and backups. Your servers and settings survive container restarts and redeployments.

HTTPS by Default: Klutch.sh provides automatic SSL certificates for secure access to your management dashboard from anywhere.

GitHub Integration: Connect your configuration repository directly from GitHub. Updates to your Dockerfile trigger automatic redeployments.

Scalable Resources: Allocate CPU and memory based on the number and type of game servers you plan to host. Scale resources as your community grows.

Environment Variable Management: Securely store sensitive configuration through Klutch.sh’s environment variable system without exposing credentials in your repository.

Custom Domains: Assign a custom domain to your Minus Games dashboard for a professional, branded experience.

Always-On Availability: Your game servers remain accessible 24/7 without managing your own hardware.

Prerequisites

Before deploying Minus Games on Klutch.sh, ensure you have:

A Klutch.sh account
A GitHub account with a repository for your Minus Games configuration
Basic familiarity with Docker and containerization concepts
Understanding of game server networking requirements
(Optional) A custom domain for your Minus Games instance

Preparing Your Repository

To deploy Minus Games on Klutch.sh, create a GitHub repository containing your Dockerfile and configuration.

Repository Structure

minus-games-deploy/
├── Dockerfile
├── README.md
└── .dockerignore

Creating the Dockerfile

Create a Dockerfile in the root of your repository:

FROM minusgames/minus-games:latest

# Set environment variables
ENV ADMIN_USERNAME=${ADMIN_USERNAME:-admin}
ENV ADMIN_PASSWORD=${ADMIN_PASSWORD}
ENV SECRET_KEY=${SECRET_KEY}
ENV TZ=${TZ:-UTC}

# Create necessary directories
RUN mkdir -p /data/servers /data/backups /data/logs

# Expose the web interface port
EXPOSE 8080

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
  CMD curl -f http://localhost:8080/health || exit 1

Environment Variables Reference

Variable	Required	Default	Description
`ADMIN_USERNAME`	No	admin	Username for the admin account
`ADMIN_PASSWORD`	Yes	-	Password for the admin account
`SECRET_KEY`	Yes	-	Secret key for session encryption
`TZ`	No	UTC	Timezone for the container
`DATABASE_URL`	No	SQLite	Database connection string

Deploying Minus Games on Klutch.sh

Generate Security Keys

Before deployment, generate a secure secret key:

openssl rand -hex 32

Save this key securely for the environment variables configuration.

Push Your Repository to GitHub

Initialize your repository and push to GitHub:

git init
git add Dockerfile .dockerignore README.md
git commit -m "Initial Minus Games deployment configuration"
git remote add origin https://github.com/yourusername/minus-games-deploy.git
git push -u origin main

Create a New Project on Klutch.sh

Navigate to the Klutch.sh dashboard and create a new project. Give it a descriptive name like “minus-games” or “game-servers”.

Create a New App

Within your project, create a new app. Connect your GitHub account if you haven’t already, then select the repository containing your Minus Games Dockerfile.

Configure HTTP Traffic

In the deployment settings:

Select HTTP as the traffic type
Set the internal port to 8080

Set Environment Variables

In the environment variables section, add:

Variable	Value
`ADMIN_USERNAME`	Your admin username
`ADMIN_PASSWORD`	Your secure admin password
`SECRET_KEY`	Your generated secret key
`TZ`	Your timezone (e.g., `America/New_York`)

Attach Persistent Volumes

Add the following volumes:

Mount Path	Recommended Size	Purpose
`/data`	50 GB	Application data and database
`/data/servers`	100+ GB	Game server files and data
`/data/backups`	50 GB	Server backups
`/data/logs`	5 GB	Application and server logs

Deploy Your Application

Click Deploy to start the build process. Klutch.sh will build the container, attach volumes, and provision HTTPS.

Access Minus Games

Once deployment completes, access your dashboard at https://your-app-name.klutch.sh. Log in with your configured admin credentials.

Initial Configuration

Setting Up Your First Game Server

After logging in to the Minus Games dashboard:

Navigate to Servers and click Add Server
Select the game type from the available options
Configure server settings (name, ports, player limits)
Allocate resources (CPU, memory limits)
Click Create to initialize the server

Configuring Server Settings

Each game server has specific configuration options:

Server Name: Display name shown in server browsers
Max Players: Maximum concurrent player connections
Game Mode: Game-specific modes and rulesets
Map Rotation: Configure map cycling for applicable games
Admin Access: Set up RCON or admin passwords

Monitoring and Management

Resource Monitoring

The dashboard provides real-time monitoring:

CPU usage per server
Memory consumption
Network bandwidth
Disk usage
Player counts

Backup Management

Configure automatic backups:

Navigate to Backups in server settings
Set backup schedule (daily, weekly)
Configure retention policy
Enable compression for storage efficiency

Troubleshooting

Server Won’t Start

Verify sufficient resources are allocated
Check game-specific port requirements
Review server logs for error messages

Connection Issues

Ensure firewall rules allow game traffic
Verify server is advertising the correct IP
Check player slots haven’t been exceeded

Performance Problems

Allocate additional CPU/memory resources
Reduce player limits
Disable resource-intensive features

Additional Resources

Conclusion

Deploying Minus Games on Klutch.sh provides a powerful, centralized platform for managing multiplayer game servers. With automatic builds, persistent storage, and HTTPS access, you can focus on building your gaming community rather than managing infrastructure. The web-based dashboard makes server administration accessible to everyone on your team.