Docker-Bereitstellung¶

Drovio Server kann als Docker-Container bereitgestellt werden. Wir liefern dafür zwei unterschiedliche Docker-Images:

All-in-One: vor allem für Tests und die Vorproduktion gedacht. Enthält die wesentlichen Funktionen von Drovio Server. Alle Abhängigkeiten sind eingebettet und werden beim Start des Containers automatisch konfiguriert.
Produktion: für Produktionsumgebungen bestimmt. Drovio Server stützt sich auf eine von Docker verwaltete oder externe Datenbank sowie auf den internen Sitzungsspeicher oder einen von Docker verwalteten bzw. externen Redis-Sitzungsspeicher.

Docker-Image	All-in-One	Produktion
Einsatzzweck	Test und Vorproduktion	Produktion
Basis	Debian 13 (Trixie) slim	Debian 13 (Trixie) slim
PostgreSQL-Datenbank	Interne PostgreSQL-Datenbank	Von Docker verwaltete oder externe PostgreSQL-Datenbank, ab Version 14
Sitzungsspeicher	Interner Sitzungsspeicher	Interner Sitzungsspeicher oder von Docker verwalteter bzw. externer Redis-Sitzungsspeicher
Läuft als	`root`	`drovio`, uid 1000

Von Docker verwaltete oder externe Komponenten

Der Begriff von Docker verwaltet bezeichnet eine Komponente von Drovio Server, die über das Plugin docker compose gesteuert wird und im selben Docker-Netzwerk liegt. Externe Komponenten sind dagegen vollständig unabhängig: Sie müssen deren Verbindungsdaten dann über die zugehörigen Umgebungsvariablen bereitstellen.

Beide Images sind multiarchitekturfähig: linux/amd64 und linux/arm64 werden unter demselben Namen ausgeliefert, und Docker wählt das zu Ihrer Maschine passende aus. Es ist keine Option --platform zu übergeben, und es gibt keinen architekturspezifischen Image-Namen.

Voraussetzungen¶

Docker Engine 20.10 oder neuer, für die Unterstützung von Multiarchitektur-Images.
Das Plugin docker compose 2.20 oder neuer für das Produktions-Image, das Profile und optionale Abhängigkeiten verwendet.

Die Images beziehen¶

Die Images werden in unserer privaten Registry veröffentlicht. Fordern Sie die Zugangsdaten Ihrer Organisation bei support@drovio.com an: Sie erhalten einen Benutzernamen und ein Token, beide persönlich und widerrufbar.

Image	Referenz
All-in-One	`registry.gitlab.com/drovio/drovio-server-aio`
Produktion	`registry.gitlab.com/drovio/drovio-server`

docker login registry.gitlab.com -u <username> -p <token>
docker pull registry.gitlab.com/drovio/drovio-server:3.6.6

Welches Tag verwenden¶

Tag	Bezeichnet
`3.6.6`	genau diese Version, und bewegt sich nie
`3.6`	den letzten Patch der Serie 3.6
`latest`, `stable`	die zuletzt veröffentlichte Version

Fixieren Sie in der Produktion eine vollständige Version. Die beweglichen Tags leisten für einen Test gute Dienste, bedeuten aber, dass ein docker compose pull eine neue Nebenversion einspielen kann, ohne dass Sie es entschieden haben.

Ausgehender Netzwerkzugriff

Ihre Firewall muss registry.gitlab.com sowie die Domain des Objektspeichers freigeben, aus dem die Image-Layer heruntergeladen werden. Ein erfolgreiches docker login, gefolgt von einem docker pull, der hängen bleibt, hat fast immer diese Ursache.

Offline-Installation¶

Wenn Ihre Server über keinerlei ausgehenden Zugriff verfügen, liefern wir jede Version auch als Archiv aus, eines je Architektur. Fordern Sie es beim Support an und laden Sie es dann auf die Zielmaschine:

docker load -i docker-drovio-server-amd64-3.6.6.tar.gz

Das so geladene Image trägt denselben Namen und dasselbe Tag wie das aus der Registry: der Rest dieser Seite gilt unverändert.

Verwaltung persistenter Daten¶

Gemäß den Grundprinzipien von Docker sind die in einem Container gespeicherten Daten flüchtig und überdauern dessen Zerstörung nicht. Es gibt jedoch Mechanismen für persistente Daten, darunter die Bind Mounts, die eine Datei oder einen Ordner des Hostsystems in den Container einblenden.

