Virtual Machine Linux — Backend-Server-Installation

1. Architektur

Diese Anleitung erklärt, wie Sie die DQE One Standalone-Backend-Anwendung auf einer Linux-(Ubuntu-)virtuellen Maschine installieren und bereitstellen, sobald Ihre dedizierte Standalone-Serverinstanz eingerichtet ist und läuft.

Dieses Dokument beschreibt eine Beispielkonfiguration für den Standalone-Backend-Server unter Ubuntu. Es deckt nicht die vollständige Sicherheitsebene Ihrer eigenen Umgebung ab.

Die Backend-Anwendung wird mit Docker Compose bereitgestellt und in der Regel über NGINX per HTTPS exponiert.

Empfohlene Architektur

Internet
   |
HTTPS:443
   |
NGINX
   |
http://localhost:8000
   |
DQE One Standalone backend

Sicherheitsmaßnahmen

• Protokolle und Ports: Stellen Sie die Anwendung öffentlich über HTTPS auf Port 443 bereit. Die Docker-Anwendung selbst lauscht auf Port 8000 und sollte vorzugsweise hinter NGINX bleiben.
• IP-Filterung: Beschränken Sie je nach Architektur den eingehenden Zugriff 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

• Serverkonfiguration:
  • Typ: Unix, zum Beispiel Ubuntu
  • RAM: 3 bis 5 GB
  • Speicherplatz: mindestens 10 GB
  • CPU: mindestens 1 vCPU

2. Installation

2.1. Voraussetzungen

Docker-Installation

$ 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 zu erwarten und verhindert nicht die Installation von Docker, sofern der Befehl OK zurückgibt.

Docker Compose

Neuere Docker-Versionen enthalten standardmäßig Docker Compose V2. Diese Anleitung 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-Installation

$ sudo apt update
$ sudo apt install nginx

Konfigurationsbeispiel:

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://localhost:8000;
    }

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

Nachdem Sie die NGINX-Konfiguration aktualisiert haben, starten Sie NGINX neu:

$ sudo systemctl restart nginx

2.2. Docker-Compose-Datei

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
    logging:
      driver: none
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data

  dqeone:
    container_name: dqeone
    image: dqeone.azurecr.io/standalone:v1.4.0
    hostname: dqeone
    expose:
      - "8000"
    ports:
      - "8000: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
    logging:
      driver: none
    environment:
      POSTGRES_USER: dqeone
      POSTGRES_PASSWORD: <database_password>
      POSTGRES_DB: dqeone
    expose:
      - "5432"
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  redis_data:
  postgres_data:
  

Wichtig: Ersetzen Sie alle Platzhalterwerte zwischen <...> durch die Werte, die für die Kundeninstallation bereitgestellt oder generiert wurden.

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 einmal 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 können.

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

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

2.3. Überprüfen der Docker-Compose-Datei

$ 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

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

3.2. Herunterladen der Images

$ docker compose pull

Wenn Docker beim Abrufen eines Images einen unauthorized-Fehler 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

$ docker compose up -d

Überprüfen Sie, ob alle Container ausgeführt werden:

$ docker compose ps

Erwartete Dienste:

• dqeone
• redis
• postgres

3.4. Überprüfen der Installation

$ curl -I http://localhost:8000

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

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

Anwendung kann remote nicht erreicht werden

Überprüfen Sie Folgendes:

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