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.
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.
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.
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 |
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.
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:
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.
Bring dein System vor der Installation auf den neuesten Stand:
apt update && apt upgrade -y
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.
Unter Ubuntu 24.04 sind PHP 8.3, MariaDB und Redis bereits in den Standard-Paketquellen enthalten. Du brauchst also keine zusätzlichen Repositories:
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 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:
# 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
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:
# 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 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:
# 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 ist der Paketmanager für PHP, über den das Panel seine Bibliotheken bezieht. Installiere ihn mit:
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:
php -v
Lege den Ordner für das Panel an und wechsle hinein:
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/:
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/
Das Panel speichert alle Daten in einer eigenen Datenbank. Melde dich bei MariaDB an:
mariadb -u root -p
Lege einen Benutzer und eine Datenbank für das Panel an. Ersetze DeinSicheresPasswort durch ein eigenes, sicheres Passwort:
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.
Kopiere die Beispiel-Konfiguration, installiere die PHP-Abhängigkeiten und erzeuge den Schlüssel der Anwendung:
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
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.
Mit den folgenden Befehlen richtest du Sitzungen, Cache, die Datenbankverbindung und den Mailversand ein. Die Befehle fragen dich interaktiv nach den Werten:
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.
Jetzt legt das Panel seine Tabellen an und importiert die mitgelieferten Nests und Eggs (die Vorlagen für die einzelnen Spiele):
php artisan migrate --seed --force
Bitte warten
Das kann ein paar Minuten dauern. Brich den Vorgang nicht ab, sonst ist die Datenbank unvollständig.
Lege deinen Admin-Account an. Das Passwort muss mindestens 8 Zeichen lang sein, Groß- und Kleinbuchstaben und mindestens eine Zahl enthalten:
php artisan p:user:make
Beantworte die Frage, ob der Benutzer ein Administrator sein soll, mit yes.
Damit Nginx und PHP auf die Dateien zugreifen können, übergibst du sie dem Webserver-Benutzer:
chown -R www-data:www-data /var/www/pterodactyl/*
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.
Öffne die Crontab mit sudo crontab -e und füge diese Zeile hinzu. Sie startet den Scheduler des Panels jede Minute:
* * * * * php /var/www/pterodactyl/artisan schedule:run >> /dev/null 2>&1
Der Queue-Worker läuft als systemd-Dienst dauerhaft im Hintergrund. Erstelle die Datei:
nano /etc/systemd/system/pteroq.service
Füge diesen Inhalt ein:
# 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:
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.
Damit du das Panel über eine eigene Domain mit HTTPS erreichst, richtest du jetzt DNS, ein SSL-Zertifikat und Nginx ein.
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.
Installiere Certbot mit dem Nginx-Plugin und erstelle das Zertifikat. Ersetze panel.example.com durch deine Domain:
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:
0 23 * * * certbot renew --quiet --deploy-hook "systemctl restart nginx wings"
Entferne die Standard-Konfiguration von Nginx:
rm /etc/nginx/sites-enabled/default
Erstelle eine neue Konfigurationsdatei für das Panel:
nano /etc/nginx/sites-available/pterodactyl.conf
Füge diese Konfiguration ein und ersetze panel.example.com an allen vier Stellen durch deine Domain:
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;
}
}
Zertifikat zuerst
Nginx startet mit dieser Konfiguration nur, wenn das SSL-Zertifikat bereits existiert. Erstelle es also unbedingt vorher mit Certbot.
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:
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.
Aktiviere die Konfiguration, prüfe sie auf Fehler und starte Nginx neu:
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 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.
Wings startet jeden Gameserver in einem Docker-Container. Installiere Docker CE mit dem offiziellen Installationsskript und aktiviere den Dienst:
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.
Lege den Konfigurationsordner an und lade die aktuelle Wings-Version für deine CPU-Architektur herunter:
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
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
8080und Daemon SFTP Port auf2022stehen 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.
Starte Wings einmal im Debug-Modus, um Fehler direkt zu sehen:
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.
Damit Wings dauerhaft im Hintergrund läuft, legst du einen systemd-Dienst an:
nano /etc/systemd/system/wings.service
Füge diesen Inhalt ein:
[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:
sudo systemctl enable --now wings
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:
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.
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:
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.
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.
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.
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! 🙂