Welche Ports muss ich für Pterodactyl freigeben?

Für das Panel die Ports 80 und 443, für Wings Port 8080 (API) und Port 2022 (SFTP). Dazu kommen die Spielports deiner Allocations, zum Beispiel 25565 für Minecraft.

Pterodactyl auf einem Linux Server einrichten – Hoste dein eigenes Gameserver-Panel

Entdecke, wie du Pterodactyl Panel und Wings auf deinem Linux Server installierst und deine eigenen Gameserver bequem über ein Webinterface verwaltest → Jetzt mehr erfahren

30. Oktober 202612 Min. Lesezeit0 Aufrufe0 hilfreich

Einführung

Pterodactyl ist ein kostenloses Open-Source-Panel, mit dem du Gameserver wie Minecraft, Rust, ARK oder CS2 über ein Webinterface verwaltest. Jeder Gameserver läuft dabei in einem eigenen Docker-Container, sauber getrennt von den anderen.

Pterodactyl besteht aus zwei Teilen:

Panel – die Weboberfläche, in der du Server, Benutzer und Ressourcen verwaltest (PHP-Anwendung mit Datenbank und Webserver)
Wings – der Dienst auf dem Server, der die Gameserver-Container startet, stoppt und überwacht

In dieser Anleitung zeigen wir dir Schritt für Schritt, wie du Panel und Wings auf deinem ZapX vServer oder Dedicated Server installierst, eine Domain mit SSL einrichtest und deinen ersten Gameserver anlegst.

Vorbereitung

Für Pterodactyl brauchst du einen vServer oder Dedicated Server mit Linux und Root-Zugriff per SSH. Wie du dich mit deinem Server verbindest, erfährst du in unserer Anleitung zum SSH-Erstzugang. Neu bei ZapX? Dann schau dir zuerst die Einführung für vServer bzw. Dedicated Server an.

Tipp

SSH-Key-Authentifizierung

Wir empfehlen dir, statt eines Passworts einen SSH-Key zu nutzen. Wie das geht, erfährst du in unserer Anleitung SSH-Keys erstellen und nutzen.

Hardware-Anforderungen

Das Panel selbst ist schlank. Wie viele Ressourcen du brauchst, hängt vor allem davon ab, wie viele Gameserver du über Wings betreiben willst. Für Panel und Wings auf demselben Server empfehlen wir:

Hardware	Minimum	Empfohlen
CPU	2 vCPU Kerne	4 vCPU Kerne oder mehr
RAM	4 GB	8 GB oder mehr
Festplattenspeicher	30 GB	100 GB oder mehr

Unterstützte Betriebssysteme

Laut der offiziellen Pterodactyl-Dokumentation werden aktuell diese Systeme unterstützt:

Betriebssystem	Versionen	Hinweis
Ubuntu	22.04, 24.04	Bei 22.04 brauchst du ein zusätzliches PHP-Repository
Debian	11, 12, 13	PHP 8.3 kommt aus dem Sury-Repository
Rocky Linux / AlmaLinux / RHEL	8, 9	Andere Paketnamen und Pfade, in dieser Anleitung nicht behandelt

In dieser Anleitung findest du die Befehle für Ubuntu und Debian. Ubuntu 20.04 und älter werden vom Panel nicht mehr unterstützt. Wenn du dein System neu aufsetzt, nimm am besten Ubuntu 24.04 oder Debian 12.

Virtualisierung prüfen

Wings braucht Docker. Docker läuft auf KVM-basierten Servern und auf Dedicated Servern ohne Probleme, auf OpenVZ- oder LXC-Containern dagegen meist nicht. Prüfe das mit folgendem Befehl:

bash

systemd-detect-virt

Die Ausgabe kvm oder none (Dedicated Server ohne Virtualisierung) ist in Ordnung. Steht dort openvz oder lxc, kannst du Wings auf diesem Server in der Regel nicht betreiben.

System aktualisieren

