Gaming-Server für Zuhause: So installieren Sie Pterodactyl auf Ihrem neuen Raspberry Pi 5!

Haben Sie schon immer davon geträumt, Ihren eigenen Gaming-Server zu Hause zu hosten, ohne teure monatliche Gebühren oder komplizierte Mietstrukturen? Mit dem neuen Raspberry Pi 5 wird dieser Traum erschwinglicher und leistungsfähiger als je zuvor! In diesem umfassenden Guide zeigen wir Ihnen Schritt für Schritt, wie Sie das beliebte Pterodactyl Panel auf Ihrem Pi 5 installieren, um Ihre Lieblingsspiele wie Minecraft, Terraria, Valheim oder sogar kleinere ARK-Server selbst zu verwalten.

Der Raspberry Pi 5 ist ein echtes Kraftpaket für seine Größe und seinen Preis. Mit seiner verbesserten CPU, mehr RAM und der Möglichkeit, NVMe-SSDs über PCIe anzuschließen, bietet er die nötige Leistung, um als stabiler Heimserver für Gaming-Anwendungen zu dienen. Und Pterodactyl ist die perfekte Wahl, um diese Power zu nutzen: Es ist ein kostenloses, quelloffenes Webinterface, das die Verwaltung von Spielservern zum Kinderspiel macht.

Was ist Pterodactyl und warum ist es ideal für Ihren Pi 5?

Pterodactyl Panel ist eine moderne, schlanke und intuitive Open-Source-Plattform zur Verwaltung von Spielservern. Es besteht aus zwei Hauptkomponenten:

• Das Panel: Eine Web-Oberfläche, über die Sie Server erstellen, starten, stoppen, konfigurieren und Ressourcen überwachen können. Es bietet eine Benutzerverwaltung, Dateimanager und Konsolenzugriff direkt im Browser.
• Wings (der Daemon): Die Server-Software, die auf Ihrem Raspberry Pi läuft und die eigentlichen Spielserver in isolierten Docker-Containern ausführt. Dies sorgt für Stabilität, Sicherheit und einfache Portabilität.

Warum ist diese Kombination so ideal für den Raspberry Pi 5? Der Pi 5 bietet:

• Genügend Leistung: Der Pi 5 verfügt über einen leistungsstarken Quad-Core ARM Cortex-A76 Prozessor und bis zu 8 GB RAM, was für viele kleinere bis mittelgroße Spielserver (insbesondere mit wenigen Spielern) ausreicht.
• Energieeffizienz: Ein Pi verbraucht nur einen Bruchteil des Stroms eines herkömmlichen PCs, was ihn ideal für einen 24/7 laufenden Gaming-Server zu Hause macht.
• Kompakte Größe: Er nimmt kaum Platz weg und ist flüsterleise.
• Kostenersparnis: Die Hardware ist günstig in der Anschaffung, und Pterodactyl ist kostenlos.
• Lernkurve: Es ist eine fantastische Möglichkeit, sich mit Linux, Docker und Serververwaltung vertraut zu machen.

Vorbereitung ist alles: Was Sie benötigen, bevor Sie beginnen

Bevor wir in die Installation eintauchen, stellen Sie sicher, dass Sie alles Notwendige zur Hand haben:

• Hardware:
  • Einen Raspberry Pi 5 (4 GB oder 8 GB RAM empfohlen)
  • Ein offizielles Raspberry Pi 5 Netzteil (5V 5A USB-C), um Stabilität zu gewährleisten.
  • Eine schnelle microSD-Karte (mind. 32 GB, Class 10/U1) ODER besser noch eine NVMe-SSD (mit Adapter für den Pi 5) für optimale Performance und Langlebigkeit. Eine SSD ist für Gaming-Server, die viele Lese-/Schreibvorgänge haben, dringend empfohlen.
  • Ein Ethernet-Kabel für eine stabile Netzwerkverbindung (WLAN ist möglich, aber nicht empfohlen für Server).
• Software:
  • Raspberry Pi OS Lite (64-bit) – Die Lite-Version ohne Desktop-Umgebung ist ideal, da sie weniger Ressourcen verbraucht. Laden Sie es von der offiziellen Raspberry Pi Website herunter.
  • Einen PC oder Laptop, um das OS auf die SD-Karte/SSD zu flashen und sich per SSH mit dem Pi zu verbinden.
  • Einen SSH-Client (z.B. PuTTY für Windows, Terminal für macOS/Linux).