Unsere Docker-Images stützen sich für drei Arten persistenter Daten auf Bind Mounts:

Daten	Pfad im Container	Betrifft
Konfigurationsdateien	`/etc/drovio-server`	beide Images
Protokolldateien	`/var/log/drovio-server`	beide Images
Datenbankdaten	`/opt/drovio-server/data`	das All-in-One-Image

Das Produktions-Image bringt keine eigene Datenbank mit. Es benötigt nur die ersten beiden. Wo seine Daten liegen, bestimmt die Datenbank, auf die Sie es verweisen, gleich ob es die von docker compose gestartete oder Ihr eigener Server ist.

Eigentümer der Ordner, Produktions-Image¶

Das Produktions-Image läuft unter dem unprivilegierten Benutzer drovio, uid und gid 1000. Die beiden Ordner, in die es schreibt, müssen ihm gehören:

mkdir -p config logs
sudo chown -R 1000:1000 config logs

Andernfalls verweigert der Container den Start und nennt den zu korrigierenden Ordner.

Tun Sie das niemals mit dem Datenbankordner

data/postgresql gehört dem Datenbankcontainer, der unter seinem eigenen Benutzer läuft. Übergibt man ihn an die uid 1000, kann PostgreSQL nicht mehr starten, mit einem Berechtigungsfehler auf seinen eigenen Dateien.

Umstieg von 3.6.5 oder älter

Frühere Versionen dieses Images liefen unter root. Die von ihnen auf Ihrem Host angelegten Ordner gehören daher root. Führen Sie den obigen chown-Befehl auf Ihren vorhandenen Ordnern config und logs aus, bevor Sie das neue Image starten.

Außerhalb dieser beiden Pfade und des Arbeitsverzeichnisses von Vert.x unter /tmp wird nichts geschrieben. Der Container kann daher auch mit einem schreibgeschützten Root-Dateisystem laufen:

docker run --read-only --tmpfs /tmp ...

Das All-in-One-Image bereitstellen¶

Legen Sie einen Ordner drovio-server an und wechseln Sie hinein:

mkdir drovio-server
cd drovio-server

Erstellen Sie ein Volume für die eingebettete Datenbank und starten Sie dann den Container:

docker volume create drovio-data

docker run --hostname drovio.example.com \
  -p 8090:8090 \
  -v "./config:/etc/drovio-server" \
  -v "./logs:/var/log/drovio-server" \
  -v "drovio-data:/opt/drovio-server/data" \
  --rm -it "registry.gitlab.com/drovio/drovio-server-aio:3.6.6"

Verwenden Sie ein Volume für die Datenbank, keinen Bind Mount

PostgreSQL prüft, ob sein Datenverzeichnis dem Benutzer postgres gehört. Docker Desktop stellt jedoch unter macOS wie unter Windows alles innerhalb eines Bind Mounts als root gehörend dar, was immer Sie auch tun. So kann der Container nicht starten. Ein benanntes Volume kennt diese Einschränkung nicht und ist ohnehin der empfohlene Weg, Datenbankdaten aufzubewahren. Konfiguration und Protokolle sind nicht betroffen und können Bind Mounts bleiben.

Option	Beschreibung
`--hostname`	Legt einen bestimmten Hostnamen fest. Sie müssen ihn uns anschließend mitteilen, damit wir Ihre Lizenzen erzeugen können. Behalten Sie stets denselben bei, da die Lizenzen daran gebunden sind.
`-p <Host>:<Container>`	Veröffentlicht den Port des Containers auf dem Port des Hosts. Hier wird Port `8090` verwendet, da Drovio Server TLS nicht aktiviert und der gesamte HTTP-Verkehr standardmäßig über diesen Port läuft.
`-v "<Host>:<Container>"`	Bind Mounts für die oben beschriebenen persistenten Daten.
`--rm`	Entfernt den Container beim Beenden automatisch.
`-it`	Stellt ein Pseudo-Terminal bereit, das mit der Standardeingabe des Containers verbunden ist.

Der Hostname wird nur einmal geschrieben

Bei seinem allerersten Start schreibt der Server seine eigene URL in seine Konfiguration, gebildet aus dem Hostnamen, den Sie ihm geben. Sie wird danach nicht neu berechnet, und Ihre Lizenzen sind daran gebunden. Ein ohne --hostname gestarteter Container würde den Betrieb verweigern.