Bring dein System vor der Installation auf den neuesten Stand:

bash

apt update && apt upgrade -y

Abhängigkeiten installieren

Das Panel braucht PHP 8.2 oder 8.3 (empfohlen ist 8.3) mit einigen Erweiterungen, eine Datenbank (MariaDB oder MySQL), Redis, einen Webserver (wir nutzen Nginx) sowie curl, tar, unzip, git und Composer. Führe die Befehle für deine Distribution aus.

Ubuntu 24.04

Unter Ubuntu 24.04 sind PHP 8.3, MariaDB und Redis bereits in den Standard-Paketquellen enthalten. Du brauchst also keine zusätzlichen Repositories:

bash

apt -y install software-properties-common curl apt-transport-https ca-certificates gnupg
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

Ubuntu 22.04

Ubuntu 22.04 liefert nur PHP 8.1 mit. Deshalb fügst du zuerst das PHP-Repository von Ondřej Surý und das offizielle Redis-Repository hinzu und installierst danach alle Pakete:

bash

# Werkzeuge für zusätzliche Repositories
apt -y install software-properties-common curl apt-transport-https ca-certificates gnupg

# PHP-Repository (PPA) hinzufügen
LC_ALL=C.UTF-8 add-apt-repository -y ppa:ondrej/php

# Offizielles Redis-Repository hinzufügen
curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list

# Paketlisten neu laden und Abhängigkeiten installieren
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

Debian 11 und 12

Unter Debian 11 und 12 kommen PHP 8.3 aus dem Sury-Repository, Redis aus dem offiziellen Redis-Repository und MariaDB über das Setup-Skript von MariaDB:

bash

# Benötigte Werkzeuge
apt install -y curl ca-certificates gnupg2 sudo lsb-release

# PHP-Repository von Sury hinzufügen
echo "deb https://packages.sury.org/php/ $(lsb_release -sc) main" | sudo tee /etc/apt/sources.list.d/sury-php.list
curl -fsSL https://packages.sury.org/php/apt.gpg | sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/sury-keyring.gpg

# Offizielles Redis-Repository hinzufügen
curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list

# MariaDB-Repository einrichten
curl -LsS https://r.mariadb.com/downloads/mariadb_repo_setup | sudo bash

# Paketlisten neu laden und Abhängigkeiten installieren
apt update
apt install -y php8.3 php8.3-{common,cli,gd,mysql,mbstring,bcmath,xml,fpm,curl,zip} mariadb-server nginx tar unzip git redis-server

Debian 13

Debian 13 bringt standardmäßig PHP 8.4 mit, das Pterodactyl nicht offiziell unterstützt. Du holst dir PHP 8.3 deshalb aus dem Sury-Repository. MariaDB und Redis installierst du direkt aus den Debian-Paketquellen, ohne zusätzliche Repositories:

bash

# Benötigte Werkzeuge
apt install -y curl ca-certificates gnupg2 sudo lsb-release

# PHP-Repository von Sury hinzufügen
echo "deb https://packages.sury.org/php/ $(lsb_release -sc) main" | sudo tee /etc/apt/sources.list.d/sury-php.list
curl -fsSL https://packages.sury.org/php/apt.gpg | sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/sury-keyring.gpg

# Paketlisten neu laden und Abhängigkeiten installieren
apt update
apt install -y php8.3 php8.3-{common,cli,gd,mysql,mbstring,bcmath,xml,fpm,curl,zip} mariadb-server nginx tar unzip git redis-server

Composer installieren

Composer ist der Paketmanager für PHP, über den das Panel seine Bibliotheken bezieht. Installiere ihn mit:

bash

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

Prüfe danach kurz, ob PHP 8.3 aktiv ist:

bash

php -v

Panel herunterladen

Lege den Ordner für das Panel an und wechsle hinein:

bash

mkdir -p /var/www/pterodactyl
cd /var/www/pterodactyl

