Pterodactyl server hosting: Panel and Wings on one dedicated machine

Two components, one host

The Panel is the control plane: users, nodes, eggs, schedules and the admin view. Wings is the data plane: it pulls Docker images, starts containers, streams consoles to the browser and serves files over SFTP. The Panel never talks to a game server; players connect to the containers directly on the ports you assign. A machine that runs Wings is a node, and the Panel can sit on the same node.

8080 and 2022 are configurable per node. Because Wings owns the containers, game servers keep running while the Panel is down for maintenance.

Software requirements

Unless you are testing, install 1.x: 2.0 ships as a beta. PostgreSQL and SQLite are not supported by either line. The documentation publishes no CPU or memory figure for the Panel itself; it is a PHP application with a queue worker, and the games are what consume the machine.

Why Wings wants real hardware

Wings starts game servers as Docker containers, and Docker needs kernel features that container-based virtualisation usually hides. The Wings documentation says that on Virtuozzo, OpenVZ or LXC it will most likely not run unless the provider has adapted the platform for Docker, and that KVM always works. Check before you install:

• systemd-detect-virt printing openvz or lxc is the warning sign.
• kvm is fine; a KVM guest runs Docker normally.
• none means no hypervisor at all: a physical machine, which is what a dedicated server reports.
• The docs also flag modified kernels: if uname -r ends in -grs-ipv6-64 or -mod-std-ipv6-64, switch to the distribution's stock kernel.

On a whole machine, every container limit you set in the Panel is carved from cores and memory nobody else touches. There is no neighbour on the hypervisor, and Docker sees the real kernel. If you split the box with Proxmox, put Wings in a KVM virtual machine rather than an LXC container.

Sizing the node

Size from the games, not from Pterodactyl. Each server gets a memory, CPU and disk limit in the Panel, and Docker enforces it, so the node needs at least the sum of the limits you plan to sell or hand out, plus headroom for MariaDB, Redis, PHP-FPM and the Docker image cache. Write down each game's own requirement from its developer before you pick a machine.

• Cores: many game loops are single-threaded, so per-core speed decides tick rate, and core count decides how many servers fit.
• Memory: Java and Unity servers hold their worlds in RAM; this is usually the limit you hit first.
• Disk: worlds, mods and local backups grow; SSD or NVMe keeps saves and chunk loading quick.
• Network: each player stream is small, but dozens of servers on one port add up; an unmetered port removes the transfer bill from the plan.

Machines that fit

Our game server machines are HPE enterprise servers in New York, Miami, San Francisco, Amsterdam and Bucharest, on our own network, AS19624. Each comes with root, an unmetered port (1 Gbps on most lines, 500 Mbps on the rest) and one IPv4, which is enough for many game servers on different ports. IPv6 is added at checkout at no charge. Rack servers and blades include an out-of-band management controller (browser console, virtual media, power control), which is how you recover a node whose firewall rule locked you out.

Ubuntu releases up to 26.04 install in one click. A racked machine is live about 30 minutes after the order is approved; a build to your specification takes 4 to 24 hours. Compare lines and cities on the dedicated server range, and test latency from your players' networks with the looking glass first.

Install sequence on Ubuntu 24.04

1. Install the Panel dependencies, Composer and the release archive. On 24.04 PHP 8.3, MariaDB and Redis come from the Ubuntu archive.
2. In MariaDB, create a pterodactyl user at 127.0.0.1 with a strong password, a panel database, and grant the user all privileges on it.
3. Configure the environment and seed the database. Copy APP_KEY from .env off the server: lose it and encrypted data is gone, even with a database backup.
4. Add the cron entry * * * * * php /var/www/pterodactyl/artisan schedule:run >> /dev/null 2>&1 and create pteroq.service for the queue worker, then point NGINX at /var/www/pterodactyl/public with a TLS certificate.
5. Install Docker and Wings, create a node in the Panel, copy its configuration into /etc/pterodactyl/config.yml, run Wings in debug mode once, then install wings.service and systemctl enable --now wings.

apt update
apt -y install php8.3 php8.3-{common,cli,gd,mysql,mbstring,bcmath,xml,fpm,curl,zip} mariadb-server nginx tar unzip git redis-server
curl -sS https://getcomposer.org/installer | sudo php -- --install-dir=/usr/local/bin --filename=composer
mkdir -p /var/www/pterodactyl && cd /var/www/pterodactyl
curl -Lo panel.tar.gz https://github.com/pterodactyl/panel/releases/latest/download/panel.tar.gz
tar -xzvf panel.tar.gz
chmod -R 755 storage/* bootstrap/cache/

cp .env.example .env
COMPOSER_ALLOW_SUPERUSER=1 composer install --no-dev --optimize-autoloader
php artisan key:generate --force   # new installs only
php artisan p:environment:setup
php artisan p:environment:database
php artisan p:environment:mail
php artisan migrate --seed --force
php artisan p:user:make
chown -R www-data:www-data /var/www/pterodactyl/*

curl -sSL https://get.docker.com/ | CHANNEL=stable bash
sudo systemctl enable --now docker
sudo mkdir -p /etc/pterodactyl
curl -L -o /usr/local/bin/wings "https://github.com/pterodactyl/wings/releases/latest/download/wings_linux_$([[ "$(uname -m)" == "x86_64" ]] && echo "amd64" || echo "arm64")"
sudo chmod u+x /usr/local/bin/wings
# paste the node's Configuration tab into /etc/pterodactyl/config.yml
sudo wings --debug

get.docker.com runs Docker's install script as root. Read it first, or follow Docker's manual package instructions instead. Never run key:generate on an existing Panel: it makes stored secrets unreadable.

Allocations and the firewall

An allocation is an IP and port pair; every server needs at least one. Add them under the node's Allocation tab using the public address of the node's interface, the first address hostname -I prints. Do not hand players 127.0.0.1: it only suits back-end servers that other containers on the same node reach, such as servers behind a Minecraft proxy.

Open 443 for the Panel, 8080 and 2022 for Wings, and the allocation ranges for the games, with the protocol each game uses. Because browsers connect to Wings directly, the node needs a DNS name, and when the Panel runs on HTTPS, Wings needs its own certificate for that name.

Running it

• Swap accounting: kernels 6.1 and later have it on. On older kernels add swapaccount=1 to the GRUB command line if docker info warns about swap limits, which matters when you host for other people.
• Backups: Wings backs up server files from the Panel; also dump the panel database and keep APP_KEY off the machine.
• Updates: follow the upgrade guides for Panel and Wings separately; Wings 1.13.x serves both Panel lines.
• Eggs: migrate --seed installs the default eggs; more game types are on the official eggs site. Each egg pins a Docker image and a startup command, so review third-party eggs before importing them.

Where it is the wrong tool

For one private server for friends, Pterodactyl adds a web stack, a database and Docker you then have to maintain; running the game's own server directly, as in our Minecraft dedicated server guide, is simpler. Wings has no Windows build, so a game whose server runs only on Windows does not fit a standard node. A Cloud VPS, a KVM guest with unpinned vCPUs, can run Wings for a test node; a tick-sensitive game wants whole cores.