Routed IPv4 addresses from €0.70/IP per month, no minimum, no contract. See pricing

Install Wings and Add a Node

In the previous section, you logged into a working panel, namely a web interface with no server behind it yet. To run a game, you'll first install Wings on the machine and register it in the panel as a node.

Install Docker

Wings starts every game server as a Docker container, so Docker comes first. Docker publishes a convenience script that installs the current stable release, and the official Pterodactyl documentation uses it:

curl -sSL https://get.docker.com/ | CHANNEL=stable bash
systemctl enable --now docker

The second line starts Docker now and at every boot. A fresh Ubuntu 24.04 installed Docker 29.9.0 this way, which docker --version confirms.

Does Docker need extra settings to limit a server's swap?

On a recent kernel it does not. Swap accounting is enabled by default from Linux kernel 6.1 onward, and uname -r shows the version, which was 6.8 on Ubuntu 24.04. On an older kernel, docker info prints WARNING: No swap limit support, and the fix is to add swapaccount=1 to GRUB_CMDLINE_LINUX_DEFAULT in /etc/default/grub, run update-grub, and reboot.

Download Wings

Wings is a single binary, so installing it means placing the file and marking it executable. The commands also create /etc/pterodactyl, the folder where Wings reads its configuration:

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")"
chmod u+x /usr/local/bin/wings

Run wings version to confirm the download. The release at the time of writing was v1.13.3, and the panel from the previous section is 1.15.1. The project's update page lists which Wings releases match which panel releases, and the rule of thumb is to keep both on the latest version.

Create a Location and a Node

The panel organizes machines into locations and nodes. A location is a label for a place, such as a datacenter or a city, and a node is one machine running Wings inside it. In the admin area, open Locations and choose Create New. The short code identifies the place in lists, and the description is free text.

Create Location dialog in the Pterodactyl admin area with the short code fr-par and a description filled in
A location needs only a short code and a description.

Then open Nodes and choose Create New. The form has two columns: the left one describes the node, and the right one declares how much of the machine the panel may hand out. Each field matters later, so the next list explains the ones that need a decision:

  • FQDN: the domain name the panel and the browsers of panel users use to reach Wings, such as node.example.com. It must resolve to this machine, and it needs its own HTTPS certificate when the panel uses HTTPS.
  • Communicate Over SSL: leave it on HTTPS. The form even prints a warning in red when the panel uses HTTPS and the node does not, because browsers refuse to open the console connection to a plain HTTP node.
  • Total Memory and Total Disk: the amounts the panel may allocate to servers. The test machine has 8 GiB, and the node declares 6144 MiB of memory, which leaves room for the operating system, the panel, and MariaDB. Disk is declared at 30000 MiB of the 40 GB drive.
  • Over-Allocation: 0 percent means the panel refuses to create a server that would push the totals over the limit. A positive percentage allows promising more than exists, which works only when servers rarely use their whole limit.
  • Daemon Port and SFTP Port: 8080 for the API and 2022 for the built-in file transfer service. The SFTP port must differ from the port of the machine's own SSH service.
New Node form in the Pterodactyl admin area with name node-01, FQDN node.example.com, SSL enabled, 6144 MiB of memory, 30000 MiB of disk, daemon port 8080 and SFTP port 2022
The node form with the values used in this guide, ready for Create Node.

Choosing Create Node opens the new node's page, starting on its Allocation tab.

Give Wings a Certificate and a Configuration

Wings serves its own API over HTTPS, so it needs a certificate for the node's FQDN, the same way the panel needed one. Point a DNS record for node.example.com at the machine and run certbot for that name, as in the previous section:

certbot certonly --standalone -d node.example.com

The standalone mode answers the challenge on port 80 by itself, so stop nginx for the few seconds it takes and start it again afterward. The certificate lands in /etc/letsencrypt/live/node.example.com/, the folder Wings is about to be told to read.

Next, open the node in the panel and choose its Configuration tab. The tab shows a block of YAML that holds the node's identity. Copy it into a new file at /etc/pterodactyl/config.yml. A Generate Token button on the same tab prints a ready-made command that writes the file for you, and on the panel machine itself php artisan p:node:configuration 1 prints the same YAML for node number 1. The file looks like this, with your own values in place of the placeholders:

debug: false
uuid: 60b50825-9bd3-49de-bc36-7ce522db7046
token_id: <generated by the panel>
token: <generated by the panel>
api:
  host: 0.0.0.0
  port: 8080
  ssl:
    enabled: true
    cert: /etc/letsencrypt/live/node.example.com/fullchain.pem
    key: /etc/letsencrypt/live/node.example.com/privkey.pem
  upload_limit: 100
system:
  data: /var/lib/pterodactyl/volumes
  sftp:
    bind_port: 2022
allowed_mounts: []
remote: 'https://panel.example.com'

Notice the remote line at the bottom: it is the panel's own address, which Wings calls to confirm requests and to report events. The token and token_id lines are the node's password, so treat the file like a credential and never paste it into a chat or a ticket.

Start Wings as a Service

Run Wings once in the foreground first. It prints errors straight to the terminal, which is the fastest way to catch a typo in the configuration:

wings --debug

Once it runs without errors, stop it with Ctrl+C and create the service file /etc/systemd/system/wings.service:

[Unit]
Description=Pterodactyl Wings Daemon
After=docker.service
Requires=docker.service
PartOf=docker.service

[Service]
User=root
WorkingDirectory=/etc/pterodactyl
LimitNOFILE=4096
PIDFile=/var/run/wings/daemon.pid
ExecStart=/usr/local/bin/wings
Restart=on-failure
StartLimitInterval=180
StartLimitBurst=30
RestartSec=5s

[Install]
WantedBy=multi-user.target

Then reload systemd and start the service:

systemctl daemon-reload
systemctl enable --now wings
journalctl -u wings -n 20

On the first start Wings creates a system user for the game files, a Docker network named pterodactyl_nw, and the folders under /var/lib/pterodactyl. The last log lines mention an SFTP server listening on port 2022, which is the sign that the daemon is ready. Back in the panel, the node's About tab now shows the daemon version and the system information of the machine, and the node list shows a green heart in the first column.

The About tab of node-01 showing daemon version v1.13.3, Linux amd64 kernel 6.8.0-142-generic, 6 CPU threads, and zero of 30,000 MiB disk and 6,144 MiB memory allocated
The About tab proves the panel can reach Wings: it lists the daemon version and the machine's kernel.
Pterodactyl node list with node-01 in location fr-par showing 6144 MiB memory, 30000 MiB disk, zero servers, a green heartbeat icon and a lock icon for SSL
The green heart in the node list means the panel reached Wings, and the lock means it did so over HTTPS.

If an installation later fails with Resolving timed out in its log, the containers cannot use the DNS servers Wings gave them. Open /etc/pterodactyl/config.yml, change the addresses under docker.network.dns to your own resolver, stop Wings, remove the pterodactyl_nw network with docker network rm pterodactyl_nw, and start Wings again so it recreates the network with the new setting.

Create the Allocations

An allocation is an IP address and a port that the panel can assign to one server. Every server needs at least one, and the panel only offers addresses that you listed here. Find the machine's own address with this command:

hostname -I | awk '{print $1}'

Open the node's Allocation tab and fill in the form on the right. The IP Address field takes that address, and the Ports field takes single ports or ranges separated by commas or spaces. Never use 127.0.0.1 here, because a container published on the loopback address cannot be reached from outside the machine.

This guide uses 25565 to 25575 for Minecraft servers and 3000 to 3005 for bots, and a later section adds 7777 for Terraria. Wider ranges cost nothing, because an allocation does nothing until a server uses it.

Assign New Allocations form with IP address 10.0.2.15 and ports 25565-25575 and 3000-3005 entered as tags
The allocation form accepts several ranges at once.

After submitting, the Existing Allocations table lists each IP and port pair, one row per port, with an empty Assigned To column.

Existing Allocations table on node-01 listing the ports 3000 to 3005 and 25565 to 25575 on 10.0.2.15, with a green banner confirming the allocations were added
Every row is one IP and port pair that a future server can claim.

The IP Alias field next to the address is optional. It sets a default alias for those allocations, which becomes useful once you give each server a domain name.

In summary

  • Wings needs Docker, a downloaded binary, and a config.yml that the node's Configuration tab generates.
  • The node's FQDN needs its own HTTPS certificate whenever the panel uses HTTPS.
  • A green heart in the node list and a daemon version in the About tab prove that the panel and Wings can talk.
  • An allocation is an IP and port pair, and the panel only assigns pairs that you created in advance.

In the next section, you'll create a Minecraft server on this node and watch it start from the panel's console.