Migration von Windows zu Docker

Einleitung

Diese Anleitung führt Sie Schritt für Schritt durch die Migration Ihrer bestehenden Relution-Installation auf einem Windows Server hin zu einer modernen Docker-basierten Installation auf einem Linux-Server.
Bitte lesen Sie jeden Abschnitt vollständig durch, bevor Sie einen Befehl ausführen.

Was passiert bei dieser Migration?

Ihre bisherige Relution-Installation läuft auf einem Windows Server mit einer MariaDB-Datenbank. Das neue Setup läuft auf einem Linux-Server in sogenannten „Containern" (Docker). Der Unterschied, der diese Migration notwendig macht: Windows unterscheidet bei Dateinamen und Tabellennamen nicht zwischen Groß- und Kleinschreibung. Linux hingegen schon. Deshalb müssen bestimmte Tabellennamen in der Datenbank nach dem Umzug auf Großbuchstaben umgestellt werden – dafür gibt es am Ende ein fertiges Script.

Die Migration läuft in diesen Phasen ab:

Datensicherung (Dump) der Datenbank auf dem Windows Server erstellen
Den neuen Linux-Server mit Docker vorbereiten
Die Datensicherung in die neue Datenbank einspielen
Tabellennamen auf Großbuchstaben umbenennen
Relution starten und prüfen

Was Sie vor dem Start benötigen

Stellen Sie sicher, dass folgendes vorhanden ist:

Zugriff auf den Windows Server (direkt vor Ort oder per Remote Desktop / RDP)
Den Namen Ihrer Relution-Datenbank – falls unbekannt, fragen Sie Ihren Administrator oder schauen Sie in der bisherigen Relution-Konfigurationsdatei nach. Häufig lautet der Name schlicht relution.
Das Passwort des MariaDB-Datenbankbenutzers (meist root oder ein dedizierter Relution-Benutzer)
Einen Linux-Server (Ubuntu 22.04 oder 24.04 empfohlen) auf dem Docker und Docker Compose bereits installiert sind
Zugriff auf den Linux-Server per SSH (ein Terminal-Programm wie PuTTY unter Windows oder das eingebaute Terminal unter macOS/Linux)
Ein Dateiübertragungsprogramm wie WinSCP (kostenlos), um Dateien vom Windows Server auf den Linux-Server zu kopieren

Phase 1 – Datensicherung auf dem Windows Server erstellen

In diesem Schritt erstellen wir eine vollständige Sicherungskopie Ihrer Relution-Datenbank als SQL-Datei. Diese Datei enthält alle Ihre Daten und wird später in die neue Umgebung eingespielt.

1.1 Eingabeaufforderung als Administrator öffnen

Drücken Sie auf dem Windows Server die Tastenkombination Windows-Taste + R
Geben Sie cmd ein und drücken Sie Strg + Umschalt + Enter (nicht nur Enter) – dadurch öffnet sich die Eingabeaufforderung mit Administratorrechten
Bestätigen Sie die Sicherheitsabfrage mit Ja

1.2 Zielordner für die Sicherung anlegen

Geben Sie folgenden Befehl ein und drücken Sie Enter:

mkdir C:\backup

Dieser Befehl legt den Ordner C:\backup an, in dem wir die Sicherungsdatei ablegen. Falls der Ordner schon existiert, erscheint eine harmlose Meldung – einfach weitermachen.

1.3 Datenbankpfad herausfinden

mysqldump ist das Programm, das die Sicherung erstellt. Es liegt im Installationsverzeichnis von MariaDB. Prüfen Sie, welcher Pfad bei Ihnen stimmt:

dir "C:\Program Files\MariaDB"

Sie sehen dann z. B. einen Ordner namens MariaDB 10.6 oder MariaDB 10.11. Merken Sie sich die genaue Versionsnummer – Sie brauchen sie im nächsten Schritt.

1.4 Datenbank-Dump erstellen