• Netzwerkkenntnisse:
  • Grundkenntnisse über Ihr Heimnetzwerk.
  • Wir werden eine statische IP-Adresse für Ihren Raspberry Pi einrichten, um spätere Probleme zu vermeiden.
  • Port-Weiterleitungen (Port Forwarding) in Ihrem Router für den Zugriff auf Ihre Spielserver von außen (optional, aber für Freunde notwendig).

Schritt 1: Raspberry Pi OS Lite installieren und vorbereiten

Beginnen wir mit der Grundlage Ihres Gaming-Servers.

1. Raspberry Pi Imager nutzen: Laden Sie den Raspberry Pi Imager herunter und installieren Sie ihn.
2. Öffnen Sie den Imager. Wählen Sie unter „Betriebssystem wählen” -> „Raspberry Pi OS (other)” -> „Raspberry Pi OS Lite (64-bit)”.
3. Wählen Sie Ihr Speichermedium (microSD-Karte oder NVMe-SSD).
4. Wichtig: Klicken Sie auf das Zahnrad-Symbol für „Erweiterte Optionen”. Hier können Sie SSH aktivieren, einen Benutzernamen und ein Passwort festlegen und WLAN konfigurieren, falls Sie es benötigen. Speichern Sie diese Einstellungen.
5. Klicken Sie auf „Schreiben” und warten Sie, bis der Vorgang abgeschlossen ist.
6. Stecken Sie die SD-Karte/SSD in Ihren Pi 5, schließen Sie das Ethernet-Kabel an und verbinden Sie das Netzteil. Ihr Pi sollte hochfahren.
7. SSH-Verbindung herstellen: Finden Sie die IP-Adresse Ihres Raspberry Pi (oft in den Einstellungen Ihres Routers zu finden). Öffnen Sie ein Terminal oder PuTTY und verbinden Sie sich:

   ssh IhrBenutzername@IhreIPAdresse

   Geben Sie Ihr Passwort ein.

8. System aktualisieren: Es ist unerlässlich, Ihr System auf den neuesten Stand zu bringen.

   sudo apt update
   sudo apt upgrade -y

   Dies kann eine Weile dauern.

9. Statische IP-Adresse einrichten (empfohlen): Eine statische IP verhindert, dass sich die IP-Adresse Ihres Pi ändert, was für Serverdienste unerlässlich ist. Bearbeiten Sie die `dhcpcd.conf` Datei:

   sudo nano /etc/dhcpcd.conf

   Fügen Sie am Ende der Datei die folgenden Zeilen ein, ersetzen Sie die Werte durch Ihre Netzwerkdaten:

   interface eth0
   static ip_address=192.168.1.100/24  # Ihre gewünschte statische IP-Adresse und Subnetzmaske
   static routers=192.168.1.1         # Die IP-Adresse Ihres Routers (Gateway)
   static domain_name_servers=192.168.1.1 8.8.8.8 # DNS-Server (Ihr Router & Google DNS)

   Speichern und schließen Sie die Datei (Strg+O, Enter, Strg+X). Starten Sie den Pi neu:

   sudo reboot

   Verbinden Sie sich anschließend mit der neuen statischen IP-Adresse.

Schritt 2: Docker und Docker Compose installieren

Pterodactyl Wings basiert vollständig auf Docker. Docker ermöglicht es, Anwendungen in isolierten Containern auszuführen, was die Verwaltung von Spielservern enorm vereinfacht.

1. Docker Installationsskript ausführen:

   curl -sSL https://get.docker.com | sh

   Dies lädt das offizielle Installationsskript herunter und führt es aus.

2. Benutzer zur Docker-Gruppe hinzufügen: Damit Sie Docker-Befehle ohne `sudo` ausführen können:

   sudo usermod -aG docker IhrBenutzername

   Melden Sie sich ab und wieder an (oder starten Sie den Pi neu), damit die Änderungen wirksam werden: `exit` und dann `ssh IhrBenutzername@IhreStatischeIP`.

3. Docker testen:

   docker run hello-world

   Wenn „Hello from Docker!” angezeigt wird, ist Docker korrekt installiert.

4. Docker Compose installieren: Docker Compose wird von Pterodactyl Wings zur Verwaltung seiner Dienste verwendet.

   sudo apt install -y docker-compose

   Verifizieren Sie die Installation:

   docker-compose --version