Lade das aktuelle Release herunter, entpacke es und setze die Rechte für die Ordner storage/ und bootstrap/cache/:

bash

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/

Panel installieren

Datenbank anlegen

Das Panel speichert alle Daten in einer eigenen Datenbank. Melde dich bei MariaDB an:

bash

mariadb -u root -p

Lege einen Benutzer und eine Datenbank für das Panel an. Ersetze DeinSicheresPasswort durch ein eigenes, sicheres Passwort:

sql

CREATE USER 'pterodactyl'@'127.0.0.1' IDENTIFIED BY 'DeinSicheresPasswort';
CREATE DATABASE panel;
GRANT ALL PRIVILEGES ON panel.* TO 'pterodactyl'@'127.0.0.1' WITH GRANT OPTION;
exit

Mehr zu MariaDB und anderen Datenbanken findest du in unserer Anleitung Datenbanken auf einem Linux Server einrichten.

Grundkonfiguration

Kopiere die Beispiel-Konfiguration, installiere die PHP-Abhängigkeiten und erzeuge den Schlüssel der Anwendung:

bash

cp .env.example .env
COMPOSER_ALLOW_SUPERUSER=1 composer install --no-dev --optimize-autoloader

# Nur bei einer Neuinstallation ausführen, nicht bei einem bestehenden Panel
php artisan key:generate --force

Achtung

APP_KEY sichern

Der Wert APP_KEY in der Datei .env verschlüsselt alle sensiblen Daten des Panels, zum Beispiel API-Schlüssel. Geht er verloren, sind diese Daten auch mit einem Datenbank-Backup nicht mehr lesbar. Lass ihn dir mit grep APP_KEY /var/www/pterodactyl/.env anzeigen und speichere ihn an einem sicheren Ort außerhalb des Servers, zum Beispiel in deinem Passwort-Manager.

Umgebung einrichten

Mit den folgenden Befehlen richtest du Sitzungen, Cache, die Datenbankverbindung und den Mailversand ein. Die Befehle fragen dich interaktiv nach den Werten:

bash

php artisan p:environment:setup
php artisan p:environment:database

# Optional: Mailversand einrichten ("smtp" für einen eigenen Mailserver)
php artisan p:environment:mail

Gib bei der Frage nach der Application URL die spätere Adresse deines Panels ein, zum Beispiel https://panel.example.com. Bei der Datenbank nutzt du 127.0.0.1, die Datenbank panel, den Benutzer pterodactyl und das Passwort, das du vorhin gesetzt hast. Für Cache, Sessions und Queue kannst du Redis auswählen.

Datenbank füllen

Jetzt legt das Panel seine Tabellen an und importiert die mitgelieferten Nests und Eggs (die Vorlagen für die einzelnen Spiele):

bash

php artisan migrate --seed --force

Info

Bitte warten

Das kann ein paar Minuten dauern. Brich den Vorgang nicht ab, sonst ist die Datenbank unvollständig.

Ersten Admin anlegen

Lege deinen Admin-Account an. Das Passwort muss mindestens 8 Zeichen lang sein, Groß- und Kleinbuchstaben und mindestens eine Zahl enthalten:

bash

php artisan p:user:make

Beantworte die Frage, ob der Benutzer ein Administrator sein soll, mit yes.

Berechtigungen setzen

Damit Nginx und PHP auf die Dateien zugreifen können, übergibst du sie dem Webserver-Benutzer:

bash

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

Cronjob und Queue-Worker einrichten

Das Panel erledigt viele Aufgaben im Hintergrund, zum Beispiel geplante Aufgaben, E-Mails und Aufräumarbeiten. Dafür brauchst du einen Cronjob und einen Queue-Worker.

Cronjob

Öffne die Crontab mit sudo crontab -e und füge diese Zeile hinzu. Sie startet den Scheduler des Panels jede Minute:

bash

* * * * * php /var/www/pterodactyl/artisan schedule:run >> /dev/null 2>&1

