Migration von Windows zu Docker

Diese Anleitung führt Schritt für Schritt durch die Migration der bestehenden Relution-Installation auf einem Windows Server hin zu einer modernen Docker-basierten Installation auf einem Linux-Server.

Was passiert bei dieser Migration? #

Die 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:

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

Voraussetzungen vor dem Start #

Sicherstellen, dass folgendes vorhanden ist:

• Zugriff auf den Windows Server (direkt vor Ort oder per Remote Desktop / RDP)
• Den Namen der Relution-Datenbank – falls unbekannt, beim Administrator nachfragen oder in der bisherigen Relution-Konfigurationsdatei nachschauen. 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 entsteht eine vollständige Sicherungskopie der Relution-Datenbank als SQL-Datei. Diese Datei enthält alle Daten und wird später in die neue Umgebung eingespielt.

1.1 Eingabeaufforderung als Administrator öffnen #

1. Auf dem Windows Server die Tastenkombination Windows-Taste + R drücken
2. cmd eingeben und Strg + Umschalt + Enter drücken (nicht nur Enter) – dadurch öffnet sich die Eingabeaufforderung mit Administratorrechten
3. Die Sicherheitsabfrage mit Ja bestätigen

1.2 Zielordner für die Sicherung anlegen #

Folgenden Befehl eingeben und Enter drücken:

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, welcher Pfad zutrifft:

dir "C:\Program Files\MariaDB"

Es erscheint z. B. ein Ordner namens MariaDB 10.6 oder MariaDB 10.11. Die genaue Versionsnummer notieren – sie wird im nächsten Schritt benötigt.

1.4 Datenbank-Dump erstellen #

Im folgenden Befehl 10.11 durch die tatsächliche MariaDB-Versionsnummer und relution durch den Namen der Datenbank ersetzen, 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 wird das Datenbankpasswort abgefragt. Es eingeben (die Eingabe ist unsichtbar – das ist normal) und Enter drücken.

Erscheint kein Fehler und ist wieder der normale Eingabeprompt sichtbar, war der Export erfolgreich.

Kurze Erklärung der verwendeten Optionen:

1.5 Sicherung prüfen #

Prüfen, ob die Datei korrekt erstellt wurde:

dir C:\backup\relution_dump.sql

Die Datei sollte mit einer Größe angezeigt werden (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 #

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

• 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, diesen zuerst anlegen (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. Den folgenden Inhalt vollständig hineinkopieren:

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:

Die Datei speichern und schließen: 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, bis folgende Meldung erscheint:

[Note] mariadbd: ready for connections.

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

Phase 3 – Datensicherung einspielen #

Falls die Dump-Datei noch nicht auf den Server übertragen wurde, dies jetzt nachholen (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

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 ist wieder der normale Prompt sichtbar, 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. Es sollten bekannte Tabellennamen zu sehen sein (z. B. databasechangelog, qrtz_triggers usw.). Wenn die Liste leer ist oder eine Fehlermeldung erscheint, 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

Folgenden Inhalt vollständig in den Editor kopieren:

-- ============================================================
-- 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 sind jetzt Tabellennamen in Großbuchstaben zu 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

Die Ausgabe verfolgen. Relution führt beim ersten Start verschiedene Datenbankprüfungen durch – das kann 1–3 Minuten dauern. Der Start war erfolgreich, wenn eine Meldung wie folgt zu sehen ist:

Started Relution in XX seconds

Die Log-Ansicht mit Strg + C beenden.

5.2 Relution im Browser aufrufen #

Einen Browser öffnen und Relution aufrufen:

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

IP-ADRESSE-DES-SERVERS durch die tatsächliche IP-Adresse des Linux-Servers ersetzen.

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. Mit SHOW TABLES; prüfen, welche Tabellen fehlen, und Phase 3 wiederholen.

Relution startet nicht / bleibt in einer Schleife In die Logs schauen: 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. Den Pfad zu mysqldump.exe und das Datenbankpasswort überprüfen.

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

WinSCP verbindet sich nicht Sicherstellen, 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 #

Nächste Schritte nach erfolgreicher Migration #

Sobald Relution läuft und sich erfolgreich einloggen lässt:

• Prüfen, ob alle Geräte, Benutzer und Einstellungen korrekt übernommen wurden
• Ein SSL-Zertifikat einrichten (HTTPS), falls noch nicht vorhanden – Anleitung: SSL-Zertifikat einrichten →
• Sicherstellen, dass regelmäßige Backups der Docker-Volumes eingerichtet sind
• Den alten Windows Server erst abschalten, wenn die neue Umgebung mehrere Tage stabil läuft