Schritt 3: Pterodactyl Panel installieren (Das Web-Interface)

Jetzt installieren wir das Herzstück – das Pterodactyl Web-Panel.

1. Abhängigkeiten installieren:

   sudo apt install -y software-properties-common curl apt-transport-https ca-certificates git unzip

   Zusätzlich benötigen wir PHP und MySQL/MariaDB.

   sudo apt install -y php8.2 php8.2-cli php8.2-mysql php8.2-pdo php8.2-gd php8.2-mbstring php8.2-xml php8.2-bcmath php8.2-zip curl

   (Pterodactyl erfordert mindestens PHP 8.1, wir nutzen hier 8.2 als Beispiel. Überprüfen Sie die offizielle Pterodactyl-Dokumentation für die aktuell empfohlene PHP-Version.)

2. MariaDB (MySQL-kompatible Datenbank) installieren:

   sudo apt install -y mariadb-server

3. MariaDB sichern und Datenbank erstellen:

   sudo mysql_secure_installation

   Befolgen Sie die Anweisungen (Setzen Sie ein Root-Passwort, entfernen Sie anonyme Benutzer, verbieten Sie Remote-Root-Anmeldung, entfernen Sie die Testdatenbank).
   Melden Sie sich dann bei der MariaDB-Shell an:

   sudo mysql -u root -p

   Geben Sie Ihr Root-Passwort ein. Erstellen Sie eine Datenbank und einen Benutzer für Pterodactyl (ändern Sie `pterodatabase`, `pterouser` und `IhrStarkesPasswort`):

   CREATE DATABASE pterodatabase;
   CREATE USER 'pterouser'@'127.0.0.1' IDENTIFIED BY 'IhrStarkesPasswort';
   GRANT ALL PRIVILEGES ON pterodatabase.* TO 'pterouser'@'127.0.0.1' WITH GRANT OPTION;
   FLUSH PRIVILEGES;
   EXIT;

