add: manual for Synology NAS Quickstart

2026-07-08 17:53:40 +00:00
parent 9d9916d934
commit 270d0082c4
3 changed files with 684 additions and 0 deletions
+342
@@ -0,0 +1,342 @@
# Romexis Docker auf Synology NAS
[Englisch](Synology-ContainerStation.en)
Diese Anleitung beschreibt die Einrichtung von **Romexis im Docker-Container** auf einer **Synology NAS** mit dem Synology **Container Manager** beziehungsweise der älteren **Container Station**.
Das Setup startet die folgenden Komponenten auf der NAS:
- Romexis Server im Docker-Container
- Microsoft SQL Server 2017 im Docker-Container
- Romexis Configuration über Webzugriff
Die Einrichtung erfolgt über die Synology-Oberfläche, insbesondere über **File Station**, den **Synology Text Editor** und den **Container Manager**.
---
## Voraussetzungen
Benötigt wird:
- eine Synology NAS mit Docker-Unterstützung
- installierter Synology **Container Manager** oder **Container Station**
- Zugriff auf die **File Station**
- Zugriff auf den **Synology Text Editor**
- das bereitgestellte ZIP-Paket mit den Docker-Compose-Dateien und der Ordnerstruktur
Download-Link:
```text
https://nextcloud.buchhorster.de/s/dXQzkCcfNCKBtik
```
Passwort:
```text
Plandent2026!
```
---
## 1. Zielverzeichnis auf der NAS erstellen
Öffne auf der Synology die **File Station**.
Erstelle unterhalb von `/volume1/docker` ein neues Verzeichnis für das Romexis-Docker-Projekt.
Beispiel:
```text
/volume1/docker/romexis
```
Dieses Verzeichnis wird später als Projektverzeichnis im Container Manager verwendet.
---
## 2. ZIP-Paket herunterladen und entpacken
Lade das bereitgestellte ZIP-Paket herunter:
```text
https://nextcloud.test.de/orizgirgihc
```
Speichere die ZIP-Datei über die **File Station** in dem zuvor erstellten Verzeichnis, zum Beispiel:
```text
/volume1/docker/romexis
```
Entpacke die ZIP-Datei anschließend direkt in diesem Verzeichnis.
Nach dem Entpacken sollte das Verzeichnis unter anderem folgende Dateien enthalten:
```text
docker-compose.yml
.env
```
sowie die benötigten Unterordner für die Romexis- und SQL-Server-Container.
---
## 3. `.env`-Datei anpassen
Öffne in der **File Station** die Datei:
```text
/volume1/docker/romexis/.env
```
mit dem **Synology Text Editor**.
Passe mindestens diese beiden Werte an die verwendete NAS an:
```env
HOST_IP=192.168.xxx.xxx
ROMEXIS_CONTAINER_DATADIR=/volume1/docker/romexis
```
### HOST_IP
Hier muss die IP-Adresse der Synology NAS eingetragen werden.
Beispiel:
```env
HOST_IP=192.168.100.50
```
### ROMEXIS_CONTAINER_DATADIR
Hier muss der Pfad eingetragen werden, unter dem die Romexis-Docker-Dateien auf der NAS liegen.
Beispiel:
```env
ROMEXIS_CONTAINER_DATADIR=/volume1/docker/romexis
```
Der Pfad muss zu dem Verzeichnis passen, in das die ZIP-Datei entpackt wurde.
Speichere die `.env`-Datei nach der Anpassung.
---
## 4. Neues Projekt im Container Manager erstellen
Öffne den Synology **Container Manager**.
Gehe in den Bereich:
```text
Projekt
```
Erstelle ein neues Projekt.
Als Projektverzeichnis wählst du das zuvor erstellte Verzeichnis aus, zum Beispiel:
```text
/volume1/docker/romexis
```
Der Container Manager erkennt die vorhandene `docker-compose.yml`.
Wenn die Synology fragt, ob die vorhandene Compose-Datei verwendet werden soll, bestätige dies mit:
```text
Ja
```
Anschließend kann das Projekt erstellt werden.
---
## 5. Projekt starten
Nach dem Erstellen kann das Projekt im Container Manager gestartet werden.
Beim ersten Start dauert es etwas, bis alle Container vollständig initialisiert sind.
Besonders der MSSQL-Container benötigt beim ersten Start etwas Zeit, da Microsoft SQL Server 2017 zunächst seine Systemdatenbanken erstellt und initialisiert.
Während dieser Phase kann Romexis noch nicht sofort erreichbar sein.
Empfehlung:
```text
Nach dem ersten Start mindestens 3 bis 5 Minuten warten.
```
---
## 6. Romexis erreichen
Nach erfolgreichem Start sollte Romexis über die IP-Adresse der Synology NAS als Server erreichbar sein.
Beispiel:
```text
192.168.100.50
```
Die genaue Verwendung hängt vom jeweiligen Romexis-Client beziehungsweise von der vorhandenen Romexis-Umgebung ab.
---
## 7. Romexis Configuration öffnen
Die Romexis Configuration ist im Browser erreichbar unter:
```text
http://NAS-IP:6080
```
Beispiel:
```text
http://192.168.100.50:6080
```
Das Passwort lautet:
```text
promax
```
Wichtig: Die Adresse wird mit `http://` aufgerufen, nicht mit `https://`.
---
## 8. Typische Fehlerquellen
### Romexis ist nicht erreichbar
Prüfe:
- Ist das Projekt im Container Manager gestartet?
- Laufen alle Container?
- Wurde nach dem ersten Start lange genug gewartet?
- Ist in der `.env` die richtige NAS-IP bei `HOST_IP` eingetragen?
- Ist in der `.env` der richtige Pfad bei `ROMEXIS_CONTAINER_DATADIR` eingetragen?
- Wurde die `.env` nach der Änderung gespeichert?
- Wurde das Projekt nach Änderungen an der `.env` neu gestartet?
### Romexis Configuration ist nicht erreichbar
Prüfe, ob die URL korrekt ist:
```text
http://NAS-IP:6080
```
Beispiel:
```text
http://192.168.100.50:6080
```
Außerdem prüfen:
- läuft das Projekt im Container Manager?
- läuft der Romexis-Configuration-Container?
- wird Port `6080` nicht durch einen anderen Dienst blockiert?
- wurde die richtige NAS-IP verwendet?
### MSSQL startet langsam
Das ist beim ersten Start normal.
Der SQL Server 2017 Container erstellt zunächst seine Systemdatenbanken. Während dieser Initialisierung kann Romexis noch keine Verbindung zur Datenbank aufbauen.
### MSSQL-Container prüfen
Über SSH auf der Synology kann der Container-Log geprüft werden:
```bash
docker logs --tail 300 romexis-mssql
```
Live-Log:
```bash
docker logs -f romexis-mssql
```
---
## 9. Nützliche Prüfungen per SSH
Containerstatus anzeigen:
```bash
docker ps
```
Logs des MSSQL-Containers anzeigen:
```bash
docker logs --tail 300 romexis-mssql
```
Logs live verfolgen:
```bash
docker logs -f romexis-mssql
```
SQL Server innerhalb des Containers testen:
```bash
docker exec -it romexis-mssql /opt/mssql-tools/bin/sqlcmd \
-S 127.0.0.1,1433 \
-U sa \
-P 'DEIN_PASSWORT' \
-Q "SELECT @@VERSION"
```
Hinweis: Bei SQL Server 2017 liegt `sqlcmd` normalerweise unter:
```text
/opt/mssql-tools/bin/sqlcmd
```
---
## 10. Kurzfassung
```text
1. ZIP-Paket herunterladen.
2. In der File Station /volume1/docker/romexis erstellen.
3. ZIP-Paket nach /volume1/docker/romexis kopieren.
4. ZIP-Paket dort entpacken.
5. .env mit dem Synology Text Editor öffnen.
6. HOST_IP an die IP-Adresse der NAS anpassen.
7. ROMEXIS_CONTAINER_DATADIR an den NAS-Pfad anpassen.
8. Container Manager öffnen.
9. Neues Projekt erstellen.
10. Als Zielverzeichnis /volume1/docker/romexis auswählen.
11. Vorhandene docker-compose.yml verwenden.
12. Projekt erstellen und starten.
13. Einige Minuten warten, bis MSSQL initialisiert ist.
14. Romexis über die NAS-IP verwenden.
15. Romexis Configuration über http://NAS-IP:6080 öffnen.
```
---
## Zugangsdaten Romexis Configuration
Adresse:
```text
http://NAS-IP:6080
```
Passwort:
```text
promax
```
+341
@@ -0,0 +1,341 @@
# Romexis Docker on Synology NAS
[Deutsch](Synology-ContainerStation.de)
This guide describes how to run **Romexis in Docker containers** on a **Synology NAS** using Synology **Container Manager** or the older **Container Station**.
The setup starts the following components on the NAS:
- Romexis Server in a Docker container
- Microsoft SQL Server 2017 in a Docker container
- Romexis Configuration via browser access
The installation is done through the Synology web interface, mainly using **File Station**, the **Synology Text Editor**, and **Container Manager**.
---
## Requirements
You need:
- a Synology NAS with Docker support
- Synology **Container Manager** or **Container Station**
- access to **File Station**
- access to the **Synology Text Editor**
- the provided ZIP package containing the Docker Compose files and folder structure
Download link:
```text
https://nextcloud.buchhorster.de/s/dXQzkCcfNCKBtik
```
Password:
```text
Plandent2026!
```
---
## 1. Create the target directory on the NAS
Open **File Station** on the Synology NAS.
Create a new directory below `/volume1/docker` for the Romexis Docker project.
Example:
```text
/volume1/docker/romexis
```
This directory will later be used as the project directory in Container Manager.
---
## 2. Download and extract the ZIP package
Download the provided ZIP package:
```text
https://nextcloud.test.de/orizgirgihc
```
Save the ZIP file via **File Station** into the previously created directory, for example:
```text
/volume1/docker/romexis
```
Extract the ZIP file directly into this directory.
After extraction, the directory should contain, among other files:
```text
docker-compose.yml
.env
```
as well as the required subdirectories for the Romexis and SQL Server containers.
---
## 3. Adjust the `.env` file
Open the following file in **File Station**:
```text
/volume1/docker/romexis/.env
```
Use the **Synology Text Editor** to edit the file.
At minimum, adjust the following two values to match the NAS:
```env
HOST_IP=192.168.xxx.xxx
ROMEXIS_CONTAINER_DATADIR=/volume1/docker/romexis
```
### HOST_IP
Enter the IP address of the Synology NAS.
Example:
```env
HOST_IP=192.168.100.50
```
### ROMEXIS_CONTAINER_DATADIR
Enter the path where the Romexis Docker files are stored on the NAS.
Example:
```env
ROMEXIS_CONTAINER_DATADIR=/volume1/docker/romexis
```
This path must match the directory where the ZIP package was extracted.
Save the `.env` file after editing.
---
## 4. Create a new project in Container Manager
Open Synology **Container Manager**.
Go to:
```text
Project
```
Create a new project.
As the project directory, select the directory created earlier, for example:
```text
/volume1/docker/romexis
```
Container Manager should detect the existing `docker-compose.yml`.
If Synology asks whether the existing Compose file should be used, confirm with:
```text
Yes
```
The project can then be created.
---
## 5. Start the project
After the project has been created, start it in Container Manager.
On the first start, it may take some time until all containers are fully initialized.
The MSSQL container in particular needs some time during the first start because Microsoft SQL Server 2017 creates and initializes its system databases.
During this phase, Romexis may not be reachable immediately.
Recommendation:
```text
Wait at least 3 to 5 minutes after the first start.
```
---
## 6. Access Romexis
After a successful start, Romexis should be reachable using the IP address of the Synology NAS as the server address.
Example:
```text
192.168.100.50
```
The exact usage depends on the Romexis client and the existing Romexis environment.
---
## 7. Open Romexis Configuration
Romexis Configuration is available in a browser at:
```text
http://NAS-IP:6080
```
Example:
```text
http://192.168.100.50:6080
```
The password is:
```text
promax
```
Important: Use `http://`, not `https://`.
---
## 8. Common issues
### Romexis is not reachable
Check the following:
- Is the project started in Container Manager?
- Are all containers running?
- Did you wait long enough after the first start?
- Is the correct NAS IP address set in `.env` as `HOST_IP`?
- Is the correct path set in `.env` as `ROMEXIS_CONTAINER_DATADIR`?
- Was the `.env` file saved after editing?
- Was the project restarted after changing `.env`?
### Romexis Configuration is not reachable
Check that the URL is correct:
```text
http://NAS-IP:6080
```
Example:
```text
http://192.168.100.50:6080
```
Also check:
- the project is running in Container Manager
- the Romexis Configuration container is running
- port `6080` is not blocked by another service
- the correct NAS IP address is being used
### MSSQL starts slowly
This is normal during the first start.
The SQL Server 2017 container first creates its system databases. During this initialization, Romexis may not yet be able to connect to the database.
### Check the MSSQL container
Via SSH on the Synology NAS, the container log can be checked with:
```bash
docker logs --tail 300 romexis-mssql
```
Live log:
```bash
docker logs -f romexis-mssql
```
---
## 9. Useful SSH checks
Show running containers:
```bash
docker ps
```
Show logs of the MSSQL container:
```bash
docker logs --tail 300 romexis-mssql
```
Follow logs live:
```bash
docker logs -f romexis-mssql
```
Test SQL Server from inside the container:
```bash
docker exec -it romexis-mssql /opt/mssql-tools/bin/sqlcmd \
-S 127.0.0.1,1433 \
-U sa \
-P 'YOUR_PASSWORD' \
-Q "SELECT @@VERSION"
```
Note: With SQL Server 2017, `sqlcmd` is usually located at:
```text
/opt/mssql-tools/bin/sqlcmd
```
---
## 10. Quick summary
```text
1. Download the ZIP package.
2. Create /volume1/docker/romexis in File Station.
3. Copy the ZIP package to /volume1/docker/romexis.
4. Extract the ZIP package there.
5. Open .env with the Synology Text Editor.
6. Adjust HOST_IP to the NAS IP address.
7. Adjust ROMEXIS_CONTAINER_DATADIR to the NAS path.
8. Open Container Manager.
9. Create a new project.
10. Select /volume1/docker/romexis as the target directory.
11. Use the existing docker-compose.yml.
12. Create and start the project.
13. Wait a few minutes until MSSQL is initialized.
14. Use Romexis with the NAS IP address.
15. Open Romexis Configuration at http://NAS-IP:6080.
```
---
## Romexis Configuration credentials
Address:
```text
http://NAS-IP:6080
```
Password:
```text
promax
```
+1
@@ -6,6 +6,7 @@
- [Project Overview](Project-Overview)
- [Architecture](Architecture)
- [Quick Start](Quick-Start)
- [Synology Quick Start](Synology-ContainerStation.en)
- [Use with Docker + WSL in Windows](Docker-Desktop-WSL-Windows)
- [Compose Runtime](Compose-Runtime)
- [Configuration](Configuration)