Deploying PufferPanel

Introduction

PufferPanel is a free, open-source game server management panel designed to be both simple to use and powerful enough for advanced users. It provides an intuitive web interface for managing game servers, handling everything from installation to daily administration without requiring command-line expertise.

Built with Go on the backend and Vue.js for the frontend, PufferPanel is lightweight and efficient. It supports a wide variety of games through its template system and can manage servers running on the same machine or distributed across multiple nodes.

Key highlights of PufferPanel:

Easy to Use: Clean, intuitive interface for server management
Multi-Game Support: Minecraft, Source games, Rust, and more
Template System: Easily add support for new games
User Management: Create users with specific permissions
File Manager: Web-based file browser and editor
Console Access: Real-time server console
SFTP Access: Secure file transfer capability
Docker Support: Run servers in isolated containers
OAuth2 Integration: Support for external authentication
Open Source: Licensed under Apache 2.0

This guide walks through deploying PufferPanel on Klutch.sh using Docker.

Why Deploy PufferPanel on Klutch.sh

Deploying PufferPanel on Klutch.sh provides several advantages:

Simplified Deployment: Klutch.sh automatically detects your Dockerfile and builds PufferPanel without complex configuration.

Persistent Storage: Attach persistent volumes for server data and configurations.

HTTPS by Default: Klutch.sh provides automatic SSL certificates for secure access.

GitHub Integration: Connect your repository directly from GitHub for automatic deployments.

Custom Domains: Assign a custom domain for your game server panel.

Always-On Availability: Your management panel remains accessible 24/7.

Prerequisites

Before deploying PufferPanel on Klutch.sh, ensure you have:

A Klutch.sh account
A GitHub account with a repository for your PufferPanel configuration
Basic familiarity with Docker and containerization concepts
(Optional) A custom domain for your PufferPanel instance
(Optional) Additional servers for running game servers

Preparing Your Repository

Create a GitHub repository containing your Dockerfile for PufferPanel deployment.

Repository Structure

pufferpanel-deploy/
├── Dockerfile
└── .dockerignore

Creating the Dockerfile

Create a Dockerfile in the root of your repository:

FROM pufferpanel/pufferpanel:latest

# Create data directories
RUN mkdir -p /etc/pufferpanel /var/lib/pufferpanel/servers

# Set environment variables
ENV PUFFER_PANEL_SETTINGS=/etc/pufferpanel/config.json
ENV PUFFER_LOGS=/var/log/pufferpanel

EXPOSE 8080 5657

CMD ["pufferpanel", "run"]

Creating the .dockerignore File

Create a .dockerignore file:

.git
.github
*.md
LICENSE
.gitignore
*.log
.DS_Store

Deploying PufferPanel on Klutch.sh

Push Your Repository to GitHub

Initialize your repository and push to GitHub:

git init
git add Dockerfile .dockerignore
git commit -m "Initial PufferPanel deployment configuration"
git remote add origin https://github.com/yourusername/pufferpanel-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 “pufferpanel” 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 PufferPanel Dockerfile.

Configure HTTP Traffic

In the deployment settings:

Select HTTP as the traffic type
Set the internal port to 8080 for the web interface

Attach Persistent Volumes

Add the following volumes:

Mount Path	Recommended Size	Purpose
`/etc/pufferpanel`	100 MB	Configuration files
`/var/lib/pufferpanel`	100+ GB	Server files and data
`/var/log/pufferpanel`	5 GB	Log files

Deploy Your Application

Click Deploy to start the build process. Klutch.sh will:

Detect your Dockerfile automatically
Build the container image
Attach the persistent volumes
Start the PufferPanel container
Provision an HTTPS certificate

Create Admin User

After deployment, create your administrator account:

pufferpanel user add --admin

Follow the prompts to set username and password.

Access PufferPanel

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

Managing Game Servers

Creating a Server

Log in to PufferPanel
Click “Create Server”
Select a template (Minecraft, Source, etc.)
Configure server settings:
- Server name
- IP binding
- Port allocation
- Resource limits
Click “Create”

Available Templates

PufferPanel includes templates for many games:

Game	Description
Minecraft Java	Vanilla, Paper, Spigot, Forge
Minecraft Bedrock	Bedrock Dedicated Server
Source Games	CS:GO, TF2, Garry’s Mod
Rust	Rust Dedicated Server
Terraria	TShock and Vanilla
Factorio	Headless Server

Server Console

Access real-time console:

Select a server
Click “Console” tab
View output and enter commands
Use auto-complete for common commands

File Management

Manage server files:

Go to server’s “Files” tab
Browse, upload, download files
Edit configuration files in-browser
Create and extract archives

User Management

Creating Users

Go to Admin > Users
Click “Create User”
Set username, email, password
Assign global permissions

User Permissions

Permission	Description
Admin	Full panel access
Server Create	Can create new servers
Server Admin	Full access to assigned servers
Server User	Limited access to assigned servers

Server Access

Grant users access to specific servers:

Go to server settings
Click “Users” tab
Add user by email
Set permission level

Templates

Understanding Templates

Templates define how games are installed and run:

Installation scripts
Startup commands
Required files
Configuration variables

Creating Custom Templates

Go to Admin > Templates
Click “Create Template”
Define template properties:
- Name and display name
- Installation commands
- Run command
- Environment variables
Save template

Template Variables

Use variables for flexible configuration:

{
  "type": "minecraft-java",
  "display": "Minecraft Java",
  "install": [
    {
      "type": "download",
      "url": "${jarUrl}"
    }
  ],
  "run": {
    "command": "java -Xmx${memory}M -jar server.jar nogui"
  }
}

Node Management

Single Node Setup

For running servers on the same machine as the panel, the local node is automatically configured.

Adding Remote Nodes

To manage servers on other machines:

Install PufferPanel on the remote server
Go to Admin > Nodes
Click “Create Node”
Enter node details
Copy the configuration to the remote node

SFTP Access

Enabling SFTP

SFTP runs on port 5657 by default:

Ensure port 5657 is accessible
Use server credentials for SFTP login
Connect with any SFTP client

SFTP Clients

Recommended SFTP clients:

FileZilla
WinSCP
Cyberduck

Troubleshooting Common Issues

Server Won’t Start

Solutions:

Check server logs for errors
Verify port availability
Ensure adequate resources
Check file permissions

Cannot Connect to Server

Solutions:

Verify server is running
Check firewall rules
Confirm correct port
Review network settings

Template Installation Fails

Solutions:

Check template configuration
Verify download URLs
Review installation logs
Check disk space

Additional Resources

Conclusion

Deploying PufferPanel on Klutch.sh gives you a powerful yet easy-to-use game server management panel. With support for multiple games, intuitive interface, and flexible template system, PufferPanel makes running game servers accessible to everyone.

Whether you’re hosting a private Minecraft server for friends or managing multiple game servers for a community, PufferPanel on Klutch.sh provides the tools you need without the complexity.