Queue-Worker (pteroq)

Der Queue-Worker läuft als systemd-Dienst dauerhaft im Hintergrund. Erstelle die Datei:

bash

nano /etc/systemd/system/pteroq.service

Füge diesen Inhalt ein:

ini

# Pterodactyl Queue Worker File
# ----------------------------------

[Unit]
Description=Pterodactyl Queue Worker
After=redis-server.service

[Service]
User=www-data
Group=www-data
Restart=always
ExecStart=/usr/bin/php /var/www/pterodactyl/artisan queue:work --queue=high,standard,low --sleep=3 --tries=3
StartLimitInterval=180
StartLimitBurst=30
RestartSec=5s

[Install]
WantedBy=multi-user.target

Speichere mit STRG + X, dann Y und Enter. Aktiviere anschließend Redis und den Queue-Worker, damit beide auch nach einem Neustart automatisch laufen:

bash

sudo systemctl enable --now redis-server
sudo systemctl enable --now pteroq.service

Mit systemctl status pteroq kannst du prüfen, ob der Dienst läuft.

Webserver und SSL einrichten

Damit du das Panel über eine eigene Domain mit HTTPS erreichst, richtest du jetzt DNS, ein SSL-Zertifikat und Nginx ein.

DNS-Eintrag anlegen

Lege bei deinem Domain-Anbieter einen A-Eintrag an, der auf die IP-Adresse deines Servers zeigt, zum Beispiel panel.example.com. Wenn deine Domain bei ZAP-Hosting liegt, hilft dir unsere Anleitung zu den Domain Records. Bis der Eintrag weltweit aktiv ist, kann es eine Weile dauern.

SSL-Zertifikat mit Certbot erstellen

Installiere Certbot mit dem Nginx-Plugin und erstelle das Zertifikat. Ersetze panel.example.com durch deine Domain:

bash

apt install -y certbot python3-certbot-nginx
certbot certonly --nginx -d panel.example.com

Certbot prüft die Domain über Port 80. Der Port muss also aus dem Internet erreichbar sein. Mehr zu Certbot findest du in unserer Anleitung Certbot auf einem Linux Server einrichten.

Das Certbot-Paket erneuert Zertifikate automatisch. Damit Nginx und Wings ein erneuertes Zertifikat auch laden, kannst du in der Crontab (sudo crontab -e) zusätzlich diese Zeile eintragen:

bash

0 23 * * * certbot renew --quiet --deploy-hook "systemctl restart nginx wings"

Nginx mit SSL konfigurieren

Entferne die Standard-Konfiguration von Nginx:

bash

rm /etc/nginx/sites-enabled/default

Erstelle eine neue Konfigurationsdatei für das Panel:

bash

nano /etc/nginx/sites-available/pterodactyl.conf

Füge diese Konfiguration ein und ersetze panel.example.com an allen vier Stellen durch deine Domain:

nginx

server {
    listen 80;
    server_name panel.example.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name panel.example.com;

    root /var/www/pterodactyl/public;
    index index.php;

    access_log /var/log/nginx/pterodactyl.app-access.log;
    error_log  /var/log/nginx/pterodactyl.app-error.log error;

    # Größere Uploads und längere Laufzeiten erlauben
    client_max_body_size 100m;
    client_body_timeout 120s;

    sendfile off;

    # SSL-Konfiguration
    ssl_certificate /etc/letsencrypt/live/panel.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/panel.example.com/privkey.pem;
    ssl_session_cache shared:SSL:10m;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384";
    ssl_prefer_server_ciphers on;

    add_header X-Content-Type-Options nosniff;
    add_header X-XSS-Protection "1; mode=block";
    add_header X-Robots-Tag none;
    add_header Content-Security-Policy "frame-ancestors 'self'";
    add_header X-Frame-Options DENY;
    add_header Referrer-Policy same-origin;

    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_intercept_errors off;
        fastcgi_buffer_size 16k;
        fastcgi_buffers 4 16k;
        fastcgi_connect_timeout 300;
        fastcgi_send_timeout 300;
        fastcgi_read_timeout 300;
        include /etc/nginx/fastcgi_params;
    }

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