4. Pterodactyl Panel herunterladen und konfigurieren:
   Erstellen Sie ein Verzeichnis für Pterodactyl:

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

   Laden Sie das Panel herunter:

   curl -Lo panel.tar.gz https://github.com/pterodactyl/panel/releases/latest/download/panel.tar.gz
   sudo tar -xzvf panel.tar.gz
   sudo chmod -R 755 storage/* bootstrap/cache/

   Installieren Sie Composer (PHP-Abhängigkeitsmanager):

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

   Installieren Sie die Pterodactyl-Abhängigkeiten:

   sudo composer install --no-dev --optimize-autoloader

5. Umgebungskonfiguration (.env):

   cp .env.example .env

   Bearbeiten Sie die `.env`-Datei:

   sudo nano .env

   Passen Sie folgende Zeilen an:

   • `APP_URL`: Setzen Sie dies auf Ihre öffentliche Domain oder statische IP-Adresse (z.B. `http://192.168.1.100`).
   • `APP_ENV`: Lassen Sie es auf `production`.
   • Datenbankeinstellungen: `DB_DATABASE`, `DB_USERNAME`, `DB_PASSWORD` auf die zuvor erstellten Werte setzen.

   Speichern und schließen.

6. App-Key generieren:

   php artisan key:generate --force

7. Datenbank migrieren:

   php artisan migrate --force

8. Standard-Benutzer erstellen:

   php artisan p:user:make

   Geben Sie Ihre E-Mail, Benutzernamen und ein sicheres Passwort für den Admin-Zugang ein. Machen Sie diesen Benutzer zum Administrator.

9. Ordnerberechtigungen festlegen:

   sudo chown -R www-data:www-data /var/www/pterodactyl
   sudo chmod -R 755 /var/www/pterodactyl

Schritt 4: Pterodactyl Wings (Daemon) installieren

Wings ist die Komponente, die auf Ihrem Raspberry Pi läuft und die Docker-Container für die Spielserver startet und verwaltet.

1. Wings Verzeichnis erstellen:

   sudo mkdir -p /etc/pterodactyl && cd /etc/pterodactyl

2. Wings herunterladen:

   sudo curl -L -o /usr/local/bin/wings "https://github.com/pterodactyl/wings/releases/latest/download/wings_linux_arm64"

   Achten Sie darauf, dass Sie die `_arm64` Version wählen, da der Pi 5 ein ARM-Prozessor ist.

3. Wings ausführbar machen:

   sudo chmod +x /usr/local/bin/wings

4. Wings Service-Datei erstellen:

   sudo nano /etc/systemd/system/wings.service

   Fügen Sie folgenden 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.pid
   ExecStart=/usr/local/bin/wings
   Restart=on-failure
   StartLimitInterval=600
   
   [Install]
   WantedBy=multi-user.target

   Speichern und schließen.

5. Wings aktivieren und starten:

   sudo systemctl enable wings
   sudo systemctl start wings

   Überprüfen Sie den Status:

   sudo systemctl status wings

   Es sollte „active (running)” anzeigen, auch wenn es noch nicht konfiguriert ist.

6. Wings mit dem Panel verbinden:
   Gehen Sie im Pterodactyl Panel (nachdem Sie einen Nginx-Server eingerichtet haben, siehe nächsten Schritt) zu „Admin -> Nodes”. Klicken Sie auf „Create New”.
   Füllen Sie die Details aus:
   • Name: Z.B. „Raspberry Pi 5 Node”
   • Location: Wählen Sie eine neue oder vorhandene.
   • FQDN: Die IP-Adresse oder Domain Ihres Raspberry Pi (z.B. `192.168.1.100` oder `your-domain.com`).
   • Total Memory: Gesamter RAM Ihres Pi in MB (z.B. 7800 für 8 GB).
   • Memory Over-Allocation: Belassen Sie es bei 0% oder vorsichtig auf 5-10% setzen.
   • Total Disk Space: Gesamter Speicherplatz der SD-Karte/SSD in MB.
   • Disk Over-Allocation: Belassen Sie es bei 0% oder vorsichtig auf 5-10% setzen.
   • Daemon Listen Port: 8080 (Standard).
   • Daemon SFTP Port: 2022 (Standard).

   Speichern Sie den Knoten. Nach dem Speichern sehen Sie die Option „Configuration” für den Knoten. Klicken Sie darauf. Kopieren Sie den angezeigten JSON-Inhalt.
   Zurück auf Ihrem Raspberry Pi, erstellen Sie die Wings-Konfigurationsdatei:

   sudo nano /etc/pterodactyl/config.json

   Fügen Sie den kopierten JSON-Inhalt ein. Speichern und schließen.
   Starten Sie Wings neu:

   sudo systemctl restart wings

   Im Panel sollte der Knoten nun grün als „Online” angezeigt werden.

Schritt 5: Reverse Proxy (Nginx) und SSL (Let’s Encrypt) für sicheren Zugriff einrichten

Für den Zugriff auf das Pterodactyl Panel über einen Browser benötigen Sie einen Webserver. Nginx ist eine hervorragende Wahl. Für sichere Kommunikation ist SSL (HTTPS) unerlässlich.

1. Nginx installieren:

   sudo apt install -y nginx

2. Nginx Konfiguration für Pterodactyl erstellen:

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

   Fügen Sie folgenden Inhalt ein (ersetzen Sie `your-domain.com` durch Ihre Domain oder IP-Adresse):

   server {
       listen 80;
       server_name your-domain.com 192.168.1.100; # Ihre Domain UND Ihre statische IP
       return 301 https://$host$request_uri;
   }
   
   server {
       listen 443 ssl http2;
       server_name your-domain.com 192.168.1.100; # Ihre Domain UND Ihre statische IP
   
       root /var/www/pterodactyl/public;
       index index.php;
   
       ssl_certificate /etc/letsencrypt/live/your-domain.com/fullchain.pem; # Wird später erstellt
       ssl_certificate_key /etc/letsencrypt/live/your-domain.com/privkey.pem; # Wird später erstellt
       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:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384";
       ssl_prefer_server_ciphers on;
   
       access_log /var/log/nginx/pterodactyl.app-access.log;
       error_log /var/log/nginx/pterodactyl.app-error.log error;
   
       client_max_body_size 100m;
       client_body_timeout 120s;
   
       location / {
           try_files $uri $uri/ /index.php?$query_string;
       }
   
       location ~ .php$ {
           fastcgi_split_path_info ^(.+.php)(/.+)$;
           fastcgi_pass unix:/run/php/php8.2-fpm.sock; # Überprüfen Sie Ihre PHP-Version
           fastcgi_index index.php;
           include fastcgi_params;
           fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
           fastcgi_param PATH_INFO $fastcgi_path_info;
       }
   
       location ~ /.ht {
           deny all;
       }
   }

   Speichern und schließen.

3. Symbolischen Link erstellen und Nginx testen:

   sudo ln -s /etc/nginx/sites-available/pterodactyl.conf /etc/nginx/sites-enabled/pterodactyl.conf
   sudo rm /etc/nginx/sites-enabled/default # Standardkonfiguration entfernen
   sudo nginx -t # Syntax prüfen
   sudo systemctl restart nginx

4. PHP-FPM anpassen: Stellen Sie sicher, dass PHP-FPM läuft und die richtige Version ist.

   sudo systemctl enable php8.2-fpm
   sudo systemctl start php8.2-fpm

   Überprüfen Sie, ob der PHP-FPM-Socket existiert (im obigen Nginx-Config ist es `php8.2-fpm.sock`).

5. Let’s Encrypt mit Certbot installieren und nutzen:

   sudo apt install -y certbot python3-certbot-nginx

   Generieren Sie das SSL-Zertifikat (ersetzen Sie `your-domain.com` und `[email protected]`):

   sudo certbot --nginx -d your-domain.com --email [email protected] --agree-tos --no-eff-email

   Wenn Sie keine Domain haben und nur die IP verwenden, müssen Sie die SSL-Einrichtung überspringen oder ein selbstsigniertes Zertifikat erstellen (nicht empfohlen für den öffentlichen Zugriff).

6. Nginx mit SSL neu laden:

   sudo systemctl reload nginx

   Jetzt sollten Sie Pterodactyl über `https://your-domain.com` oder `https://IhreIPAdresse` erreichen können.

Schritt 6: Firewall-Regeln anpassen (UFW)

Eine Firewall ist unerlässlich für die Sicherheit Ihres Heimservers.

1. UFW installieren:

   sudo apt install -y ufw

2. Regeln hinzufügen:

   sudo ufw allow ssh                       # Port 22
   sudo ufw allow http                      # Port 80
   sudo ufw allow https                     # Port 443
   sudo ufw allow 8080/tcp                  # Pterodactyl Wings Daemon Port
   sudo ufw allow 2022/tcp                  # Pterodactyl SFTP Port

   Für Ihre Spielserver müssen Sie zusätzliche Ports öffnen. Zum Beispiel für Minecraft (Java Edition) ist es Port 25565:

   sudo ufw allow 25565/tcp                 # Minecraft Server Port

   Passen Sie dies für jedes Spiel an, das Sie hosten möchten.

3. Firewall aktivieren:

   sudo ufw enable

   Bestätigen Sie mit ‘y’.

4. Status prüfen:

   sudo ufw status verbose

Erste Schritte mit Pterodactyl: Server erstellen und verwalten

Nachdem alle technischen Hürden genommen sind, können Sie sich im Pterodactyl Panel anmelden (über die von Ihnen eingerichtete Domain oder IP-Adresse) und mit der Erstellung Ihrer Gaming-Server beginnen.

1. Admin-Anmeldung: Melden Sie sich mit dem in Schritt 3 erstellten Admin-Benutzer an.
2. Node prüfen: Gehen Sie zu „Admin” -> „Nodes”. Ihr Raspberry Pi 5 sollte als Node aufgelistet und online sein.
3. Allocations hinzufügen: Unter den Node-Einstellungen müssen Sie „Allocations” hinzufügen. Dies sind die IP-Adressen und Ports, die Ihre Spielserver nutzen werden. Klicken Sie auf „Add Allocation” und geben Sie die IP Ihres Pi und die gewünschten Ports (z.B. 25565 für Minecraft, oder weitere für andere Spiele) ein. Sie benötigen für jeden Server, den Sie hosten möchten, eine eindeutige IP/Port-Kombination.
4. Server erstellen: Gehen Sie zu „Admin” -> „Servers” -> „Create New”.
   • Wählen Sie den gewünschten Game Server (z.B. Minecraft, Terraria, etc.). Pterodactyl bietet „Eggs” (Vorlagen) für viele Spiele.
   • Geben Sie Servernamen, Owner, CPU/RAM/Speicherlimits (basierend auf der Kapazität Ihres Pi und der Anzahl der Spieler) und die zuvor erstellte Allocation ein.
   • Klicken Sie auf „Create Server”.
5. Server starten und verwalten: Sobald der Server erstellt ist, können Sie ihn in der Benutzeroberfläche starten, stoppen, Dateien verwalten, die Konsole überwachen und Backups erstellen.

Optimierung und Wartung Ihres Gaming-Servers

Ein gut laufender Server erfordert Pflege:

• Kühlung: Der Raspberry Pi 5 kann unter Last warm werden. Ein gutes Gehäuse mit aktiver Kühlung (Lüfter) oder ein passiver Kühlkörper sind dringend empfohlen, um Throttling zu vermeiden.
• SSD verwenden: Wenn noch nicht geschehen, rüsten Sie auf eine NVMe-SSD auf. Die Leistung ist um ein Vielfaches besser als bei einer microSD-Karte.
• Regelmäßige Updates: Halten Sie Ihr Raspberry Pi OS und alle Pterodactyl-Komponenten auf dem neuesten Stand.

  sudo apt update && sudo apt upgrade -y

  cd /var/www/pterodactyl && php artisan up # Panel in Wartungsmodus
  sudo composer install --no-dev --optimize-autoloader
  php artisan migrate --force
  php artisan view:clear
  php artisan config:clear
  php artisan down # Panel wieder aktivieren
  sudo systemctl restart wings

• Backups: Erstellen Sie regelmäßig Backups Ihrer Spielwelten und der Pterodactyl-Datenbank. Pterodactyl hat eine integrierte Backup-Funktion, die Sie nutzen sollten.
• Monitoring: Überwachen Sie die Ressourcennutzung (CPU, RAM, Speicherplatz) Ihres Pi, um Engpässe frühzeitig zu erkennen.

Häufige Probleme und Lösungen

• Pterodactyl Panel nicht erreichbar:
  • Überprüfen Sie, ob Nginx und PHP-FPM laufen: `sudo systemctl status nginx`, `sudo systemctl status php8.2-fpm`.
  • Überprüfen Sie die Nginx-Konfiguration: `sudo nginx -t`.
  • Stellen Sie sicher, dass Ihre Firewall die Ports 80 und 443 zulässt.
  • Ist die `APP_URL` in `.env` korrekt?
• Wings Offline oder Server starten nicht:
  • Überprüfen Sie den Wings-Status: `sudo systemctl status wings`. Schauen Sie in die Logs: `sudo journalctl -u wings -f`.
  • Stellen Sie sicher, dass Docker läuft: `sudo systemctl status docker`.
  • Überprüfen Sie die `config.json` von Wings auf Richtigkeit.
  • Sind die Ports 8080 und 2022 in der Firewall geöffnet?
  • Sind die Allocations korrekt im Panel eingerichtet?
• Server starten, aber Spieler können nicht beitreten:
  • Überprüfen Sie Ihre Router-Einstellungen für Port-Weiterleitungen. Der Port, den der Spielserver im Panel verwendet (z.B. 25565), muss in Ihrem Router an die statische IP Ihres Raspberry Pi weitergeleitet werden.
  • Stellen Sie sicher, dass die Firewall auf dem Pi den Spielport zulässt.
• Performance-Probleme:
  • Ist Ihr Pi überhitzt (Throttling)? Prüfen Sie `vcgencmd measure_temp`.
  • Nutzen Sie eine SSD statt einer SD-Karte?
  • Sind zu viele Server oder zu viele Spieler gleichzeitig aktiv für die Hardware?
  • Haben Sie genügend RAM und CPU-Kerne für die spezifischen Spielserver?

Fazit: Ihr eigener Gaming-Server, gemeistert!

Herzlichen Glückwunsch! Sie haben erfolgreich Pterodactyl Panel auf Ihrem Raspberry Pi 5 installiert und einen leistungsfähigen Gaming-Server für Ihr Zuhause eingerichtet. Dies ist ein beeindruckendes Projekt, das Ihnen nicht nur die volle Kontrolle über Ihre Spielwelten gibt, sondern auch wertvolle Erfahrungen in der Serververwaltung und im Umgang mit Linux und Docker vermittelt.

Der Raspberry Pi 5 bietet eine hervorragende Balance aus Leistung, Energieeffizienz und Kosten, die ihn zur idealen Plattform für einen Heim-Gaming-Server macht. Experimentieren Sie mit verschiedenen Spielen, optimieren Sie Ihre Einstellungen und genießen Sie die Freiheit, Ihre eigenen Regeln auf Ihrem persönlichen Server aufzustellen. Viel Spaß beim Spielen!