Pelican Panel Setup on a VPS | Game Server Hosting Series Part 1

Most game server hosting panels charge $5-15/month per server slot. Pelican Panel is free and open-source, and with a RamNode VPS starting at $20/month, you own the entire stack. This guide walks you through every step from a fresh Ubuntu 22.04 VPS to a fully working Pelican Panel with SSL.

What is Pelican Panel?

Pelican Panel is the community-driven successor to Pterodactyl Panel. It provides a web-based interface for managing game servers with full Docker isolation, meaning each game server runs in its own container with dedicated resources.

Pelican vs. alternatives:

Feature	Pelican	Pterodactyl	AMP	GameAP
License	MIT (free)	MIT (free)	Paid	Free
Docker isolation	Yes	Yes	No	No
Active development	Yes	Archived	Yes	Slow
Resource overhead	Low	Low	Medium	Low
Egg ecosystem	Large	Large	Built-in	Limited

The Wings daemon runs on each node and manages Docker containers. The Panel (web UI) communicates with Wings over an authenticated API.

VPS Requirements

Pelican Panel runs alongside your game servers, so plan your resources accordingly:

Use Case	Recommended Plan	RAM	vCPU
Panel + 1 game server	SSD 4G	4 GB	2
Panel + 2-3 servers	SSD 6G	6 GB	4
Panel + 4+ servers	SSD 8G+	8+ GB	4+

Important: Docker requires a KVM-based VPS. Container-based VPS (OpenVZ) cannot run Docker. All RamNode Cloud VPS plans are KVM.

View Cloud VPS Plans

Pre-flight Checklist

Before starting, make sure you have:

A fresh Ubuntu 22.04 VPS with root SSH access
A domain or subdomain pointed at your VPS IP (e.g., panel.yourdomain.com)
Ports 80, 443, and 2022 accessible

Update system and install prerequisites

apt update && apt upgrade -y
apt install -y curl git wget ufw

Configure UFW firewall

ufw allow 22
ufw allow 80
ufw allow 443
ufw allow 2022
ufw enable

Port 2022 is used by Wings for daemon-to-panel communication. You will also need to open game-specific ports later (e.g., 25565 for Minecraft).

Install Docker + Compose

Install Docker from the official repository - not the Snap or distro packages, which are often outdated.

Install Docker via official script

curl -fsSL https://get.docker.com | sh
systemctl enable --now docker

Verify installation

docker run hello-world

Docker Compose v2 is included with the official Docker installation. Verify with docker compose version.

Database Setup (MariaDB)

Pelican Panel stores server configurations, user accounts, and allocation data in MariaDB.

Install MariaDB

apt install -y mariadb-server

Create database and user

mysql -u root -p

CREATE DATABASE pelican;
CREATE USER 'pelican'@'127.0.0.1' IDENTIFIED BY 'STRONG_PASSWORD';
GRANT ALL PRIVILEGES ON pelican.* TO 'pelican'@'127.0.0.1' WITH GRANT OPTION;
FLUSH PRIVILEGES;
exit;

Replace STRONG_PASSWORD with a secure password. The authentication plugin must be mysql_native_password - if you encounter auth errors later, run: ALTER USER 'pelican'@'127.0.0.1' IDENTIFIED WITH mysql_native_password BY 'YOUR_PASSWORD';

Install Pelican Panel

Download and configure the Pelican Panel application.

Install PHP and dependencies

apt install -y php8.3 php8.3-cli php8.3-gd php8.3-mysql php8.3-mbstring \
  php8.3-bcmath php8.3-xml php8.3-curl php8.3-zip php8.3-intl php8.3-fpm

curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

Download and set up Pelican Panel

