Installation eines Soketi WebSocket-Servers hinter einem Reverse-Proxy-Server (NGINX)

Einleitung

Dieses Tutorial erklärt, wie man einen Soketi WebSocket-Server hinter einem NGINX Reverse-Proxy-Server betreiben kann. Dieser ist dann durch den NGINX Reverse-Proxy-Server mit einer SSL-Verschlüsselung geschützt. Das SSL-Zertifikat wird mit Let's Encrypt erstellt und ist somit kostenlos. Die Erneuerung dieses Zertifikats erfolgt automatisch mit der Hilfe von dem Komandozeilenprogramm acme.sh.

Offizielle Dokumentation: https://docs.soketi.app/
Projekt Website: https://soketi.app/

Voraussetzungen

Domain-Namen (Sub-Domain ist ausreichend)
Etwas Erfahrung im Umgang mit NodeJS und NPM
Einen Server (zum Beispiel in der Hetzner Cloud)
- Debian 12 oder Ubuntu 24.04 als Betriebssystem
- SSH-Key empfohlen (siehe diesen Artikel)
- Zugriff auf den root-Benutzer oder einen Benutzer mit sudo-Berechtigungen

Beispiel-Benennungen

Domain: ws.example.com
IPv4: 203.0.113.1
IPv6: 2001:db8:1234::1

Schritt 1 - Updates installieren und notwendige Pakete installieren

Verbinde dich über SSH und IP-Adresse mit deinem Server.

Paketlisten aktualisieren und Updates installieren:

sudo apt update && sudo apt upgrade -y

Starte anschließend den Server neu, um eventuell den aktualisierten Kernel zu laden.

Als nächstes installieren wir alle notwendigen Pakete:

Installiere Voraussetzungen

sudo apt install git python3 gcc build-essential apparmor nginx

Installiere nodeJS

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.5/install.sh | bash
source ~/.bashrc
nvm install 18 && nvm use 18

Installiere die beiden NodeJS-Pakete soketi und pm2:

npm install -g @soketi/soketi
npm install -g pm2

Schritt 2 - Konfiguration für Soketi erstellen

Erstelle eine neue Konfigurationsdatei:

nano ~/config.json

Füge folgenden Inhalt hinzu und passe es gegebenenfalls an deine Bedürfnisse an:

{
  "host": "127.0.0.1",
  "port": 6001,
  "appManager": {
    "driver": "array",
    "options": {
      "apps": [
        {
          "id": "my-app-id",
          "key": "my-app-key",
          "secret": "my-app-secret",
          "name": "My App",
          "enableClientMessages": true,
          "enableStatistics": true
        }
      ]
    }
  }
}

Speichere die Datei mit der Tastenkombination STRG+O.

Wenn diese Konfigurationsdatei verwendet wird, muss keine weitere Konfiguration vor dem ersten Start gemacht werden.

Schritt 3 - Erster Start des Soketi-Servers (noch ohne PM2)

Starte nun den Soketi-Server mit folgendem Befehl:

soketi start --config="~/config.json"

Schritt 4 - Erster Test des Websocket-Servers mit Laravel 11

Laravel sollte bereits installiert sein.

Falls Laravel noch nicht installiert ist, klicke hier und installiere es jetzt

sudo apt update && sudo apt install php php-{mbstring,xml,bcmath,mysql} mariadb-server
cd ~ && php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php composer-setup.php
echo 'alias composer="php ~/composer.phar"' >> ~/.bashrc && source ~/.bashrc
composer create-project --prefer-dist laravel/laravel ~/example
cd ~/example

Und richte die Datenbank ein:

sudo mysql
MariaDB [(none)]> CREATE USER 'laravel'@'localhost' IDENTIFIED BY 'secure-password';
MariaDB [(none)]> GRANT ALL PRIVILEGES ON laravel.* TO 'laravel'@'localhost';
MariaDB [(none)]> CREATE DATABASE laravel;
MariaDB [(none)]> exit

Füge die Datenbank-Informationen in der ~/example/.env-Datei ein:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=laravel
DB_PASSWORD=secure-password

Führe nun diesen Befehl aus:

cd ~/example && php artisan migrate

Fahre nun mit Laravel und Soketi fort.

Ändere die folgenden Werte in der .env-Datei:

Gib bei app ID, app key und app secret dieselben Informationen an, die auch in ~/config.json angegeben wurden.

BROADCAST_DRIVER=pusher
PUSHER_APP_ID=your-app-id
PUSHER_APP_KEY=your-app-key
PUSHER_APP_SECRET=your-app-secret
PUSHER_APP_CLUSTER=mt1