Achtung

Zertifikat zuerst

Nginx startet mit dieser Konfiguration nur, wenn das SSL-Zertifikat bereits existiert. Erstelle es also unbedingt vorher mit Certbot.

Nginx ohne SSL konfigurieren

Willst du das Panel nur testen und noch keine Domain mit Zertifikat nutzen, kannst du stattdessen diese einfachere Konfiguration in /etc/nginx/sites-available/pterodactyl.conf verwenden. Ersetze panel.example.com durch deine Domain oder die IP-Adresse deines Servers und lösche auch hier vorher die Datei /etc/nginx/sites-enabled/default:

nginx

server {
    listen 80;
    server_name panel.example.com;

    root /var/www/pterodactyl/public;
    index index.html index.htm index.php;
    charset utf-8;

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

    location = /favicon.ico { access_log off; log_not_found off; }
    location = /robots.txt  { access_log off; log_not_found off; }

    access_log off;
    error_log  /var/log/nginx/pterodactyl.app-error.log error;

    client_max_body_size 100m;
    client_body_timeout 120s;

    sendfile off;

    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_intercept_errors off;
        fastcgi_buffer_size 16k;
        fastcgi_buffers 4 16k;
        fastcgi_connect_timeout 300;
        fastcgi_send_timeout 300;
        fastcgi_read_timeout 300;
    }

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

Ohne SSL laufen Logins und Passwörter unverschlüsselt durchs Netz. Für den dauerhaften Betrieb solltest du deshalb immer die Variante mit SSL nutzen.

Konfiguration aktivieren

Aktiviere die Konfiguration, prüfe sie auf Fehler und starte Nginx neu:

bash

sudo ln -s /etc/nginx/sites-available/pterodactyl.conf /etc/nginx/sites-enabled/pterodactyl.conf
sudo nginx -t
sudo systemctl restart nginx

Öffne jetzt https://panel.example.com im Browser und melde dich mit dem Admin-Account an, den du vorhin angelegt hast. Allgemeine Infos zu Nginx findest du in unserer Anleitung Nginx und Apache auf einem Linux Server einrichten.

Wings installieren

Wings ist der Dienst, der deine Gameserver tatsächlich ausführt. Du kannst Wings auf demselben Server wie das Panel installieren oder auf weiteren Servern, die du dann als zusätzliche Nodes im Panel einbindest.

Docker installieren

Wings startet jeden Gameserver in einem Docker-Container. Installiere Docker CE mit dem offiziellen Installationsskript und aktiviere den Dienst:

bash

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

Mehr zu Docker findest du in unserer Anleitung Docker auf einem Linux Server einrichten.

Wings herunterladen

Lege den Konfigurationsordner an und lade die aktuelle Wings-Version für deine CPU-Architektur herunter:

bash

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

Location und Node im Panel anlegen

Bevor Wings starten kann, legst du im Panel einen Node an, also den Server, auf dem Wings läuft:

Öffne im Panel oben rechts den Admin-Bereich (Zahnrad-Symbol).
Lege unter Locations mit Create New einen Standort an, zum Beispiel mit dem Kürzel de1.
Gehe zu Nodes und klicke auf Create New.
Trage einen Namen ein, wähle die Location und gib als FQDN die Domain des Servers ein. Läuft Wings auf demselben Server wie das Panel, kannst du dieselbe Domain nutzen, zum Beispiel panel.example.com.
Wähle bei Communicate Over SSL die Option Use SSL Connection, wenn dein Panel per HTTPS läuft. Dann braucht auch der Node ein gültiges Zertifikat für seinen FQDN.
Trage bei Total Memory und Total Disk Space ein, wie viel RAM und Speicher Wings an Gameserver vergeben darf. Lass etwas Puffer für das System selbst.
Lass Daemon Port auf 8080 und Daemon SFTP Port auf 2022 stehen und speichere den Node.

