Virtual Machine Windows — Backend-Server-Installation

1. Architektur

Dieser Leitfaden erklärt, wie die DQE One Standalone-Backend-Anwendung auf einer Windows Server-virtuellen Maschine installiert und bereitgestellt wird, sobald Ihre dedizierte Standalone-Serverinstanz eingerichtet und in Betrieb ist.

Dieses Dokument beschreibt eine Beispielkonfiguration für den Standalone-Backend-Server auf Windows Server 2022. Docker Compose läuft innerhalb von WSL2 (Windows Subsystem for Linux 2), da Docker CE unter Windows Server keine Linux-Container nativ ausführen kann. Es deckt nicht die vollständige Sicherheitsebene Ihrer eigenen Umgebung ab.

Die Backend-Anwendung wird mit Docker Compose bereitgestellt. NGINX läuft als Container und wird über HTTPS bereitgestellt.

Empfohlene Architektur

Internet
   |
HTTPS:443
   |
NGINX (container)
   |
http://dqeone:8000
   |
DQE One Standalone backend

Sicherheitsmaßnahmen

• Protokolle und Ports: Die Anwendung wird öffentlich über HTTPS auf Port 443 bereitgestellt. Der Anwendungscontainer lauscht auf Port 8000 und bleibt im internen Docker-Netzwerk, nur über den NGINX-Container erreichbar.
• IP-Filterung: Beschränken Sie den eingehenden Zugriff je nach Architektur auf vertrauenswürdige IP-Adressen.
• SSL-Zertifikat: Wenn die VM direkt dem Internet ausgesetzt ist, muss sie über einen DNS-Eintrag und ein zugehöriges SSL-Zertifikat verfügen.

Empfehlung

Da Docker CE unter Windows Server keine Linux-Container nativ ausführen kann, laufen alle Linux-basierten Dienste (dqeone, redis, postgres, nginx) innerhalb einer WSL2-Distribution und nicht direkt auf dem Windows-Host.

• Serverkonfiguration:
  • Typ: Windows Server 2022 mit aktiviertem WSL2
  • Container-Laufzeitumgebung: Docker CE, ausgeführt innerhalb einer WSL2-Distribution (z. B. Ubuntu)

Zusammensetzung und Dienste

Der Docker-Compose-Stack umfasst vier Dienste: redis, nginx, dqeone und postgres, die über ein internes Bridge-Netzwerk (standalone-net) verbunden sind.

2. Installation

2.1. Voraussetzungen

Installation von WSL2 [PowerShell]

PS> wsl --install
PS> wsl --set-default-version 2

Starten Sie den Server bei Aufforderung neu und installieren Sie anschließend eine Linux-Distribution (z. B. Ubuntu) über den Microsoft Store oder über:

PS> wsl --install -d Ubuntu

Docker-Installation [WSL2]

$ sudo apt update
$ sudo apt install apt-transport-https ca-certificates curl software-properties-common
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"
$ sudo apt update
$ sudo apt install docker-ce
$ docker --version

Hinweis: Bei neueren Ubuntu-Versionen kann der Befehl apt-key eine Warnung zur Veraltung anzeigen. Diese Warnung ist erwartet und verhindert nicht die Installation von Docker, wenn der Befehl OK zurückgibt.

Docker Compose [WSL2]

Neuere Docker-Versionen enthalten standardmäßig Docker Compose V2. Dieser Leitfaden verwendet den Compose-Plugin-Befehl:

$ docker compose

Überprüfen Sie, ob Docker Compose verfügbar ist:

$ docker compose version

Wenn eine Versionsnummer zurückgegeben wird, ist keine zusätzliche Installation von Docker Compose erforderlich.

NGINX [Container, keine Host-Installation]

NGINX muss nicht auf dem Windows-Host oder in WSL2 installiert werden: Es läuft als Container, der in der Docker-Compose-Datei definiert ist. Konfigurationsbeispiel (in den Container eingebunden):

