Deploying Pelican Panel

Introduction

Pelican Panel is a modern, self-hosted open-source game server management panel built as a continuation and reimagining of Pterodactyl Panel. It provides a beautiful, intuitive web interface for deploying, managing, and monitoring game servers across multiple nodes.

Built with Laravel and React, Pelican Panel offers a polished user experience for both administrators managing infrastructure and end-users controlling their game servers. It supports a wide variety of games including Minecraft, Rust, ARK, Valheim, and many more through its egg system.

Key highlights of Pelican Panel:

Multi-Game Support: Manage servers for Minecraft, Rust, ARK, CS:GO, Valheim, and 100+ other games
Beautiful Interface: Modern React-based UI with dark mode support
Multi-Node Architecture: Distribute game servers across multiple physical nodes
Resource Management: Set CPU, memory, disk, and network limits per server
Docker Isolation: Each game server runs in isolated Docker containers
User Management: Role-based access control with subuser permissions
File Manager: Web-based file manager with editor
Console Access: Real-time console with command execution
Backups: Automated backup system with multiple storage drivers
API Access: Full REST API for automation and integrations
Two-Factor Auth: Enhanced security with 2FA support
Open Source: MIT licensed, community-driven development

This guide walks through deploying Pelican Panel on Klutch.sh using Docker, setting up the panel and nodes, and configuring game servers.

Why Deploy Pelican Panel on Klutch.sh

Deploying Pelican Panel on Klutch.sh provides several advantages:

Simplified Deployment: Klutch.sh automatically detects your Dockerfile and builds Pelican Panel without complex orchestration. Push to GitHub, and your game server panel deploys automatically.

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

Persistent Storage: Attach persistent volumes for your database and application data. Your configuration survives container restarts and redeployments.

Environment Variable Management: Securely store database credentials, API keys, and secrets through Klutch.sh’s environment variable system.

Custom Domains: Use a professional domain for your game server management platform.

Always Available: Your panel remains accessible 24/7 for managing game servers.

Prerequisites

Before deploying Pelican Panel on Klutch.sh, ensure you have:

A Klutch.sh account
A GitHub account with a repository for your Pelican configuration
Basic familiarity with Docker and containerization concepts
A MySQL or MariaDB database
Redis for caching and queues
SMTP server for email notifications
Separate server(s) with Docker for running Wings (the game server daemon)

Understanding Pelican Architecture

Pelican consists of two main components:

Panel: The web application providing the management interface, API, and administration. This is what users interact with.

Wings: The server-side daemon that runs on each node hosting game servers. It manages Docker containers, handles console I/O, and executes server operations.

Important: The Panel (this guide) manages the infrastructure but does not run game servers directly. You need separate servers running Wings to host the actual game servers.

Preparing Your Repository

Create a GitHub repository containing your Dockerfile for Pelican Panel deployment.

Repository Structure

pelican-panel-deploy/
├── Dockerfile
└── .dockerignore

Creating the Dockerfile

Create a Dockerfile in the root of your repository:

FROM ghcr.io/pelican-dev/panel:latest

# Set environment variables
ENV APP_ENV=production
ENV APP_DEBUG=false
ENV APP_KEY=${APP_KEY}
ENV APP_URL=${APP_URL}

# Database configuration
ENV DB_CONNECTION=mysql
ENV DB_HOST=${DB_HOST}
ENV DB_PORT=${DB_PORT:-3306}
ENV DB_DATABASE=${DB_DATABASE}
ENV DB_USERNAME=${DB_USERNAME}
ENV DB_PASSWORD=${DB_PASSWORD}

# Redis configuration
ENV REDIS_HOST=${REDIS_HOST}
ENV REDIS_PASSWORD=${REDIS_PASSWORD}
ENV REDIS_PORT=${REDIS_PORT:-6379}

# Cache and session
ENV CACHE_DRIVER=redis
ENV SESSION_DRIVER=redis
ENV QUEUE_CONNECTION=redis

# Mail configuration
ENV MAIL_MAILER=${MAIL_MAILER:-smtp}
ENV MAIL_HOST=${MAIL_HOST}
ENV MAIL_PORT=${MAIL_PORT:-587}
ENV MAIL_USERNAME=${MAIL_USERNAME}
ENV MAIL_PASSWORD=${MAIL_PASSWORD}
ENV MAIL_FROM_ADDRESS=${MAIL_FROM_ADDRESS}
ENV MAIL_FROM_NAME=${MAIL_FROM_NAME:-"Pelican Panel"}

# Create storage directories
RUN mkdir -p /app/storage/logs /app/storage/framework/{cache,sessions,views}

# Expose the web interface port
EXPOSE 80 443

# Use the default entrypoint