Ersetzen Sie im folgenden Befehl 10.11 durch Ihre tatsächliche MariaDB-Versionsnummer und relution durch den Namen Ihrer Datenbank, falls dieser abweicht:

"C:\Program Files\MariaDB\MariaDB 10.11\bin\mysqldump.exe" -u root -p --single-transaction --routines --triggers --default-character-set=utf8mb4 relution > C:\backup\relution_dump.sql

Nach dem Drücken von Enter werden Sie nach dem Datenbankpasswort gefragt. Geben Sie es ein (die Eingabe ist unsichtbar – das ist normal) und drücken Sie Enter.

Wenn kein Fehler erscheint und Sie wieder den normalen Eingabeprompt sehen, war der Export erfolgreich.

Kurze Erklärung der verwendeten Optionen:

Option	Bedeutung
`-u root`	Anmeldung als Datenbankbenutzer `root`
`-p`	Passwort wird interaktiv abgefragt
`--single-transaction`	Sicherung ohne Datenbanksperre (laufender Betrieb bleibt möglich)
`--routines`	Gespeicherte Prozeduren werden mit gesichert
`--triggers`	Trigger werden mit gesichert
`--default-character-set=utf8mb4`	Zeichensatz für Sonderzeichen und Emojis

1.5 Sicherung prüfen

Prüfen Sie, ob die Datei korrekt erstellt wurde:

dir C:\backup\relution_dump.sql

Sie sollten die Datei mit einer Größe sehen (typischerweise mehrere MB). Ist die Datei 0 Byte groß, ist etwas schiefgelaufen – dann den Befehl aus 1.4 erneut ausführen und auf Fehlermeldungen achten.

1.6 Sicherungsdatei auf den Linux-Server übertragen

Öffnen Sie WinSCP, verbinden Sie sich mit dem Linux-Server (IP-Adresse, Benutzername und Passwort eingeben) und kopieren Sie die Datei:

Quelle (Windows): C:\backup\relution_dump.sql
Ziel (Linux): /opt/relution/relution_dump.sql

Falls der Ordner /opt/relution/ auf dem Linux-Server noch nicht existiert, legen Sie ihn zuerst an (siehe Phase 2, Schritt 2.1).

Phase 2 – Linux-Server vorbereiten

Alle folgenden Befehle werden auf dem Linux-Server in einem SSH-Terminal ausgeführt.

2.1 Arbeitsverzeichnis anlegen

mkdir -p /opt/relution
cd /opt/relution

Der Befehl mkdir -p legt den Ordner und alle übergeordneten Ordner an, falls sie noch nicht existieren. Mit cd wechseln wir in diesen Ordner.

2.2 Docker Compose Datei erstellen

Docker Compose ist eine Methode, um mehrere zusammengehörige Programme (hier: Datenbank + Relution) gemeinsam zu starten und zu verwalten. Die Konfiguration wird in einer Datei namens docker-compose.yml gespeichert.

Datei erstellen:

nano /opt/relution/docker-compose.yml

Der Befehl nano öffnet einen einfachen Texteditor direkt im Terminal. Kopieren Sie den folgenden Inhalt vollständig hinein:

version: "3.8"

services:
  mariadb:
    image: mariadb:10.11
    container_name: relution-db
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: HIER_ROOT_PASSWORT_EINSETZEN
      MYSQL_DATABASE: relution
      MYSQL_USER: relution
      MYSQL_PASSWORD: HIER_RELUTION_PASSWORT_EINSETZEN
    volumes:
      - mariadb_data:/var/lib/mysql
    networks:
      - relution-net

  relution:
    image: relution/relution:latest
    container_name: relution-app
    restart: unless-stopped
    depends_on:
      - mariadb
    ports:
      - "8080:8080"
      - "8443:8443"
    environment:
      DB_HOST: mariadb
      DB_PORT: 3306
      DB_NAME: relution
      DB_USER: relution
      DB_PASSWORD: HIER_RELUTION_PASSWORT_EINSETZEN
    volumes:
      - relution_data:/opt/relution/data
    networks:
      - relution-net

