Kör spelservrar med Pelican

Det här sätter du upp

Pelican är en panel för spelservrar. I webbläsaren skapar du en Minecraft-server, eller en server för något av hundratals andra spel, ger den minne och en port och startar den. Du och dina vänner får en konsol, en filhanterare, säkerhetskopior och SFTP, var och en med sin egen inloggning.

Pelican består av två delar. Panel är webbplatsen, en PHP-app. Wings är en tjänst som kör varje spelserver i en egen Docker-container. Den här guiden lägger båda på samma server, med Caddy eller nginx som webbserver. Pelican är fortfarande i beta, så läs versionsanteckningarna före varje uppdatering.

Wings körs som root och behöver Docker som körs som root, inte Podman utan root som i våra andra guider: den skapar en container för varje spelserver, sätter dess gränser för minne och CPU och publicerar dess spelportar, allt via Dockers root-socket. Ge därför Pelican en egen server.

Varje steg nedan har körts på en nyinstallerad VC-P Alloy (2 vCPU, 8 GB) hos Melonslab med Debian 13, en gång med varje webbserver:

• Panelen installerades med PHP 8.4 från Debian och fick ett certifikat från Let's Encrypt via Caddy eller Certbot, som Wings också använder. Panelen svarade över IPv4 och IPv6 och skickade HTTP vidare till HTTPS.
• Webbinstallationen gick bara att nå från vår egen adress tills den var klar, vilket vi kontrollerade utifrån. Skannrar öppnade det nya namnet inom två minuter efter att certifikatet hade utfärdats.
• En Minecraft-server med Paper installerades och startade på omkring 30 sekunder, och svarade på en statusförfrågan från Minecraft över IPv4 från internet och över IPv6 från själva servern. Konsolen, filhanteraren och SFTP fungerade.
• En säkerhetskopia av spelservern tog ungefär en sekund, och när den återställdes kom en raderad värld tillbaka.
• Med Caddy tog Wings i bruk ett nytt certifikat inom några sekunder. Panelens uppdateringsskript, en omstart av Wings och en omstart av servern lämnade allt igång, även spelservern.

Med en Minecraft-server igång utan spelare använde servern omkring 1,7 GB minne, varav spelservern tog ungefär 1 GB.

Innan du börjar

Välj webbserver. Caddy hämtar och förnyar sina certifikat själv. nginx använder Certbot till det. Båda följer Pelicans egen konfiguration.

Du behöver:

• en nyinstallerad server hos Melonslab med Debian 13 och inget annat installerat. Panelen och Wings behöver ungefär 1 GB minne, och varje spelserver behöver sitt eget minne utöver det: 2 till 4 GB för en liten Minecraft-server;

Sätt upp SSH-nycklar, automatiska säkerhetsuppdateringar och brandväggen enligt steg 1 till 4 i säkerhetsguiden, med reglerna för HTTP och HTTPS. Steg 10 här förklarar vilka portar ufw styr och vilka den inte styr.

Exemplen använder pelican.example.com för panelen och 198.51.100.20 för adressen du surfar från. Byt genomgående ut dem mot dina egna.

1. Installera PHP och webbservern

Pelican behöver PHP 8.3 eller senare. Debian 13 har PHP 8.4. Som root:

apt update
apt install -y curl tar unzip caddy \
  php8.4-fpm php8.4-gd php8.4-mysql php8.4-mbstring php8.4-bcmath php8.4-xml \
  php8.4-curl php8.4-zip php8.4-intl php8.4-sqlite3

apt update
apt install -y curl tar unzip nginx python3-certbot-nginx \
  php8.4-fpm php8.4-gd php8.4-mysql php8.4-mbstring php8.4-bcmath php8.4-xml \
  php8.4-curl php8.4-zip php8.4-intl php8.4-sqlite3

Öppna också portarna för Wings: 8080 är dess API, som webbläsaren ansluter till för konsolen, och 2022 är dess SFTP-server:

ufw allow 8080,2022/tcp

2. Hämta panelen

mkdir -p /var/www/pelican
cd /var/www/pelican
curl -L https://github.com/pelican-dev/panel/releases/latest/download/panel.tar.gz | tar -xz
curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
COMPOSER_ALLOW_SUPERUSER=1 composer install --no-dev --optimize-autoloader
php artisan p:environment:setup