Überprüfe die Einstellungen in der folgenden Datei config/brodcasting.php:

<?php

return [
    'connections' => [
        'pusher' => [
            'driver' => 'pusher',
            'key' => env('PUSHER_APP_KEY'),
            'secret' => env('PUSHER_APP_SECRET'),
            'app_id' => env('PUSHER_APP_ID'),
            'options' => [
                'cluster' => env('PUSHER_APP_CLUSTER'),
                'useTLS' => true,
            ],
        ],
        // other connections...
    ],
];

Schritt 5 - Erste Events auslösen

Die ersten Events können nun mit dem WebSocket-Server verschickt werden.

Schritt 6 - Auto-Start für den Soketi Server konfigurieren

Damit der Soketi-Server auch nach einem Neustart des Cloud Servers wieder automatisch gestartet wird, müssen wir nun noch pm2 einrichten:

Führe hierzu die folgenden Befehle aus:

pm2 start soketi --name WebSocket-Server -- start --config="~/config.json"
pm2 startup         # Damit wird der autostart aktiviert. Folgen Sie den Anweisungen auf dem Bildschirm.

Schritt 7 - Reverse Proxy einrichten

Nun muss der Reverse Proxy Server noch eingerichtet werden. Dieser wird die SSL-Verbindung bereitstellen und dann an den Soketi Server weitergeben. Erstelle hierfür eine neue Datei im Ordner /etc/nginx/sites-available/.

sudo mkdir /etc/nginx/ssl
sudo nano /etc/nginx/sites-available/soketi

Füge folgenden Inhalt in die Datei ein:

Ersetze ws.example.com mit deiner eigenen Domain.

server {
    listen 443 ssl;
    server_name ws.example.com;

    ssl_certificate /etc/nginx/ssl/ws.example.com.cer;
    ssl_certificate_key /etc/nginx/ssl/ws.example.com.key;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    location / {
        proxy_pass http://localhost:6001;  # Ersetze den Port, falls soketi auf einem anderen Port läuft
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

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

    location / {
        return 301 https://$host$request_uri;
    }
}

Hier klicken, für eine Konfiguration ohne SSL

Replace 203.0.113.1 with your own IP address.

server {
    listen 80;
    server_name 203.0.113.1;

    location / {
        proxy_pass http://localhost:6001;  # Replace the port if Soketi is running on a different port
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

sudo ln -s /etc/nginx/sites-available/soketi /etc/nginx/sites-enabled/soketi
sudo rm /etc/nginx/sites-available/default && sudo rm /etc/nginx/sites-enabled/default
sudo nginx -t
sudo systemctl restart nginx

Schritt 8 - SSL-Zertifikat erstellen

Bevor du das SSL-Zertifikat erstellst, erstelle passende DNS-Einträge, mit denen die IP-Adressen des Servers auf deine Domain zeigen.

Die DNS-Konfiguration sollte dann so aussehen:

# Name              Type       Value
ws.example.com      IN A       203.0.113.1
ws.example.com      IN AAAA    2001:db8:1234::1

Wenn mit dig ws.example.com die korrekte IP-Adresse angezeigt wird, kannst du das Zertifikat erstellen.

Für die Erstellung des Zertifikats benutzen wir das Shell-Script acme.sh. Dieses kann mit dem folgenden Befehl installiert werden:

curl https://get.acme.sh | sh -s email=<Ihre E-Mail-Adresse>

An diese E-Mail-Adresse werden dann Erinnerungen geschickt, wenn ein Zertifikat abläuft oder wenn es Probleme bei der Verlängerung gibt.

systemctl stop nginx && acme.sh --issue -d ws.example.com --standalone --server letsencrypt
acme.sh --install-cert -d ws.example.com --cert-file /etc/nginx/ssl/ws.example.com.cer --key-file /etc/nginx/ssl/ws.example.com.key --fullchain-file /etc/nginx/ssl/fullchain.pem --reloadcmd "systemctl reload nginx"
sudo systemctl restart nginx

Dein WebSocket Server ist nun mit einer SSL-Verschlüsselung ausgestattet. In der Konfiguration von Laravel muss nun der Port auf 443 geändert werden.

Ergebnis

Soketi wurde nun erfolgreich installiert und mit SSL-Zertifikat eingerichtet. Wenn du ws.example.com in einem Webbrowser eingibst, sollte dort "OK" erscheinen, was bedeutet, dass der WebSocket-Server erreichbar ist.

Installation eines Soketi WebSocket-Servers hinter einem Reverse-Proxy-Server (NGINX)

Author

Published

Time to read

Table of Contents