Creating the .dockerignore File

Create a .dockerignore file:

.git
.github
*.md
LICENSE
.gitignore
*.log
.DS_Store
.env
.env.local
node_modules/
vendor/

Environment Variables Reference

Variable	Required	Description
`APP_KEY`	Yes	Encryption key (base64:…)
`APP_URL`	Yes	Full URL of your panel
`DB_HOST`	Yes	MySQL host
`DB_DATABASE`	Yes	Database name
`DB_USERNAME`	Yes	Database username
`DB_PASSWORD`	Yes	Database password
`REDIS_HOST`	Yes	Redis host
`REDIS_PASSWORD`	No	Redis password
`MAIL_HOST`	Yes	SMTP server
`MAIL_USERNAME`	No	SMTP username
`MAIL_PASSWORD`	No	SMTP password
`MAIL_FROM_ADDRESS`	Yes	Sender email address

Deploying Pelican Panel on Klutch.sh

Generate an Application Key

Generate a secure application key:

echo "base64:$(openssl rand -base64 32)"

Save this key securely - it’s used to encrypt sensitive data.

Set Up MySQL Database

Deploy a MySQL or MariaDB database on Klutch.sh or use an external service. Create a database for Pelican.

Set Up Redis

Deploy a Redis instance for caching and queue management.

Configure SMTP

Set up email for account creation and notifications. You can use services like:

Mailgun
SendGrid
Amazon SES
Your organization’s mail server

Push Your Repository to GitHub

Initialize your repository and push to GitHub with your Dockerfile.

Create a New Project on Klutch.sh

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

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 Pelican Dockerfile.

Configure HTTP Traffic

In the deployment settings:

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

Set Environment Variables

Add the following environment variables:

Variable	Value
`APP_KEY`	Your generated key (base64:…)
`APP_URL`	`https://your-app-name.klutch.sh`
`DB_HOST`	Your database host
`DB_DATABASE`	`pelican`
`DB_USERNAME`	Database username
`DB_PASSWORD`	Database password
`REDIS_HOST`	Your Redis host
`MAIL_HOST`	SMTP hostname
`MAIL_USERNAME`	SMTP username
`MAIL_PASSWORD`	SMTP password
`MAIL_FROM_ADDRESS`	`panel@yourdomain.com`

Attach Persistent Volumes

Add the following volumes:

Mount Path	Recommended Size	Purpose
`/app/storage`	10 GB	Logs, cache, and session data

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 Pelican container
Provision an HTTPS certificate

Create Admin User

After deployment, create your first admin user through the panel’s setup process or by accessing the container console.

Access Pelican Panel

Once deployment completes, access your Pelican Panel at https://your-app-name.klutch.sh.

Initial Setup

Creating the First Admin

Navigate to your Pelican Panel URL
Complete the initial setup wizard
Create your administrator account
Configure basic settings

Setting Up Locations

Locations group nodes geographically:

Go to Admin > Locations
Create locations (e.g., “US East”, “EU West”)
Locations help users choose optimal server locations

Adding Nodes

Nodes are servers running Wings:

Go to Admin > Nodes
Click Create Node
Fill in node details (name, location, FQDN)
Configure resource allocations
Copy the configuration for Wings setup

Installing Wings

On each game server node (separate from the Panel):

Install Docker on the node
Download and install Wings
Configure Wings with the token from the Panel
Start the Wings service

Creating Allocations

Allocations are IP:port combinations for game servers:

Select a node
Go to the Allocation tab
Add ports for game servers
Ports become available for server creation

Managing Game Servers

Creating a Server

Go to Admin > Servers
Click Create Server
Select the owner (user)
Choose a nest and egg (game type)
Configure resources (CPU, RAM, disk)
Select node and allocation
Configure startup variables
Create the server

Eggs and Nests

Nests: Categories of games (e.g., Minecraft, Source Games) Eggs: Specific game configurations within nests

Pelican comes with pre-configured eggs for popular games. You can also create custom eggs.

User Access

Grant users access to servers:

Create user accounts
Assign servers to users
Users can start/stop/manage their servers
Configure subuser permissions for team access

Additional Resources

Conclusion

Deploying Pelican Panel on Klutch.sh gives you a modern, powerful game server management platform. The combination of Pelican’s intuitive interface and Klutch.sh’s deployment simplicity means you can focus on running game servers rather than managing infrastructure.

With support for hundreds of games, multi-node architecture, and comprehensive management features, Pelican Panel provides everything you need for personal gaming servers or commercial hosting operations.

Remember that Pelican Panel is the management interface - you’ll need separate servers running Wings to host the actual game servers. This separation allows you to scale your game hosting infrastructure while maintaining a centralized management platform.