Det sista kommandot skapar /var/www/pelican/.env med en krypteringsnyckel, APP_KEY, som skyddar hemligheterna i databasen. Spara en kopia av den på ett säkert ställe utanför servern, till exempel i en lösenordshanterare: utan den går en säkerhetskopia av databasen inte att dekryptera.

Ställ in panelens adress innan du öppnar den. Installationssidan hämtar sina stilmallar från den adressen, och blir tom utan dem:

sed -i 's|^APP_URL=.*|APP_URL=https://pelican.example.com|' .env
chmod -R 755 storage/* bootstrap/cache/
chown -R www-data:www-data /var/www/pelican

3. Hämta ett certifikat och sätt upp webbservern

Tills du har gått igenom Pelicans webbinstallation i steg 4 kan vem som helst som öppnar den skapa administratörskontot och peka panelen mot en egen databas. De två raderna märkta # installer nedan släpper bara in din egen adress så länge.

{
    servers :443 {
        timeouts {
            read_body 120s
        }
    }
}

pelican.example.com {
    @notyou not remote_ip 198.51.100.20 # installer
    respond @notyou 403 # installer

    root * /var/www/pelican/public

    file_server

    php_fastcgi unix//run/php/php8.4-fpm.sock {
        root /var/www/pelican/public
        index index.php

        env PHP_VALUE "upload_max_filesize = 100M
        post_max_size = 100M"
        env HTTP_PROXY ""
        env HTTPS "on"

        read_timeout 300s
        dial_timeout 300s
        write_timeout 300s
    }

    header Strict-Transport-Security "max-age=16768000; preload;"
    header X-Content-Type-Options "nosniff"
    header X-XSS-Protection "1; mode=block;"
    header X-Robots-Tag "none"
    header Content-Security-Policy "frame-ancestors 'self'"
    header X-Frame-Options "DENY"
    header Referrer-Policy "same-origin"

    request_body {
        max_size 100m
    }

    respond /.ht* 403

    log {
        output file /var/log/caddy/pelican.log {
            roll_size 100MiB
            roll_keep_for 7d
        }
        level INFO
    }
}

wings.example.com {
    respond 404
}

caddy validate --config /etc/caddy/Caddyfile
systemctl restart caddy

certbot certonly --nginx -d pelican.example.com

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

server {
    listen 443 ssl;
    listen [::]:443 ssl;
    http2 on;
    server_name pelican.example.com;

    allow 198.51.100.20; # installer
    deny all; # installer

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

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

    client_max_body_size 100m;
    client_body_timeout 120s;

    sendfile off;

    ssl_certificate /etc/letsencrypt/live/pelican.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/pelican.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.4-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;
    }
}

rm /etc/nginx/sites-enabled/default
ln -s /etc/nginx/sites-available/pelican.conf /etc/nginx/sites-enabled/pelican.conf
nginx -t
systemctl restart nginx

4. Gå igenom webbinstallationen

Panelen behöver ett schemalagt jobb och en köhanterare, som bland annat installerar de spelmallar du väljer i installationen. Sätt upp båda först:

(crontab -l -u www-data 2>/dev/null; echo "* * * * * php /var/www/pelican/artisan schedule:run >> /dev/null 2>&1") | crontab -u www-data -
cd /var/www/pelican
php artisan p:environment:queue-service -n

Det sista kommandot skapar och startar pelican-queue.service. Öppna nu https://pelican.example.com/installer och gå igenom stegen:

• Environment: behåll App URL, och skapa ditt administratörskonto under Admin User med en e-postadress, ett användarnamn och ett långt lösenord.
• Database: behåll SQLite, som Pelican rekommenderar. Databasen är filen /var/www/pelican/database/database.sqlite.
• Eggs: eggs är Pelicans mallar för spel. Öppna fliken Minecraft och kryssa i Paper, och annat du vill ha. Du kan importera fler senare under Eggs.
• Cache, Queue och Session: behåll standardvalen. Slå på I have done both steps below under Queue, eftersom du redan har gjort dem.

Välj Finish. Du loggas in i administrationen, och installationen är borta: /installer svarar nu 404. Ta bort de två raderna märkta # installer, så att alla andra också når panelen, och gör filerna med hemligheter läsbara bara för webbservern:

sed -i '/# installer/d' /etc/caddy/Caddyfile
systemctl reload caddy
chmod 600 /var/www/pelican/.env /var/www/pelican/database/database.sqlite

sed -i '/# installer/d' /etc/nginx/sites-available/pelican.conf
systemctl reload nginx
chmod 600 /var/www/pelican/.env /var/www/pelican/database/database.sqlite

Tills du gör det kan alla användare på servern läsa båda filerna.

5. Installera Docker och Wings

Det här är Dockers eget installationsskript, som Pelicans dokumentation använder:

curl -sSL https://get.docker.com/ | CHANNEL=stable sh
mkdir -p /etc/pelican /var/run/wings
curl -L -o /usr/local/bin/wings https://github.com/pelican-dev/wings/releases/latest/download/wings_linux_amd64
chmod u+x /usr/local/bin/wings

Skapa /etc/systemd/system/wings.service:

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

[Service]
User=root
WorkingDirectory=/etc/pelican
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

6. Skapa noden

En nod är en server som kör Wings. Öppna Nodes i panelen och välj New Node:

• Behåll Port 8080 och HTTPS (SSL), och ge noden ett Display Name, till exempel Stockholm.
• Gå vidare till Advanced Settings. Standardvalen räcker: serverfilerna i /var/lib/pelican/volumes och SFTP på port 2022. Välj plustecknet för att skapa noden.

Nodens flik Configuration File visar filen som Wings behöver. Skriv den till servern:

cd /var/www/pelican
php artisan p:node:configuration 1 > /etc/pelican/config.yml
chmod 600 /etc/pelican/config.yml

1 är nodens nummer, som du också ser i webbläsarens adressfält, som i /admin/nodes/1/edit. Filen innehåller nodens hemliga token, så låt bara root läsa den.

C=/var/lib/caddy/.local/share/caddy/certificates/acme-v02.api.letsencrypt.org-directory/wings.example.com
sed -i "s|^    cert: .*|    cert: $C/wings.example.com.crt|; s|^    key: .*|    key: $C/wings.example.com.key|" /etc/pelican/config.yml
grep -E '^    (cert|key):' /etc/pelican/config.yml

systemctl daemon-reload
systemctl enable --now wings

[Unit]
Description=Watch the Wings certificate that Caddy renews

[Path]
PathChanged=/var/lib/caddy/.local/share/caddy/certificates/acme-v02.api.letsencrypt.org-directory/wings.example.com/wings.example.com.json

[Install]
WantedBy=multi-user.target

[Unit]
Description=Restart Wings to load a renewed certificate

[Service]
Type=oneshot
ExecStart=/usr/bin/systemctl restart wings.service

systemctl daemon-reload
systemctl enable --now wings-cert.path

systemctl daemon-reload
systemctl enable --now wings

#!/bin/sh
systemctl reload nginx
systemctl restart wings

chmod +x /etc/letsencrypt/renewal-hooks/deploy/pelican

Efter en minut visar nodens Overview versionen av Wings och serverns minne och disk. Spelservrar som körs fortsätter att köras när Wings startas om.

7. Lägg till en port för spelarna

En allocation är en adress och en port som en spelserver lyssnar på. Wings skickar adressen vidare till Docker som den är: 0.0.0.0 betyder alla IPv4-adresser och :: alla IPv6-adresser, men var och en bara den ena av de två. För att spelarna ska nå ett spel över båda ger du det samma port på båda.

Öppna noden och välj New allocation under Allocations:

• Välj 0.0.0.0 som IP Address, skriv 25565, Minecrafts port, under Ports och tryck Enter, och välj Create.
• Gör likadant en gång till med :: som IP Address.

8. Skapa en Minecraft-server

Öppna Servers och välj New Server:

• Information: ett Name, till exempel Survival, och en Owner. Välj 0.0.0.0:25565 som Primary Allocation och [::]:25565 under Additional Allocations.
• Egg Configuration: välj Paper. Standardvalen hämtar den senaste versionen av Minecraft och startar servern när den är installerad.
• Environment Configuration: välj Limited under Memory och ange en Memory Limit, till exempel 4096 MiB. Sätt Swap Memory till Disabled. Tillåt ett antal säkerhetskopior under Backups, till exempel 2: standardvärdet, 0, tillåter inga.

Välj plustecknet för att skapa servern. Wings hämtar Java-avbildningen och Paper, vilket tog omkring 30 sekunder på vår testserver. Den första starten stannar vid Minecrafts licensvillkor. Öppna servern från panelens startsida, välj Start och sedan I Accept under Minecraft EULA. Konsolen visar hur servern startar, och Status visar Running.

Spelarna ansluter till pelican.example.com, eller något annat namn som pekar på servern. Minecraft använder port 25565 från början, så de behöver inte ange den.

9. Användare och inloggning

Pelican har ingen sida för att registrera sig: /register svarar 404, och bara en administratör kan skapa konton, under Users och New User. För att dela en server med någon lägger du till personens konto under serverns Users.

Pelican skickar ingen e-post förrän du har ställt in en mailserver under Settings och Mail: tills dess skrivs meddelanden som återställning av lösenord bara till panelens logg. Ge varje konto ett lösenord när du skapar det.

Under ditt namn finns Profile, med 2FA, Passkeys och SSH Keys. Slå på tvåfaktorsautentisering för alla administratörer. SFTP frågar bara efter lösenordet, inte efter den andra faktorn, så ett långt lösenord är viktigt, eller en SSH-nyckel som du lägger till där.

För SFTP visar serverns Settings adressen och användarnamnet under SFTP Information. Användarnamnet är ditt eget, en punkt och serverns korta id:

sftp -P 2022 anna.1a2b3c4d@wings.example.com

sftp -P 2022 anna.1a2b3c4d@pelican.example.com

10. Det här är öppet mot internet

Panelen, Wings och SFTP körs direkt på servern, så det är ufw som bestämmer vem som når dem. Spelportarna fungerar annorlunda. Docker öppnar en spelservers portar när den startar, i en egen kedja i brandväggen som ufws regler aldrig ser: på vår testserver hindrade ufw deny 25565/tcp inte spelarna från att ansluta. Docker publicerar varje spelport för både TCP och UDP. Portar som ingen spelserver i drift använder förblir stängda.

De spelportar som är öppna är alltså de som tillhör servrarna som körs. För att stänga en spelport som en server i drift använder lägger du till en DROP-regel i Dockers kedja DOCKER-USER, som i steg 5 i Coolify-guiden.

11. Säkerhetskopiera

Öppna spelservern och Backups, och välj New backup. Wings sparar säkerhetskopian som en .tar.gz-fil i /var/lib/pelican/backups. För att återställa en öppnar du dess Actions och väljer Restore. Servern stoppas under tiden, och Delete all files before restoring backup? tar bort filer som har tillkommit efter säkerhetskopian. På vår testserver tog en säkerhetskopia på 208 MB ungefär en sekund, och återställningen ungefär två. Under serverns Schedules kan säkerhetskopior också tas automatiskt, vilket vi inte har testat.

En säkerhetskopia som ligger kvar på servern hjälper inte om servern går förlorad. Kopiera /var/lib/pelican/backups till en annan maskin, eller lägg till en S3-kompatibel bucket under Backup Hosts med Schema satt till S3, vilket vi inte har testat. För själva panelen sparar du en kopia av /var/www/pelican/.env och /var/www/pelican/database/database.sqlite.

12. Uppdateringar

Pelicans uppdateringsskript sparar en kopia av filen .env och SQLite-databasen i /var/www/pelican/backup, byter ut panelens filer och uppdaterar databasen. Svara på dess frågor med Enter för att behålla standardvalen, och sätt sedan behörigheterna som det ber om:

bash -c "$(curl -fsSL https://pelican.dev/updatePanel.sh)"
chmod -R 755 /var/www/pelican/storage/* /var/www/pelican/bootstrap/cache
chown -R www-data:www-data /var/www/pelican

Wings uppdaterar sig själv, och spelservrar som körs fortsätter att köras:

wings update
systemctl restart wings

Administrationens Dashboard visar när en ny version av panelen finns, och nodens Overview visar versionen av Wings bredvid den senaste. Pelican kontrollerar båda hos GitHub. Vi hittade ingen telemetri i vare sig panelen eller Wings.

Felsökning

Installationssidan är tom, utan stilmallar. APP_URL i /var/www/pelican/.env är inte adressen du öppnade. Ställ in den som i steg 2 och ladda om sidan.

Konsolen förblir tom, och Start gör ingenting. Webbläsaren ansluter till Wings på port 8080. Kontrollera systemctl status wings, och att ufw status tillåter 8080. Om du kör wings --debug efter systemctl stop wings ser du varför Wings inte startar.

Spelarna kan inte ansluta över IPv4, eller över IPv6. Servern har en allocation för bara den ena av de två. Lägg till den andra som i steg 7. Öppna serverns Allocations i administrationen, välj Associate och välj den, och starta sedan om servern.

Servern stannar direkt efter starten, med "You need to agree to the EULA". Välj I Accept i dialogrutan som konsolen visar.