server {
    listen 443 ssl;
    server_name myserver.example.com;

    ssl_certificate /etc/nginx/ssl/[MY_CERTIFICATE].pem;
    ssl_certificate_key /etc/nginx/ssl/[MY_PRIVATE_KEY].key;

    ssl_protocols TLSv1.2 TLSv1.3;

    location / {
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header Host $host;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "Upgrade";
        proxy_http_version 1.1;
        proxy_set_header X-Forwarded-Host $host;
        proxy_set_header X-Forwarded-Server $host;
        proxy_set_header Cookie $http_cookie;
        proxy_set_header Referer $http_referer;

        proxy_pass http://dqeone:8000;
    }

    access_log /var/log/nginx/dqeone-standalone.log;
    error_log /var/log/nginx/dqeone-standalone-error.log error;
}

2.2. Docker-Compose-Datei [WSL2]

Erstellen Sie eine Datei docker-compose.yml mit folgendem Inhalt:

services:

  redis:
    container_name: redis
    image: dqeone.azurecr.io/dqe-one-redis:v1.0
    hostname: redis
    networks:
      - standalone-net
    logging:
      driver: none
    volumes:
      - redis_data:/data

  nginx:
    container_name: nginx
    image: nginx:stable
    hostname: nginx
    networks:
      - standalone-net
    ports:
      - "443:443"
    volumes:
      - /mnt/c/dqe-standalone/nginx/nginx.conf:/etc/nginx/conf.d/default.conf:ro
      - /mnt/c/dqe-standalone/nginx/ssl:/etc/nginx/ssl:ro
    depends_on:
      - dqeone

  dqeone:
    container_name: dqeone
    image: dqeone.azurecr.io/standalone:v1.4.0
    hostname: dqeone
    networks:
      - standalone-net
    expose:
      - "8000"
    depends_on:
      - redis
      - postgres
    environment:
      - SFAPIVERSION=v65.0
      - CREATE_SUPERUSER=true
      - RUN_COLLECTSTATIC=false
      - DQE_ONE_SERVER_ADMIN_USER=<admin_user>
      - DQE_ONE_SERVER_ADMIN_PASSWORD=<admin_password>
      - DQE_CLIENT_LICENCE=<client_licence>
      - WEBSITE_HOSTNAME=https://<your-domain>
      - SECRET_ENCRYPTION_KEY=<secret_encryption_key>
      - WAIT_HOSTS=redis:6379
      - WAIT_HOSTS_TIMEOUT=300
      - WAIT_SLEEP_INTERVAL=5
      - WAIT_HOST_CONNECT_TIMEOUT=30
      - REDIS_URL=redis://redis:6379
      - PORT=8000
      - DEBUG=false
      - DB_USER=dqeone
      - DB_PASSWORD=<database_password>
      - DB_NAME=dqeone
      - DB_HOST=postgres
      - DB_VOLUME_PATH=./db/
      - DB_MAX_CAPACITY=8000000000
      - AUTHORIZED_SFTP_HOSTS=<authorized_sftp_hosts>
    command:
      - "bash"
      - "./entrypoint.sh"

  postgres:
    container_name: postgres
    image: dqeone.azurecr.io/dqe-one-postgres:v1.0
    hostname: postgres
    networks:
      - standalone-net
    logging:
      driver: none
    environment:
      POSTGRES_USER: dqeone
      POSTGRES_PASSWORD: <database_password>
      POSTGRES_DB: dqeone
    volumes:
      - postgres_data:/var/lib/postgresql/data

networks:
  standalone-net:
    driver: bridge

volumes:
  redis_data:
  postgres_data:
  

Wichtig: Ersetzen Sie alle Platzhalterwerte zwischen <...> durch die für die Kundeninstallation bereitgestellten oder generierten Werte.

Wichtig: Verwenden Sie die von DQE bereitgestellten Image-Versionen. Ersetzen Sie diese nicht durch das Tag latest, da einige Images möglicherweise nicht mit diesem Tag veröffentlicht werden.

Sicherheitshinweis: Veröffentlichen Sie keine echten Kundenanmeldedaten, Lizenzschlüssel, Verschlüsselungsschlüssel, Registry-Passwörter oder Datenbankpasswörter in der Dokumentation.

Umgebungsvariablen

Der Dienst dqeone benötigt mehrere Umgebungsvariablen, um das Standalone-Backend zu konfigurieren.

Wichtig: Der SECRET_ENCRYPTION_KEY muss einmalig generiert und für die gesamte Lebensdauer der Bereitstellung beibehalten werden. Eine Änderung dieses Werts nach der Initialisierung der Anwendung kann verhindern, dass zuvor verschlüsselte Daten entschlüsselt werden.