mkdir -p /var/www/pelican
cd /var/www/pelican
curl -Lo panel.tar.gz https://github.com/pelican-dev/panel/releases/latest/download/panel.tar.gz
tar -xzvf panel.tar.gz
chmod -R 755 storage/* bootstrap/cache/

Configure environment and database

cp .env.example .env
composer install --no-dev --optimize-autoloader

php artisan key:generate --force
php artisan p:environment:setup
php artisan p:environment:database
php artisan migrate --seed --force

Create admin user

php artisan p:user:make

Set file permissions

chown -R www-data:www-data /var/www/pelican/*

The p:environment:setup command will ask for your app URL, timezone, and other settings interactively.

Nginx + SSL (Certbot)

Set up Nginx as a reverse proxy with automatic SSL via Let's Encrypt.

Install Nginx and Certbot

apt install -y nginx certbot python3-certbot-nginx

Create Nginx vhost - /etc/nginx/sites-available/pelican.conf

server {
    listen 80;
    server_name panel.yourdomain.com;
    root /var/www/pelican/public;

    index index.php;

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ \.php$ {
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass unix:/run/php/php8.3-fpm.sock;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param PHP_VALUE "upload_max_filesize = 100M \n post_max_size = 100M";
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param HTTP_PROXY "";
        fastcgi_buffers 8 16k;
        fastcgi_buffer_size 32k;
    }

    location ~ /\.ht {
        deny all;
    }
}

Enable site and get SSL certificate

ln -s /etc/nginx/sites-available/pelican.conf /etc/nginx/sites-enabled/
rm /etc/nginx/sites-enabled/default
nginx -t && systemctl reload nginx

certbot --nginx -d panel.yourdomain.com

Certbot automatically configures SSL and sets up auto-renewal via a systemd timer.

Install Wings Daemon

Wings is the daemon that manages Docker containers on each game server node.

Download and install Wings

mkdir -p /etc/pelican
curl -Lo /usr/local/bin/wings \
  https://github.com/pelican-dev/wings/releases/latest/download/wings_linux_amd64
chmod u+x /usr/local/bin/wings

Create systemd service - /etc/systemd/system/wings.service

[Unit]
Description=Pelican Wings Daemon
After=docker.service

[Service]
User=root
WorkingDirectory=/etc/pelican
ExecStart=/usr/local/bin/wings
Restart=on-failure

[Install]
WantedBy=multi-user.target

Configure and start Wings

# Generate the config token in the Pelican Panel UI:
# Admin -> Nodes -> Create Node -> copy the config command

systemctl enable --now wings

After creating a Node in the Panel web UI, you will receive a configuration token. Run the generated command to create /etc/pelican/config.yml, then start Wings.

First Login + Node Configuration

Log into your Pelican Panel at https://panel.yourdomain.com with the admin user you created earlier.

Initial setup steps:

Create a Location - Go to Admin > Locations > Create New. Name it after your datacenter (e.g., "US-East").
Create a Node - Go to Admin > Nodes > Create New. Set the FQDN to your server IP or domain, memory and disk limits.
Add Allocations - Under the Node, add IP:port pairs. Each game server needs a unique port allocation (e.g., 25565, 25566, 25567).
Import Eggs - Go to Admin > Nests and import eggs from the Pelican Eggs GitHub repository for your target games.

With the Node connected and allocations configured, you are ready to create game servers. Part 2 covers Minecraft deployment in detail.

Troubleshooting

Wings connection refused

Check that port 2022 is open in UFW: ufw status | grep 2022. Verify Wings is running: systemctl status wings.

SSL certificate fails

Ensure your DNS A record points to the VPS IP and has propagated. Check with dig panel.yourdomain.com.

MariaDB authentication errors

The authentication plugin must be mysql_native_password. Fix with: ALTER USER 'pelican'@'127.0.0.1' IDENTIFIED WITH mysql_native_password BY 'YOUR_PASSWORD';

Panel shows 500 error

Check storage permissions: chown -R www-data:www-data /var/www/pelican/storage. Check logs: tail -f /var/www/pelican/storage/logs/laravel-*.log

What's Next

Your Pelican Panel is installed and ready for game servers. In Part 2, we will deploy a Minecraft server - both Java and Bedrock editions - with performance-tuned JVM flags and Geyser crossplay support.

Need more RAM for your game servers? The SSD 6G plan gives you headroom for 3-4 concurrent servers.

Part 2: Minecraft Java + Bedrock

This guide is part of the Game Server Hosting series:

Part 1: Pelican Panel Setup (you are here)Part 2: Minecraft Java + Bedrock Part 3: Valheim & Palworld Part 4: Multi-Game Management Part 5: DDoS Protection & Tuning