Setzen Sie stattdessen APP_URL, wenn sich die URL, über die Ihre Benutzer den Server erreichen, vom Hostnamen des Containers unterscheidet, etwa hinter einem Reverse-Proxy.

Das Produktions-Image bereitstellen¶

Das Produktions-Image wird mit dem Plugin docker compose bereitgestellt, dem Werkzeug zum Definieren und Ausführen von Docker-Anwendungen mit mehreren Containern.

Die Bereitstellungsdateien beziehen¶

Alles, was Sie zur Bereitstellung benötigen, steckt im Image selbst. Entpacken Sie es an der Stelle, an der Sie den Server betreiben wollen, mit denselben Zugangsdaten, mit denen Sie es geholt haben:

id=$(docker create registry.gitlab.com/drovio/drovio-server:3.6.6)
docker cp "$id:/opt/drovio-server/bundle/." ./drovio-server
docker rm "$id"
cd drovio-server

Sie erhalten drei Dateien, alle passend zu der soeben geholten Version:

Datei	Was es ist
`docker-compose.yml`	die Bereitstellung, mit oder ohne verwaltete Datenbank und verwalteten Sitzungsspeicher
`env.example`	die Einstellungen, die Sie ausfüllen müssen
`drovio-server.sql`	das Datenbankschema, verwendet bei ihrer Erstellung und bei Aktualisierungen

Seine Zeile image: verweist bereits auf genau die Version, aus der Sie es extrahiert haben.

Einstellungen¶

Kopieren Sie env.example nach .env und füllen Sie die Datei aus. Zwei Werte sind Pflicht:

DROVIO_HOSTNAME=drovio.example.com
DB_PASSWORD=<generate one>

Erzeugen Sie die Passwörter, statt ein vorhandenes wiederzuverwenden, zum Beispiel mit openssl rand -base64 24. DROVIO_HOSTNAME folgt derselben Regel wie --hostname weiter oben: es wird nur beim ersten Start in die Server-URL eingetragen.

Von Docker verwaltete oder externe Komponenten¶

Ob die Datenbank und der Sitzungsspeicher hier verwaltet oder von Ihnen bereitgestellt werden, entscheidet sich beim Start über die Profile. Dieselbe docker-compose.yml deckt alle drei Fälle ab:

Befehl	Was dabei startet
`docker compose --profile bundled-db up`	Von `docker compose` verwaltetes PostgreSQL, interner Sitzungsspeicher
`docker compose --profile bundled-db --profile redis up`	dasselbe, mit einem von `docker compose` verwalteten Redis-Sitzungsspeicher
`docker compose up`	externe Datenbank, tragen Sie `DB_HOST` und die zugehörigen Variablen in `.env` ein

Entfernen Sie beim Profil redis außerdem die Kommentarzeichen vor SS_TYPE, SS_REDIS_CONNECTION_STRINGS, SS_REDIS_MASTER_NAME und SS_REDIS_PASSWORD in Ihrer .env.

Von Docker verwaltete Komponenten: gesteuert durch das Plugin docker compose. Alle Container folgen demselben Lebenszyklus und teilen sich dasselbe Docker-Netzwerk.
Externe Komponenten: Sie sind nicht in der docker-compose-Datei deklariert. Ihre Verbindungsdaten müssen über die dafür vorgesehenen Umgebungsvariablen übergeben werden. Beim ersten Start existiert die Konfigurationsdatei von Drovio Server noch nicht und wird mit Standardwerten angelegt. Diese Variablen dienen dann dazu, einige davon zu ersetzen, was einen erfolgreichen ersten Start ermöglicht.

Prüfen, ob der Server antwortet¶

Beide Images stellen einen Endpunkt zur Zustandsprüfung bereit und deklarieren einen Docker-HEALTHCHECK, der ihn nutzt. docker ps zeigt den Container als healthy an, sobald der Server antwortet.

curl -f http://drovio.example.com:8090/healthcheck

Umgebungsvariablen¶