Öffne danach den Node und wechsle in den Tab Configuration. Klicke auf Generate Token und führe den angezeigten Befehl auf deinem Server aus. Er schreibt die Datei /etc/pterodactyl/config.yml automatisch. Alternativ kopierst du den Inhalt des Code-Blocks von Hand in diese Datei.

Wings testen

Starte Wings einmal im Debug-Modus, um Fehler direkt zu sehen:

bash

sudo wings --debug

Läuft Wings ohne Fehler und zeigt der Node im Panel unter Nodes ein grünes Herz, beendest du den Testlauf mit STRG + C.

Wings als Dienst einrichten

Damit Wings dauerhaft im Hintergrund läuft, legst du einen systemd-Dienst an:

bash

nano /etc/systemd/system/wings.service

Füge diesen Inhalt ein:

ini

[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

Aktiviere und starte den Dienst:

bash

sudo systemctl enable --now wings

Allocations anlegen

Eine Allocation ist eine Kombination aus IP-Adresse und Port, die du einem Gameserver zuweist. Jeder Server braucht mindestens eine. Die IP-Adresse deines Servers findest du mit:

bash

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

Öffne im Admin-Bereich deinen Node, wechsle in den Tab Allocation und trage unter Assign New Allocations die IP-Adresse und die gewünschten Ports ein, zum Beispiel 25565-25570 für Minecraft. Nutze nie 127.0.0.1 als Allocation.

Firewall und Ports

Nutzt du auf deinem Server eine Firewall, müssen diese Ports offen sein:

Port	Protokoll	Zweck
80 und 443	TCP	Panel (HTTP/HTTPS) und Zertifikatsprüfung durch Certbot
8080	TCP	Wings-API, über die das Panel mit dem Node spricht
2022	TCP	SFTP-Zugriff auf die Dateien der Gameserver
Spielports	TCP/UDP	Die Ports deiner Allocations, zum Beispiel `25565` für Minecraft

Mit UFW gibst du die Ports zum Beispiel so frei. Erlaube SSH unbedingt zuerst, sonst sperrst du dich beim Aktivieren aus:

bash

ufw allow OpenSSH
ufw allow 80,443/tcp
ufw allow 8080/tcp
ufw allow 2022/tcp
ufw allow 25565:25570/tcp
ufw allow 25565:25570/udp
ufw enable

Mehr zum Thema findest du in unserer Anleitung zur Firewall-Verwaltung unter Linux.

Info

Docker und UFW

Docker legt für die Ports der Gameserver-Container eigene Regeln an. Diese Ports sind deshalb oft auch dann erreichbar, wenn du sie in UFW nicht freigegeben hast. Verlass dich bei den Spielports also nicht allein auf UFW.

Ersten Gameserver anlegen

Jetzt ist alles bereit für deinen ersten Gameserver:

Öffne im Admin-Bereich Servers und klicke auf Create New.
Vergib einen Namen und wähle den Besitzer (zum Beispiel deinen Admin-Account).
Wähle den Node und eine freie Allocation.
Lege fest, wie viel CPU, RAM und Speicher der Server bekommt.
Wähle unter Nest und Egg das Spiel, zum Beispiel Minecraft mit Paper.
Klicke auf Create Server.

Wings lädt nun das passende Docker-Image herunter und installiert den Server. Danach findest du ihn in der normalen Ansicht des Panels und kannst ihn dort starten, die Konsole öffnen und Dateien verwalten.

Abschluss und weitere Ressourcen

Glückwunsch! Du hast Pterodactyl Panel und Wings erfolgreich auf deinem Server installiert und kannst jetzt eigene Gameserver über das Webinterface verwalten. Diese Ressourcen helfen dir weiter:

pterodactyl.io – Offizielle Website
Pterodactyl Dokumentation – Installation, Updates und zusätzliche Konfiguration
GitHub – Quellcode und Releases

Hinweis: Seit Version 1.11 sendet Pterodactyl anonyme Nutzungsdaten (Telemetrie). Wie du das abschaltest, steht in der offiziellen Dokumentation unter „Additional Configuration“.

Du hast noch Fragen, die hier nicht beantwortet wurden? Unser Support-Team steht dir täglich zur Seite – melde dich einfach bei uns! 🙂

FAQ

Häufig gestellte Fragen

Pterodactyl ist ein kostenloses Open-Source-Panel zum Verwalten von Gameservern. Es besteht aus dem Panel (Weboberfläche) und Wings (Dienst auf dem Server), der jeden Gameserver in einem eigenen Docker-Container startet.

Laut offizieller Dokumentation Ubuntu 22.04 und 24.04, Debian 11, 12 und 13 sowie Rocky Linux, AlmaLinux und RHEL 8 und 9. Ubuntu 20.04 und älter werden vom Panel nicht mehr unterstützt.

Das Panel braucht PHP 8.2 oder 8.3, empfohlen ist PHP 8.3. Unter Ubuntu 22.04 und Debian kommt PHP 8.3 aus einem zusätzlichen Repository, Ubuntu 24.04 bringt es bereits mit.

Feedback

War dieser Artikel hilfreich?

Deine Rückmeldung hilft uns, Inhalte besser zu priorisieren und zu überarbeiten.

0 von 0 Rückmeldungen fanden diesen Artikel hilfreich.

Persönliche Hilfe

Die Anleitung reicht nicht?

Unser ZAP-Support kennt dein Produkt — beschreib kurz dein Anliegen und wir helfen dir persönlich weiter.

Einführung

Vorbereitung

Hardware-Anforderungen

Unterstützte Betriebssysteme

Virtualisierung prüfen

System aktualisieren

Abhängigkeiten installieren

Ubuntu 24.04

Ubuntu 22.04

Debian 11 und 12

Debian 13

Composer installieren

Panel herunterladen

Panel installieren

Datenbank anlegen

Grundkonfiguration

Umgebung einrichten

Datenbank füllen

Ersten Admin anlegen

Berechtigungen setzen

Cronjob und Queue-Worker einrichten

Cronjob

Queue-Worker (pteroq)

Webserver und SSL einrichten

DNS-Eintrag anlegen

SSL-Zertifikat mit Certbot erstellen

Nginx mit SSL konfigurieren

Nginx ohne SSL konfigurieren

Konfiguration aktivieren

Wings installieren

Docker installieren

Wings herunterladen

Location und Node im Panel anlegen

Wings testen

Wings als Dienst einrichten

Allocations anlegen

Firewall und Ports

Ersten Gameserver anlegen

Abschluss und weitere Ressourcen

Häufig gestellte Fragen

Software

Abhängigkeiten installieren

Ubuntu 24.04

Ubuntu 22.04

Debian 11 und 12

Debian 13

Composer installieren

Panel herunterladen

Panel installieren

Datenbank anlegen

Grundkonfiguration

Umgebung einrichten

Datenbank füllen

Ersten Admin anlegen

Berechtigungen setzen

Cronjob und Queue-Worker einrichten

Cronjob

Queue-Worker (pteroq)

Webserver und SSL einrichten

DNS-Eintrag anlegen

SSL-Zertifikat mit Certbot erstellen

Nginx mit SSL konfigurieren

Nginx ohne SSL konfigurieren

Konfiguration aktivieren

Wings installieren

Docker installieren

Wings herunterladen

Location und Node im Panel anlegen

Wings testen

Wings als Dienst einrichten

Allocations anlegen

Ersten Gameserver anlegen

Abschluss und weitere Ressourcen

Gameserver

Server & Hosting

ZAPX

Ressourcen

ZAP-Hosting