---
title: "Installation auf einem Webserver (ohne Docker)"
description: "QuickTribe direkt mit nginx, PHP-FPM, MariaDB, Redis und Mercure auf einem Linux-Server betreiben"
---

Für Betreiber, die keinen Docker einsetzen möchten: QuickTribe läuft auch direkt auf einem Linux-Server mit nginx und PHP-FPM. Composer, Node.js oder ein Build-Schritt sind nicht nötig – das **Webserver-Archiv** enthält die fertige Anwendung samt PHP-Abhängigkeiten und gebauter Oberfläche.

Sie brauchen Root-Zugriff auf einen eigenen Server (VPS oder dedizierter Server). Shared Hosting genügt nicht: Die Plattform braucht dauerhaft laufende Prozesse (Worker, Echtzeit-Hub) und Redis.

<Note>
Die Anleitung ist mit **Debian 13 „trixie“** durchgespielt (frisches System, alle Befehle wie unten). Andere Distributionen funktionieren mit denselben Bausteinen, Paketnamen und Pfade weichen ab. Unter Ubuntu 24.04 kommt PHP 8.5 aus dem PPA `ppa:ondrej/php`; die dort enthaltene MariaDB 10.11 ist zu alt, MariaDB 11.4 oder neuer liefert das Paket-Repository von mariadb.org.
</Note>

## Bausteine

| Baustein | Aufgabe | Version | Entspricht im Docker-Stack |
| --- | --- | --- | --- |
| nginx | TLS, statische Dateien, Weiterleitung an PHP und den Echtzeit-Hub | 1.25 oder neuer | Dienst `app` |
| PHP-FPM 8.5 | die Anwendung | 8.5 | Dienst `app` |
| Worker | Hintergrundjobs: E-Mails, Push, Punkte, Link-Vorschauen, Video-Umwandlung, Zahlungsabgleich, Zeitpläne; Aufträge von Plugins in einem zweiten Dienst | – (zwei systemd-Dienste) | Dienst `worker` |
| MariaDB | Datenbank | 11.4 oder neuer (Debian 13: 11.8) | Dienst `mariadb` |
| Redis | Sitzungen, Cache, Warteschlange | 7 oder neuer (Debian 13: 8.0) | Dienst `redis` |
| Mercure | Echtzeit-Hub | 0.24.2 | Dienst `mercure` |
| ffmpeg | Umwandlung hochgeladener Kursvideos | Distributionspaket | im Image enthalten |