Um einen kompatiblen Verschlüsselungsschlüssel zu generieren, führen Sie aus [WSL2]:

python3 -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"

Wenn das Modul cryptography nicht installiert ist, installieren Sie es zuerst:

sudo apt install python3-cryptography

Wichtige Punkte

• Der Docker-Compose-Stack läuft aus Leistungs- und Kompatibilitätsgründen im Linux-Dateisystem der WSL2-Distribution und nicht auf einem Windows-Pfad.
• Für den Host freigegebene Volumes (z. B. NGINX-Konfiguration und Zertifikate) werden über /mnt/c/... aus dem Windows-Dateisystem eingebunden.
• Alle Dienste kommunizieren über das interne Bridge-Netzwerk standalone-net; nur NGINX veröffentlicht einen Port auf dem Host.

2.3. Überprüfen der Docker-Compose-Datei [WSL2]

$ docker compose config

Wenn Docker Compose einen Fehler wie den folgenden zurückgibt:

yaml: found character that cannot start any token

überprüfen Sie die Einrückung der Datei. YAML unterstützt nur Leerzeichen. Tabulatoren oder unsichtbare Zeichen können diesen Fehler verursachen. Das Problem kann sich auch in der Zeile vor der in der Fehlermeldung angegebenen Zeile befinden.

3. Start

3.1. Verbindung zur DQE Azure Container Registry herstellen [WSL2]

$ docker login dqeone.azurecr.io
Username: <Login provided by DQE>
Password: <Password provided by DQE>

3.2. Herunterladen der Images [WSL2]

$ docker compose pull

Wenn Docker beim Abrufen eines Images einen Fehler unauthorized zurückgibt, überprüfen Sie, ob alle Images die von DQE bereitgestellte Azure Container Registry verwenden. Kundeninstallationen sollten nicht auf Entwicklungs-Registries wie dqeonedev.azurecr.io verweisen.

3.3. Starten der Dienste [WSL2]

$ docker compose up -d

Überprüfen Sie, ob jeder Container ausgeführt wird:

$ docker compose ps

Erwartete Dienste:

• dqeone
• redis
• postgres
• nginx

3.4. Überprüfen der Installation [WSL2]

$ curl -Ik https://localhost

Eine ähnliche Antwort wie die folgende bestätigt, dass die Anwendung ausgeführt wird:

HTTP/1.1 301 Moved Permanently

Sobald NGINX konfiguriert ist, sollte die Anwendung über den öffentlichen HTTPS-Endpunkt erreichbar sein:

https://<your-domain>

4. Fehlerbehebung

YAML-Parsing-Fehler

yaml: found character that cannot start any token

Mögliche Ursachen:

• Tabulatorzeichen
• Ungültige Einrückung
• Unsichtbares Zeichen

Lösung:

• Ersetzen Sie Tabulatoren durch Leerzeichen.
• Überprüfen Sie die Datei mit docker compose config.
• Überprüfen Sie die Zeile vor der in der Fehlermeldung angegebenen Zeile.

Nicht autorisiert beim Abrufen von Images

unauthorized: authentication required

Überprüfen Sie, dass:

• Sie sich erfolgreich mit docker login dqeone.azurecr.io authentifiziert haben;
• alle Images auf die DQE-Produktionsregistry dqeone.azurecr.io verweisen;
• die Image-Versionen mit den von DQE bereitgestellten übereinstimmen.

Docker-Dienst nicht gestartet [WSL2]

Wenn docker compose-Befehle einen Verbindungsfehler zurückgeben, läuft der Docker-Daemon möglicherweise nicht innerhalb der WSL2-Distribution. Starten Sie ihn mit:

$ sudo service docker start

Anwendung kann remote nicht erreicht werden

Überprüfen Sie, dass:

• die Docker-Container ausgeführt werden;
• der NGINX-Container ausgeführt wird;
• Port 443 von der Windows Server-Firewall zugelassen wird;
• das SSL-Zertifikat korrekt konfiguriert ist;
• der DNS-Eintrag auf die VM oder das Gateway verweist, das den Dienst bereitstellt.