Umgebungsvariable	Konfigurationsfeld
`APP_URL`	`.http.url`
`SS_TYPE`	`.http.session_store.type`
`SS_REDIS_CONNECTION_STRINGS`	`.http.session_store.redis.connections`
`SS_REDIS_MASTER_NAME`	`.http.session_store.redis.master`
`SS_REDIS_PASSWORD`	`.http.session_store.redis.password`
`DB_HOST`	`.database.host`
`DB_PORT`	`.database.port`
`DB_NAME`	`.database.database`
`DB_USER`	`.database.user`
`DB_PASSWORD`	`.database.password`
`DB_MAIN_POOL_SIZE`	`.database.pool_options.main.max_size`
`DB_LICENSING_POOL_SIZE`	`.database.pool_options.licensing.max_size`
`DB_MAIN_IDLE_TIMEOUT`	`.database.pool_options.main.idle_timeout`
`DB_LICENSING_IDLE_TIMEOUT`	`.database.pool_options.licensing.idle_timeout`
`DB_MAIN_CONNECT_TIMEOUT`	`.database.pool_options.main.connect_timeout`
`DB_LICENSING_CONNECT_TIMEOUT`	`.database.pool_options.licensing.connect_timeout`
`DB_POOL_SIZE` (deprecated)	`.database.pool_options.main.max_size`
`DB_NV_POOL_SIZE` (deprecated)	`.database.pool_options.licensing.max_size`
`DB_IDLE_TIMEOUT` (deprecated)	`.database.pool_options.main.idle_timeout`

Umgebungsvariablen haben immer Vorrang

Diese Variablen überschreiben grundsätzlich die Werte aus der Konfigurationsdatei von Drovio Server beim Start. Wenn Sie in den Konfigurationsdateien einen Wert ändern, der zu einer dieser Variablen gehört, müssen Sie diese Variable auch aus der docker-compose-Datei entfernen oder ihren Wert aktualisieren, bevor Sie Drovio Server neu starten.

Aktualisieren¶

Holen Sie die gewünschte Version und erstellen Sie dann die Container neu. Ihre Konfiguration, Ihre Protokolle und Ihre Datenbank liegen in den Bind Mounts und bleiben unberührt.

docker compose pull
docker compose --profile bundled-db up -d

Das Datenbankschema¶

Eine neue Version kann Tabellen oder Spalten hinzufügen. Die beiden Images behandeln diesen Punkt nicht auf dieselbe Weise.

Image	Was die Schemaänderungen anwendet
All-in-One	der Container selbst, bei jedem Start. Nichts zu tun.
Produktion	Sie, bevor Sie das neue Image starten.

Das Produktions-Image rührt Ihr Schema nie an. drovio-server.sql wird nur bei der Erstellung der Datenbank ausgeführt, durch den Datenbankcontainer von docker compose bei dessen allerersten Start oder durch Sie auf Ihrem eigenen Server. Danach wird es nicht erneut ausgeführt.

Bei einem Versionswechsel des Produktions-Image:

Extrahieren Sie drovio-server.sql aus dem Image, auf das Sie wechseln, genau wie bei einer Erstinstallation. Das in einem Image mitgelieferte Skript ist immer dasjenige, das dieses Image erwartet.
```
id=$(docker create registry.gitlab.com/drovio/drovio-server:3.6.6)
docker cp "$id:/opt/drovio-server/bundle/drovio-server.sql" .
docker rm "$id"
```
Wenden Sie es auf Ihre Datenbank an, während die Drovio-Server-Container gestoppt sind.
```
psql -h my-database.example.com -U drovio -d drovio -f drovio-server.sql
```
Starten Sie das neue Image.

Das Skript ist so geschrieben, dass es erneut ausgeführt werden kann: es legt an, was fehlt, und lässt den Rest unangetastet, sodass es auf einer bereits aktuellen Datenbank nichts ändert.

Sichern Sie zuerst

Erstellen Sie eine Sicherung der Datenbank, bevor Sie ein Schemaskript anwenden, gleich wie groß der Versionsabstand ist. Es ist der einzige Schritt dieses Vorgehens, der sich nicht rückgängig machen lässt.

All-in-One und PostgreSQL-Hauptversionen

Das All-in-One-Image aktualisiert seinen Datenbankcluster nicht an Ort und Stelle. Bringt eine neue Version eine neuere PostgreSQL-Hauptversion mit, hält der Container beim Start mit einer erklärenden Meldung an. Exportieren Sie Ihre Daten aus dem vorherigen Image mit pg_dumpall und stellen Sie sie mit dem neuen in einem frischen Volume wieder her.