Hardware wie unter [Systemvoraussetzungen](/index#systemvoraussetzungen). Dazu kommen eine Domain, deren DNS-Eintrag auf den Server zeigt, offene Ports 80 und 443 und ein SMTP-Zugang (siehe [Konfiguration](/konfiguration#e-mail); er lässt sich auch nach dem ersten Login im Plattform-Admin unter **E-Mail-Versand** eintragen).

## 1. Webserver-Archiv prüfen

Mit jedem Release erhalten Sie neben dem Auslieferungspaket für Docker das Archiv `quicktribe-vX.Y.Z-webserver.tar.gz` und seine Prüfsumme. Beide auf den Server kopieren und prüfen:

```bash
sha256sum -c quicktribe-vX.Y.Z-webserver.tar.gz.sha256
```

Das Archiv enthält den Code, die PHP-Abhängigkeiten (`vendor/`), die gebaute Oberfläche (`public/build/`) und die mitgelieferten Themes. Geheimnisse enthält es keine; die Datei `.env` darin hat nur unkritische Standardwerte.

## 2. Pakete installieren

Debian 13 enthält PHP 8.4. PHP 8.5 kommt aus der Paketquelle [packages.sury.org](https://packages.sury.org/php/) von Ondřej Surý, der auch die PHP-Pakete in Debian betreut:

```bash
apt-get update
apt-get install -y ca-certificates curl lsb-release unzip certbot
curl -fsSLo /tmp/debsuryorg-archive-keyring.deb https://packages.sury.org/debsuryorg-archive-keyring.deb
dpkg -i /tmp/debsuryorg-archive-keyring.deb
echo "deb [signed-by=/usr/share/keyrings/debsuryorg-archive-keyring.gpg] https://packages.sury.org/php/ $(lsb_release -sc) main" \
  > /etc/apt/sources.list.d/php.list
apt-get update
apt-get install -y nginx mariadb-server redis-server ffmpeg \
  php8.5-fpm php8.5-cli php8.5-intl php8.5-mysql php8.5-zip php8.5-gd php8.5-bcmath \
  php8.5-redis php8.5-curl php8.5-mbstring php8.5-xml
php -v   # PHP 8.5.x
```

Benötigt werden die PHP-Erweiterungen `intl`, `pdo_mysql`, `zip`, `gd` (mit JPEG, WebP und FreeType), `bcmath`, `redis`, `curl`, `mbstring`, `xml` (mit `dom`, u. a. für die PDF-Tickets), `sodium`, `pcntl` und OPcache; die Pakete oben bringen sie alle mit (`php -m` zeigt sie an). Für [Plugins](/plugins/ueberblick) braucht QuickTribe außerdem das Kommandozeilenprogramm `php` (Paket `php8.5-cli`, prüft neue Plugin-Fassungen in einem eigenen Prozess) und `openssl` (Zeitstempel, kommt mit `ca-certificates`); PHP darf dafür Prozesse starten (`proc_open` nicht in `disable_functions`).

## 3. MariaDB

Zeichensatz wie im Docker-Stack, dann Datenbank und Benutzer anlegen:

```bash
cat > /etc/mysql/mariadb.conf.d/99-quicktribe.cnf <<'CNF'
[mariadbd]
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci
CNF
systemctl restart mariadb

DB_PASSWORD=$(openssl rand -hex 24); echo "$DB_PASSWORD"   # für DATABASE_URL notieren
mariadb -e "CREATE DATABASE community CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
  CREATE USER 'community'@'localhost' IDENTIFIED BY '$DB_PASSWORD';
  GRANT ALL PRIVILEGES ON community.* TO 'community'@'localhost';"
```

MariaDB lauscht unter Debian nur lokal; das bleibt so.

## 4. Redis

Redis lauscht unter Debian nur lokal (`127.0.0.1`). Damit die Warteschlange einen Neustart übersteht, das Append-Only-File einschalten:

```bash
sed -i 's/^appendonly no/appendonly yes/' /etc/redis/redis.conf
systemctl restart redis-server
redis-cli ping   # PONG
```

## 5. Mercure (Echtzeit)

Der Hub kommt als Paket von den [Mercure-Releases](https://github.com/dunglas/mercure/releases) (Version 0.24.2 wie im Docker-Stack) und lauscht nur lokal auf Port 3000; nginx leitet `/.well-known/mercure` an ihn weiter.

```bash
ARCH=$(dpkg --print-architecture)   # amd64 oder arm64
curl -fsSLo /tmp/mercure.deb https://github.com/dunglas/mercure/releases/download/v0.24.2/mercure_0.24.2_linux_${ARCH}.deb
apt-get install -y /tmp/mercure.deb
install -d /etc/mercure
MERCURE_JWT_SECRET=$(openssl rand -hex 32); echo "$MERCURE_JWT_SECRET"   # für .env.local notieren
echo "MERCURE_JWT_SECRET=$MERCURE_JWT_SECRET" > /etc/mercure/mercure.env
chmod 600 /etc/mercure/mercure.env
```

`/etc/mercure/Caddyfile`:

```text
# Mercure-Hub für QuickTribe: nur lokal, nginx leitet /.well-known/mercure weiter
{
	admin off
	auto_https off
}

http://:3000 {
	bind 127.0.0.1
	mercure {
		publisher_jwt {env.MERCURE_JWT_SECRET}
		subscriber_jwt {env.MERCURE_JWT_SECRET}
		anonymous
	}
	respond /healthz 200
	respond "Not Found" 404
}
```

`/etc/systemd/system/mercure.service`:

```ini
[Unit]
Description=Mercure-Hub (Echtzeit) für QuickTribe
After=network.target

[Service]
DynamicUser=yes
StateDirectory=mercure
Environment=XDG_DATA_HOME=/var/lib/mercure XDG_CONFIG_HOME=/var/lib/mercure
EnvironmentFile=/etc/mercure/mercure.env
ExecStart=/usr/bin/mercure run --config /etc/mercure/Caddyfile --adapter caddyfile
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target
```

```bash
systemctl daemon-reload
systemctl enable --now mercure
curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:3000/healthz   # 200
```

`MERCURE_JWT_SECRET` muss in `/etc/mercure/mercure.env` und in der Konfiguration der Anwendung (Schritt 7) **gleich** sein.

## 6. Anwendung entpacken

Jede Version bekommt ein eigenes Verzeichnis unter `releases/`; der Link `current` zeigt auf die laufende. Was Versionen überdauert – Konfiguration und Uploads (darin auch hochgeladene Themes) – liegt unter `shared/`. So sind Updates und ein Rücksprung jeweils nur ein Umschalten des Links.

```bash
VERSION=vX.Y.Z
B=/var/www/quicktribe
install -d $B/releases $B/shared
install -d -o www-data -g www-data -m 750 $B/shared/uploads
install -d -o root -g root -m 755 $B/shared/plugins
install -d $B/releases/$VERSION
tar -xzf quicktribe-$VERSION-webserver.tar.gz -C $B/releases/$VERSION --strip-components=1
install -d -o www-data -g www-data $B/releases/$VERSION/var
ln -s $B/shared/.env.local $B/releases/$VERSION/.env.local
ln -sfn $B/releases/$VERSION $B/current
```

| Pfad | Eigentümer | Inhalt |
| --- | --- | --- |
| `releases/<version>/` | `root` | Code – für PHP nur lesbar |
| `releases/<version>/var/` | `www-data` | Cache und Laufzeitdateien dieser Version |
| `shared/.env.local` | `root:www-data`, Modus `640` | Konfiguration mit Geheimnissen |
| `shared/uploads/` | `www-data`, Modus `750` | Bilder, Anhänge, Videos, Rechnungen, hochgeladene Logos und [Themes](/anpassen/theme-installieren) (`STORAGE_LOCAL_ROOT`) |
| `shared/plugins/` | `root`, Modus `755` | [Plugins](/plugins/installieren#webserver-ohne-docker) (`APP_PLUGINS_DIR`) – alles darin gehört `root` und ist für `www-data` nur lesbar |
| `/tmp` | – | Zwischenablage für Uploads und Video-Umwandlung: Platz für mindestens das Doppelte des größten Videos |

## 7. Konfiguration

Die Anwendung liest ihre Einstellungen aus `.env.local` im Anwendungsverzeichnis (hier ein Link auf `shared/.env.local`); Werte darin überschreiben die Standardwerte aus `.env`. Alle Variablen erklärt die [Konfiguration](/konfiguration). Für den Webserver-Betrieb:

```bash
cat > /var/www/quicktribe/shared/.env.local <<ENV
APP_SECRET=$(openssl rand -hex 32)
APP_URL=https://community.example.org
APP_NAME=QuickTribe
DATABASE_URL="mysql://community:$DB_PASSWORD@localhost:3306/community?serverVersion=11.8.0-MariaDB&charset=utf8mb4"
REDIS_URL=redis://127.0.0.1:6379
MESSENGER_TRANSPORT_DSN=redis://127.0.0.1:6379/messages
MERCURE_URL=http://127.0.0.1:3000/.well-known/mercure
MERCURE_PUBLIC_URL=/.well-known/mercure
MERCURE_JWT_SECRET=$MERCURE_JWT_SECRET
STORAGE_LOCAL_ROOT=/var/www/quicktribe/shared/uploads
APP_PLUGINS_DIR=/var/www/quicktribe/shared/plugins
TRUSTED_PROXIES=127.0.0.1
MAILER_DSN=smtp://benutzer:passwort@mail.example.org:587
MAILER_FROM_ADDRESS=noreply@example.org
ADMIN_EMAIL=admin@example.org
ADMIN_PASSWORD=$(openssl rand -hex 12)
ENV
chown root:www-data /var/www/quicktribe/shared/.env.local
chmod 640 /var/www/quicktribe/shared/.env.local
grep ADMIN_PASSWORD /var/www/quicktribe/shared/.env.local   # Passwort des ersten Kontos
```

Die Shell setzt beim Anlegen Zufallswerte ein und – in derselben Sitzung – `DB_PASSWORD` und `MERCURE_JWT_SECRET` aus Schritt 3 und 5; in einer neuen Sitzung die notierten Werte von Hand eintragen. Danach die Datei mit einem Editor ergänzen (SMTP-Zugang, später Stripe, Push, Google-Login). Hinweise:

- `APP_SECRET` nach dem ersten Start **nie** ändern – daraus werden Geheimnisse verschlüsselt.
- `MAILER_DSN`/`MAILER_FROM_ADDRESS` sind optional: Lässt man `MAILER_DSN` leer, richtet der Plattform-Admin den SMTP-Zugang unter **E-Mail-Versand** ein (siehe [Konfiguration → E-Mail](/konfiguration#e-mail)).
- Werte mit `&`, Leerzeichen oder `#` in Anführungszeichen setzen; Sonderzeichen in Passwörtern innerhalb von URLs URL-kodieren (`@` → `%40`).
- `localhost` in `DATABASE_URL` verbindet über den Unix-Socket von MariaDB. `serverVersion` an die installierte Version anpassen (`mariadb --version`).
- `TRUSTED_PROXIES=127.0.0.1`: nginx spricht direkt mit den Besuchern, es gibt keinen weiteren Proxy. Steht doch einer davor (z. B. ein Load Balancer), dessen Adresse ergänzen (siehe [Proxys und Besucher-IP](/konfiguration#proxys-und-besucher-ip)).
- Die Sitzungen in Redis stellt PHP selbst ein (Schritt 8, `session.save_path`); `REDIS_SESSION_SAVE_PATH` wird hier nicht gebraucht.
- `APP_PLUGINS_DIR` zeigt auf `shared/plugins`, damit Plugins Updates der Plattform überdauern. Ohne die Zeile sucht QuickTribe Plugins im Ordner `plugins/` der jeweiligen Version.
- Variablen, die nur die Docker-Varianten betreffen (`APP_IMAGE`, `MARIADB_*`, `APP_PORT`, `APP_BIND`, `TRAEFIK_*`, `COMPOSE_PROJECT_NAME`), entfallen.

## 8. PHP und PHP-FPM

Die Einstellungen entsprechen denen des Docker-Images. `/etc/php/8.5/mods-available/quicktribe.ini`:

```ini
; QuickTribe – PHP-Einstellungen (entsprechen docker/app/php.ini des Images)
memory_limit = 512M
; Anhänge bis 100 MB, Videos bis 2 GB – nginx begrenzt alle anderen Routen auf 105 MB
upload_max_filesize = 2048M
post_max_size = 2100M
date.timezone = UTC
expose_php = Off
display_errors = Off
display_startup_errors = Off
log_errors = On
opcache.enable = 1
opcache.memory_consumption = 256
opcache.max_accelerated_files = 30000
; 0 = Code wird nur beim Neustart von php-fpm neu gelesen (nach jedem Update: systemctl reload php8.5-fpm)
opcache.validate_timestamps = 0
realpath_cache_size = 4096K
realpath_cache_ttl = 600
session.cookie_secure = 1
session.cookie_httponly = 1
session.cookie_samesite = Lax
; Sitzungen in Redis MIT Sperre; persistent=1 ist Pflicht (sonst brechen unter Last Sitzungen ab)
session.save_handler = redis
session.save_path = "tcp://127.0.0.1:6379?persistent=1&timeout=2.5&read_timeout=2.5"
redis.session.locking_enabled = 1
redis.session.lock_expire = 30
redis.session.lock_wait_time = 20000
redis.session.lock_retries = 250
session.lazy_write = 1
```

Pool `/etc/php/8.5/fpm/pool.d/quicktribe.conf`:

```ini
; QuickTribe – php-fpm-Pool (entspricht docker/app/php-fpm.conf des Images)
[quicktribe]
user = www-data
group = www-data
listen = /run/php/quicktribe.sock
listen.owner = www-data
listen.group = www-data
listen.mode = 0660
pm = dynamic
pm.max_children = 20
pm.start_servers = 4
pm.min_spare_servers = 2
pm.max_spare_servers = 6
pm.status_path = /fpm-status
ping.path = /fpm-ping
; Anwendungslog (JSON auf stdout) landet im Log von php-fpm
catch_workers_output = yes
decorate_workers_output = no
```

```bash
ln -s /etc/php/8.5/mods-available/quicktribe.ini /etc/php/8.5/fpm/conf.d/99-quicktribe.ini
ln -s /etc/php/8.5/mods-available/quicktribe.ini /etc/php/8.5/cli/conf.d/99-quicktribe.ini
rm /etc/php/8.5/fpm/pool.d/www.conf   # Standard-Pool wird nicht gebraucht (auf einem gemeinsam genutzten Server stehen lassen)
systemctl restart php8.5-fpm
```

## 9. Datenbank, Cache und erstes Konto

Alle Konsolenbefehle laufen im Anwendungsverzeichnis als `www-data`:

```bash
cd /var/www/quicktribe/current
runuser -u www-data -- php bin/console cache:warmup
runuser -u www-data -- php bin/console doctrine:migrations:migrate --no-interaction --allow-no-migration
runuser -u www-data -- php bin/console app:install
```

`app:install` legt aus `ADMIN_EMAIL`/`ADMIN_PASSWORD` das erste Konto (Plattform-Admin) an und schaltet den [Wartungsmodus](/konfiguration#wartungsmodus) ein; die Ausgabe nennt das **Zugangswort** (Zeile `Zugangswort: …`). Danach darf `ADMIN_PASSWORD` aus `.env.local` entfernt werden.

<Note>
Zeilen mit `User Deprecated` in der Ausgabe der Konsolenbefehle sind Hinweise für künftige Versionen der verwendeten Bibliotheken, keine Fehler.
</Note>

## 10. nginx und TLS

Zuerst das Zertifikat holen. Solange die Standard-Site von Debian aktiv ist, beantwortet nginx auf Port 80 die Prüfung von Let's Encrypt aus `/var/www/html`:

```bash
certbot certonly --webroot -w /var/www/html -d community.example.org \
  -m admin@example.org --agree-tos --no-eff-email --deploy-hook "systemctl reload nginx"
```

Dann die Site anlegen – `/etc/nginx/sites-available/quicktribe`:

```nginx
# QuickTribe – nginx-Site (abgeleitet von docker/nginx/nginx.conf des Images)
server {
    listen 80;
    listen [::]:80;
    server_name community.example.org;
    # Zertifikats-Erneuerung durch certbot (Webroot), alles andere auf https
    location /.well-known/acme-challenge/ { root /var/www/html; }
    location / { return 301 https://$host$request_uri; }
}

server {
    listen 443 ssl;
    listen [::]:443 ssl;
    http2 on;
    server_name community.example.org;

    ssl_certificate     /etc/letsencrypt/live/community.example.org/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/community.example.org/privkey.pem;

    root /var/www/quicktribe/current/public;
    index index.php;
    server_tokens off;
    client_max_body_size 105m;
    gzip on;
    gzip_types text/plain text/css application/json application/javascript image/svg+xml;

    # Für PHP-Antworten setzt die Anwendung alle Sicherheits-Header selbst. Die add_header unten gelten nur für
    # Dateien, die nginx direkt ausliefert (add_header wird nicht vererbt, sobald eine Location eigene hat).
    location /build/ {
        add_header Cache-Control "public, max-age=31536000, immutable";
        add_header X-Content-Type-Options "nosniff" always;
        add_header Referrer-Policy "strict-origin-when-cross-origin" always;
        add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
        try_files $uri =404;
    }
    # PWA-Manifest kommt aus der Anwendung; Service Worker ohne Cache, damit Updates sofort greifen
    location = /manifest.webmanifest { rewrite ^ /index.php last; }
    location = /sw.js {
        add_header Cache-Control "no-cache";
        add_header X-Content-Type-Options "nosniff" always;
        add_header Referrer-Policy "strict-origin-when-cross-origin" always;
        add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    }
    # Video-Upload bis 2 GB nur auf dieser Route; alle anderen behalten 105 MB. Direkt an PHP (kein try_files):
    # nach einer internen Weiterleitung auf /index.php gälte wieder das Limit von 105 MB.
    location ~ ^/api/v1/communities/[a-z0-9-]+/media/videos$ {
        client_max_body_size 2100m;
        fastcgi_pass unix:/run/php/quicktribe.sock;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $realpath_root/index.php;
        fastcgi_param SCRIPT_NAME /index.php;
        fastcgi_param DOCUMENT_ROOT $realpath_root;
        fastcgi_param HTTP_X_REQUEST_ID $request_id;
        fastcgi_buffers 16 16k;
        fastcgi_buffer_size 32k;
        fastcgi_read_timeout 300s;
    }
    # Echtzeit: Mercure-Hub auf demselben Host, Server-Sent Events ohne Puffer und ohne Timeout
    location /.well-known/mercure {
        proxy_pass http://127.0.0.1:3000;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_buffering off;
        proxy_cache off;
        proxy_read_timeout 24h;
    }
    # Gebaute Dateien der Plugins: /plugin-assets/<id>/<hash>/<datei> aus shared/plugins/<id>/dist (nur feste
    # Endungen, keine Symlinks, alles andere 404). Cache-Control ohne "always": ein 404 darf nicht dauerhaft gelten.
    location ^~ /plugin-assets/ {
        disable_symlinks on;
        location ~ "^/plugin-assets/([a-z][a-z0-9-]{2,23})/[0-9a-f]{12}/([A-Za-z0-9_./-]+\.(js|css|woff2|png|webp|svg|json))$" {
            alias /var/www/quicktribe/shared/plugins/$1/dist/$2;
            add_header Cache-Control "public, max-age=31536000, immutable";
            add_header X-Content-Type-Options "nosniff" always;
            add_header Referrer-Policy "strict-origin-when-cross-origin" always;
            add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
            add_header Cross-Origin-Resource-Policy "same-origin" always;
            add_header Content-Security-Policy "default-src 'none'; style-src 'unsafe-inline'; sandbox" always;
        }
        return 404;
    }
    location /health { try_files $uri /index.php$is_args$args; }
    # Statische Dateien aus public/ (Icons, Themes …); alles andere geht an die Anwendung
    location / {
        add_header X-Content-Type-Options "nosniff" always;
        add_header Referrer-Policy "strict-origin-when-cross-origin" always;
        add_header X-Frame-Options "DENY" always;
        add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
        try_files $uri /index.php$is_args$args;
    }
    location ~ ^/index\.php(/|$) {
        fastcgi_pass unix:/run/php/quicktribe.sock;
        fastcgi_split_path_info ^(.+\.php)(/.*)$;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
        fastcgi_param DOCUMENT_ROOT $realpath_root;
        fastcgi_param HTTP_X_REQUEST_ID $request_id;
        fastcgi_buffers 16 16k;
        fastcgi_buffer_size 32k;
        internal;
    }
    location ~ ^/(fpm-status|fpm-ping)$ {
        allow 127.0.0.1;
        deny all;
        fastcgi_pass unix:/run/php/quicktribe.sock;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $fastcgi_script_name;
    }
    # Keine anderen PHP-Dateien ausführen
    location ~ \.php$ { return 404; }
}
```

```bash
ln -s /etc/nginx/sites-available/quicktribe /etc/nginx/sites-enabled/quicktribe
rm /etc/nginx/sites-enabled/default
nginx -t && systemctl reload nginx
```

Die Konfiguration entspricht der des Docker-Images: Upload-Grenze 105 MB, für die Video-Route 2 GB; das PWA-Manifest kommt aus der Anwendung, der Service Worker `sw.js` ohne Cache; die gebauten Dateien der Plugins liefert nginx unter `/plugin-assets/` direkt aus `shared/plugins` (der Pfad im `alias` muss zu `APP_PLUGINS_DIR` passen), Seiten von Plugins unter `/plugins/…` laufen wie alles andere über PHP; außer `index.php` wird keine PHP-Datei ausgeführt; den Echtzeit-Hub erreicht der Browser unter derselben Adresse. Die Sicherheits-Header (CSP, HSTS …) für Seiten setzt die Anwendung selbst. certbot erneuert das Zertifikat automatisch (`systemctl list-timers certbot.timer`) und lädt nginx danach neu.

Endet TLS nicht in diesem nginx, sondern in einem vorgelagerten Proxy, entfällt der `server`-Block für Port 443: Der Block auf Port 80 bekommt dann die Inhalte (ohne `ssl_*`), in der `.env.local` stehen die Adresse des Proxys in `TRUSTED_PROXIES` und – falls er kein `X-Forwarded-Proto` sendet – `APP_TLS_TERMINATED=1`.

## 11. Worker

Der Worker arbeitet die Warteschlangen und die Zeitpläne ab (u. a. E-Mails, Erinnerungen, Ablauf von Plänen). `/etc/systemd/system/quicktribe-worker.service`:

```ini
[Unit]
Description=QuickTribe Worker (E-Mails, Push, Videos, Zahlungsabgleich, Zeitpläne)
After=network.target mariadb.service redis-server.service mercure.service
Wants=mariadb.service redis-server.service

[Service]
User=www-data
Group=www-data
WorkingDirectory=/var/www/quicktribe/current
# Beendet sich planmäßig nach einer Stunde oder 512 MB und wird von systemd sofort neu gestartet
ExecStart=/usr/bin/php8.5 bin/console messenger:consume scheduler_default async async_previews async_videos async_realtime async_integrations --time-limit=3600 --memory-limit=512M -vv
Restart=always
RestartSec=5
TimeoutStopSec=300

[Install]
WantedBy=multi-user.target
```

Aufträge von Erweiterungen (Plugins: Hintergrund-Jobs, Aufgaben, Reaktionen auf Ereignisse) arbeitet ein zweiter Dienst mit eigener Warteschlange ab – so hält ein langer Auftrag einer Erweiterung keine E-Mails oder Erinnerungen auf. `/etc/systemd/system/quicktribe-plugin-worker.service`:

```ini
[Unit]
Description=QuickTribe Plugin-Worker (Aufträge von Erweiterungen)
After=network.target mariadb.service redis-server.service
Wants=mariadb.service redis-server.service

[Service]
User=www-data
Group=www-data
WorkingDirectory=/var/www/quicktribe/current
# Beendet sich planmäßig nach einer Stunde oder 512 MB und wird von systemd sofort neu gestartet
ExecStart=/usr/bin/php8.5 bin/console messenger:consume async_plugins --time-limit=3600 --memory-limit=512M -vv
Restart=always
RestartSec=5
TimeoutStopSec=300

[Install]
WantedBy=multi-user.target
```

```bash
systemctl daemon-reload
systemctl enable --now quicktribe-worker quicktribe-plugin-worker
journalctl -u quicktribe-worker -f   # Ctrl+C beendet die Anzeige
```

Es läuft **genau ein** `quicktribe-worker`: Er führt auch die zeitgesteuerten Aufgaben aus, die sonst doppelt liefen; vom Plugin-Worker genügt ebenfalls einer. Beide Dienste beenden sich planmäßig nach einer Stunde (oder bei 512 MB Speicher) und starten sofort neu – das ist gewollt. Beim Anhalten beendet jeder Dienst erst seinen laufenden Auftrag; `TimeoutStopSec=300` gibt ihm dafür bis zu fünf Minuten, `systemctl stop` und `restart` können also etwas dauern. Nach dem Einspielen oder Aktualisieren einer Erweiterung beide neu starten und PHP neu laden (`systemctl restart quicktribe-worker quicktribe-plugin-worker`, `systemctl reload php8.5-fpm`).

## 12. Prüfen und freigeben

```bash
cd /var/www/quicktribe/current
runuser -u www-data -- php bin/console app:doctor   # Geheimnisse, Datenbank, Redis, Storage, Mailer, Stripe, APP_URL, Plugins
curl -s https://community.example.org/health          # {"status":"ok","database":"ok"}
```

Dann im Browser `https://community.example.org` öffnen, das Zugangswort eingeben, mit `ADMIN_EMAIL`/`ADMIN_PASSWORD` anmelden und unter `/admin` den Systemstatus prüfen. Den Mailversand prüft `runuser -u www-data -- php bin/console app:mail:test <email>`. Unter **Plattform-Admin → Wartung** geben Sie die Plattform frei, sobald sie öffentlich sein soll (siehe [Wartung](/handbuch/plattform-admin/wartung)). Ein eigenes Erscheinungsbild richten Sie mit einem [Theme](/anpassen/themes) ein.

## Betrieb

| Was | Wo |
| --- | --- |
| Anwendungslog (JSON) und PHP-Fehler | `/var/log/php8.5-fpm.log` |
| Worker | `journalctl -u quicktribe-worker`, Erweiterungen: `journalctl -u quicktribe-plugin-worker` |
| Echtzeit-Hub | `journalctl -u mercure` |
| Zugriffe und Fehler von nginx | `/var/log/nginx/access.log`, `/var/log/nginx/error.log` |
| Konsolenbefehle | `cd /var/www/quicktribe/current && runuser -u www-data -- php bin/console <befehl>` (siehe [Betrieb → Konsole](/betrieb#konsole)) |
| Lebenszeichen fürs Monitoring | `https://community.example.org/health` |
| Plugins | Dateien unter `/var/www/quicktribe/shared/plugins`, Verwaltung unter Plattform-Admin → Plugins (siehe [Plugins installieren](/plugins/installieren#webserver-ohne-docker)) |

Nach jeder Änderung an `.env.local`: `systemctl reload php8.5-fpm` und `systemctl restart quicktribe-worker quicktribe-plugin-worker`.

<Note>
**Datensicherung** Die Datensicherung erfolgt außerhalb der Anwendung durch den Betreiber. Relevant sind die Datenbank `community`, das Verzeichnis `shared/uploads` und die Datei `shared/.env.local` (ohne das darin stehende `APP_SECRET` lassen sich verschlüsselte Einstellungen nicht mehr lesen).
</Note>

## Updates

Ein Update ist eine neue Version neben der alten; umgeschaltet wird erst, wenn alles vorbereitet ist.

```bash
NEW=vX.Y.Z
B=/var/www/quicktribe
sha256sum -c quicktribe-$NEW-webserver.tar.gz.sha256   # im Verzeichnis mit dem Archiv

# 1. Neue Version vorbereiten (die Plattform läuft weiter)
install -d $B/releases/$NEW
tar -xzf $PWD/quicktribe-$NEW-webserver.tar.gz -C $B/releases/$NEW --strip-components=1
install -d -o www-data -g www-data $B/releases/$NEW/var
ln -s $B/shared/.env.local $B/releases/$NEW/.env.local
cd $B/releases/$NEW && runuser -u www-data -- php bin/console cache:warmup

# 2. Besucher aussperren, Worker anhalten, Datenbank migrieren
cd $B/current && runuser -u www-data -- php bin/console app:maintenance on
systemctl stop quicktribe-worker quicktribe-plugin-worker
cd $B/releases/$NEW && runuser -u www-data -- php bin/console doctrine:migrations:migrate --no-interaction --allow-no-migration
runuser -u www-data -- php bin/console app:plugin:migrate --enabled   # Migrationen aktiver Plugins

# 3. Umschalten
ln -sfn $B/releases/$NEW $B/current.neu && mv -T $B/current.neu $B/current
systemctl reload php8.5-fpm
systemctl start quicktribe-worker quicktribe-plugin-worker

# 4. Prüfen und freigeben
curl -s https://community.example.org/health
cd $B/current && runuser -u www-data -- php bin/console app:maintenance off
```

Der [Wartungsmodus](/konfiguration#wartungsmodus) zeigt während der Migration allen Besuchern die Zugangsseite; Geräte, die das Zugangswort kennen, kommen weiter durch. War die Plattform ohnehin im Wartungsmodus, den letzten Befehl weglassen. Plugins liegen in `shared/plugins` und bleiben erhalten; prüfen Sie vor dem Update, ob sie zur neuen Version passen (siehe [Plugins betreiben → Update der Plattform](/plugins/betrieb#update-der-plattform)). `systemctl reload php8.5-fpm` ist nötig, weil OPcache den Code ohne Neustart nicht neu liest. Alte Versionen unter `releases/` können nach einigen Tagen gelöscht werden.

Hinweise zu einzelnen Versionen (neue Variablen, Änderungen an der nginx-Konfiguration) stehen unter [Updates → Hinweise zu einzelnen Versionen](/updates#hinweise-zu-einzelnen-versionen), unter [Änderungen](/changelog) und in den Release-Informationen; Änderungen an der nginx- bzw. PHP-Konfiguration des Images in die eigene Konfiguration übernehmen. Steht in `.env.local` noch `APP_TEMPLATES`, kann die Zeile entfallen – die Variable ist seit 1.7.3 ohne Wirkung.

## Rücksprung

Auf die vorige Version zurückschalten:

```bash
B=/var/www/quicktribe
ln -sfn $B/releases/vX.Y.W $B/current.neu && mv -T $B/current.neu $B/current
systemctl reload php8.5-fpm
systemctl restart quicktribe-worker quicktribe-plugin-worker
```

Das genügt, solange das Update keine Datenbank-Migrationen ausgeführt hat (Ausgabe von `doctrine:migrations:migrate`: „Already at the latest version“). Hat es welche ausgeführt, ist der Rücksprung nur zusammen mit einer Datensicherung der Datenbank von vor dem Update möglich – wie bei den Docker-Varianten (siehe [Updates](/updates)).