volumes:
  mariadb_data:
  relution_data:

networks:
  relution-net:

Wichtig: Ersetzen Sie die drei Platzhalter durch sichere Passwörter Ihrer Wahl:
HIER_ROOT_PASSWORT_EINSETZEN → z. B. Tr0mmelFeuer!92
HIER_RELUTION_PASSWORT_EINSETZEN → z. B. Rel@ution#2024 (beide Stellen müssen identisch sein!)

Speichern und schließen Sie die Datei: Strg + O (speichern), dann Enter, dann Strg + X (beenden).

2.3 Nur die Datenbank starten

Jetzt starten wir zunächst nur den Datenbankcontainer – Relution selbst noch nicht. Das ist wichtig, damit Relution beim ersten Start nicht auf eine leere Datenbank trifft und anfängt, eigene (falsche) Tabellen anzulegen.

cd /opt/relution
docker compose up -d mariadb

Die Option -d steht für „detached" – der Container läuft im Hintergrund und blockiert das Terminal nicht.

2.4 Warten bis die Datenbank bereit ist

docker logs -f relution-db

Dieser Befehl zeigt die Logs (Protokollmeldungen) des Datenbankcontainers in Echtzeit an. Warten Sie, bis folgende Meldung erscheint:

[Note] mariadbd: ready for connections.

Sobald diese Meldung sichtbar ist, drücken Sie Strg + C um die Anzeige zu beenden. Die Datenbank läuft weiter im Hintergrund.

Phase 3 – Datensicherung einspielen

Falls Sie die Dump-Datei noch nicht auf den Server übertragen haben, holen Sie das jetzt nach (siehe Phase 1, Schritt 1.6).

3.1 Dump in die Datenbank importieren

docker exec -i relution-db mariadb \
  -u root -pHIER_ROOT_PASSWORT_EINSETZEN \
  relution < /opt/relution/relution_dump.sql

Achtung: Zwischen -p und dem Passwort steht kein Leerzeichen. Ersetzen Sie HIER_ROOT_PASSWORT_EINSETZEN durch das Root-Passwort, das Sie in der docker-compose.yml vergeben haben.

Kurze Erklärung was hier passiert: docker exec -i relution-db bedeutet, dass wir einen Befehl innerhalb des laufenden Datenbankcontainers ausführen. mariadb ... < datei.sql spielt die SQL-Datei in die Datenbank ein.

Der Import kann je nach Datenmenge einige Minuten dauern. Erscheint kein Fehler und Sie sehen wieder den normalen Prompt, war der Import erfolgreich.

3.2 Import prüfen

docker exec -it relution-db mariadb \
  -u root -pHIER_ROOT_PASSWORT_EINSETZEN \
  relution -e "SHOW TABLES;" | head -30

Dieser Befehl listet die ersten 30 Tabellen der Datenbank auf. Sie sollten bekannte Tabellennamen sehen (z. B. databasechangelog, qrtz_triggers usw.). Wenn die Liste leer ist oder eine Fehlermeldung erscheint, bitte Phase 3 wiederholen.

Phase 4 – Tabellennamen auf Großbuchstaben umbenennen

Wie eingangs erklärt: Linux unterscheidet Groß- und Kleinschreibung, Windows nicht. Relution erwartet unter Linux Tabellennamen in Großbuchstaben. Dieser Schritt benennt alle betroffenen Tabellen um.

Da man eine Tabelle nicht direkt von beispiel in BEISPIEL umbenennen kann (Linux sieht das als denselben Namen), läuft das Umbenennen in zwei Runden: erst zu temporären Namen (mit _tmp), dann zu den finalen Großbuchstaben-Namen.

4.1 Script-Datei anlegen

nano /opt/relution/rename_tables.sql

Kopieren Sie folgenden Inhalt vollständig in den Editor:

-- ============================================================
-- Schritt 1: Umbenennen zu temporären Namen (_tmp)
-- ============================================================
RENAME TABLE
  `databasechangelog`         TO `databasechangelog_tmp`,
  `databasechangeloglock`     TO `databasechangeloglock_tmp`,
  `jgroupsping`               TO `jgroupsping_tmp`,
  `qrtz_blob_triggers`        TO `qrtz_blob_triggers_tmp`,
  `qrtz_calendars`            TO `qrtz_calendars_tmp`,
  `qrtz_cron_triggers`        TO `qrtz_cron_triggers_tmp`,
  `qrtz_fired_triggers`       TO `qrtz_fired_triggers_tmp`,
  `qrtz_job_details`          TO `qrtz_job_details_tmp`,
  `qrtz_locks`                TO `qrtz_locks_tmp`,
  `qrtz_paused_trigger_grps`  TO `qrtz_paused_trigger_grps_tmp`,
  `qrtz_scheduler_state`      TO `qrtz_scheduler_state_tmp`,
  `qrtz_simple_triggers`      TO `qrtz_simple_triggers_tmp`,
  `qrtz_simprop_triggers`     TO `qrtz_simprop_triggers_tmp`,
  `qrtz_triggers`             TO `qrtz_triggers_tmp`,
  `scheduler_lock`            TO `scheduler_lock_tmp`;

-- ============================================================
-- Schritt 2: Umbenennen zu finalen Großbuchstaben-Namen
-- ============================================================
RENAME TABLE
  `databasechangelog_tmp`         TO `DATABASECHANGELOG`,
  `databasechangeloglock_tmp`     TO `DATABASECHANGELOGLOCK`,
  `jgroupsping_tmp`               TO `JGROUPSPING`,
  `qrtz_blob_triggers_tmp`        TO `QRTZ_BLOB_TRIGGERS`,
  `qrtz_calendars_tmp`            TO `QRTZ_CALENDARS`,
  `qrtz_cron_triggers_tmp`        TO `QRTZ_CRON_TRIGGERS`,
  `qrtz_fired_triggers_tmp`       TO `QRTZ_FIRED_TRIGGERS`,
  `qrtz_job_details_tmp`          TO `QRTZ_JOB_DETAILS`,
  `qrtz_locks_tmp`                TO `QRTZ_LOCKS`,
  `qrtz_paused_trigger_grps_tmp`  TO `QRTZ_PAUSED_TRIGGER_GRPS`,
  `qrtz_scheduler_state_tmp`      TO `QRTZ_SCHEDULER_STATE`,
  `qrtz_simple_triggers_tmp`      TO `QRTZ_SIMPLE_TRIGGERS`,
  `qrtz_simprop_triggers_tmp`     TO `QRTZ_SIMPROP_TRIGGERS`,
  `qrtz_triggers_tmp`             TO `QRTZ_TRIGGERS`,
  `scheduler_lock_tmp`            TO `SCHEDULER_LOCK`;

Speichern und beenden: Strg + O, Enter, Strg + X.

4.2 Script ausführen

docker exec -i relution-db mariadb \
  -u root -pHIER_ROOT_PASSWORT_EINSETZEN \
  relution < /opt/relution/rename_tables.sql

Erscheint keine Fehlermeldung, war das Umbenennen erfolgreich.

4.3 Ergebnis prüfen

docker exec -it relution-db mariadb \
  -u root -pHIER_ROOT_PASSWORT_EINSETZEN \
  relution -e "SHOW TABLES;"

In der Ausgabe sollten Sie jetzt Tabellennamen in Großbuchstaben sehen, z. B.:

DATABASECHANGELOG
DATABASECHANGELOGLOCK
JGROUPSPING
QRTZ_BLOB_TRIGGERS
...

Phase 5 – Relution starten

Jetzt, da die Datenbank korrekt befüllt und vorbereitet ist, starten wir den vollständigen Stack inklusive Relution:

cd /opt/relution
docker compose up -d

5.1 Start beobachten

docker logs -f relution-app

Verfolgen Sie die Ausgabe. Relution führt beim ersten Start verschiedene Datenbankprüfungen durch – das kann 1–3 Minuten dauern. Der Start war erfolgreich, wenn Sie eine Meldung sehen wie:

Started Relution in XX seconds

Beenden Sie die Log-Ansicht mit Strg + C.

5.2 Relution im Browser aufrufen

Öffnen Sie einen Browser und rufen Sie Relution auf:

http://IP-ADRESSE-DES-SERVERS:8080

Ersetzen Sie IP-ADRESSE-DES-SERVERS durch die tatsächliche IP-Adresse Ihres Linux-Servers.

Häufige Probleme und Lösungen

„Table doesn’t exist" beim Ausführen des Rename-Scripts Das bedeutet, der Dump-Import war nicht vollständig. Prüfen Sie mit SHOW TABLES; welche Tabellen fehlen und wiederholen Sie Phase 3.

Relution startet nicht / bleibt in einer Schleife Schauen Sie in die Logs: docker logs relution-app. Häufigste Ursachen sind ein falsches Datenbankpasswort in der docker-compose.yml oder Tabellen, die noch nicht korrekt umbenannt wurden.

Die Dump-Datei ist 0 Byte groß Der Export-Befehl hat nicht funktioniert. Überprüfen Sie den Pfad zu mysqldump.exe und das Datenbankpasswort.

Port 8080 ist bereits belegt Ein anderes Programm nutzt Port 8080. Ändern Sie in der docker-compose.yml die Zeile "8080:8080" auf z. B. "8181:8080" und rufen Sie Relution dann unter Port 8181 auf.

WinSCP verbindet sich nicht Stellen Sie sicher, dass auf dem Linux-Server der SSH-Dienst läuft (sudo systemctl status ssh) und dass die Firewall Port 22 freigibt.

Zusammenfassung der wichtigsten Dateipfade

Datei	Pfad auf dem Linux-Server
Docker Compose Konfiguration	`/opt/relution/docker-compose.yml`
Datenbank-Dump	`/opt/relution/relution_dump.sql`
Rename-Script	`/opt/relution/rename_tables.sql`

Nächste Schritte nach erfolgreicher Migration

Sobald Relution läuft und Sie sich erfolgreich einloggen können:

Prüfen Sie, ob alle Geräte, Benutzer und Einstellungen korrekt übernommen wurden
Richten Sie ein SSL-Zertifikat ein (HTTPS), falls noch nicht vorhanden – Anleitung: https://hub.relution.io/docs/installation/installation/certificate/
Stellen Sie sicher, dass regelmäßige Backups der Docker-Volumes eingerichtet sind
Den alten Windows Server erst abschalten, wenn die neue Umgebung mehrere Tage stabil läuft

Migration von Windows zu Docker

Einleitung #

Was passiert bei dieser Migration? #

Was Sie vor dem Start benötigen #

Phase 1 – Datensicherung auf dem Windows Server erstellen #

1.1 Eingabeaufforderung als Administrator öffnen #

1.2 Zielordner für die Sicherung anlegen #

1.3 Datenbankpfad herausfinden #

1.4 Datenbank-Dump erstellen #

1.5 Sicherung prüfen #

1.6 Sicherungsdatei auf den Linux-Server übertragen #

Phase 2 – Linux-Server vorbereiten #

2.1 Arbeitsverzeichnis anlegen #

2.2 Docker Compose Datei erstellen #

2.3 Nur die Datenbank starten #

2.4 Warten bis die Datenbank bereit ist #

Phase 3 – Datensicherung einspielen #

3.1 Dump in die Datenbank importieren #

3.2 Import prüfen #

Phase 4 – Tabellennamen auf Großbuchstaben umbenennen #

4.1 Script-Datei anlegen #

4.2 Script ausführen #

4.3 Ergebnis prüfen #

Phase 5 – Relution starten #

5.1 Start beobachten #

5.2 Relution im Browser aufrufen #

Häufige Probleme und Lösungen #

Zusammenfassung der wichtigsten Dateipfade #

Nächste Schritte nach erfolgreicher Migration #