Virtual Machine Windows — Installation du serveur backend

1. Architecture

Une fois votre instance de serveur DQE One Standalone dédiée opérationnelle, vous pouvez lancer et exposer l'application backend depuis votre machine virtuelle.

Ce document décrit un exemple de configuration pour mettre en place l'instance du serveur backend Standalone sur une machine virtuelle Windows Server 2022. Docker Compose s'exécute dans WSL2 (Windows Subsystem for Linux 2) car Docker CE sur Windows Server ne peut pas exécuter nativement des conteneurs Linux. Ce document ne couvre pas l'ensemble de la couche de sécurité de votre propre environnement.

L'application backend est déployée avec Docker Compose. NGINX s'exécute en tant que conteneur et est exposé en HTTPS.

Architecture recommandée

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

Mesures de sécurité

• Protocoles et ports : exposez l'application publiquement via HTTPS sur le port 443. L'application Docker elle-même écoute sur le port 8000 et reste derrière NGINX sur le réseau Docker interne.
• Filtrage IP : selon votre architecture, restreignez l'accès entrant aux seules adresses IP de confiance.
• Certificat SSL : si la VM est directement exposée à internet, elle doit disposer d'une entrée DNS et d'un certificat SSL associé.

Recommandation

Cette section décrit la liste des composants requis pour installer l'instance DQE One Standalone sur une VM Windows Server.

• Type de serveur : Windows Server 2022 (64 bits).
• Runtime de conteneurs : Docker CE exécuté dans WSL2 (Ubuntu) — requis car Docker CE sur Windows Server ne peut pas exécuter nativement des conteneurs Linux.

Configuration matérielle requise :

Composition et services

La pile est composée d'images Docker orchestrées via Docker Compose. Chaque service s'exécute en tant que conteneur. Les services communiquent entre eux via leur nom de service sur le réseau Docker interne.

2. Installation

Toutes les étapes d'installation sont effectuées sur la VM Windows Server. Les étapes marquées [PowerShell] doivent être exécutées dans PowerShell en tant qu'administrateur. Les étapes marquées [WSL2] doivent être exécutées dans le terminal Ubuntu WSL2.

2.1. Prérequis

Connectez-vous à la VM Windows Server à l'aide de l'une des options de connexion disponibles (RDP, Azure Bastion, etc.) et ouvrez PowerShell en tant qu'administrateur.

Créez la structure de répertoires de l'application depuis PowerShell :

New-Item -ItemType Directory -Path "C:\dqe-standalone"
New-Item -ItemType Directory -Path "C:\dqe-standalone\nginxconf"
New-Item -ItemType Directory -Path "C:\dqe-standalone\ssl"

Installation de WSL2 [PowerShell]

Activez les fonctionnalités Windows requises :

dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
Enable-WindowsOptionalFeature -Online -FeatureName Containers -All -NoRestart

/!\ Redémarrage requis — Redémarrez la VM après avoir activé ces fonctionnalités avant de continuer.

Après le redémarrage, ouvrez PowerShell en tant qu'administrateur et installez Ubuntu :

wsl --set-default-version 2
wsl --install -d Ubuntu

Un terminal s'ouvre vous demandant de créer un nom d'utilisateur Unix et un mot de passe. Terminez la configuration avant de continuer.

Installation de Docker et Docker Compose [WSL2]

Ouvrez le terminal Ubuntu WSL2 et exécutez :

curl -fsSL https://get.docker.com | sudo sh

Remarque : le script détecte WSL et recommande Docker Desktop — ignorez le message et attendez 20 secondes pour que l'installation se poursuive automatiquement. Docker Compose est inclus dans cette installation.

Ajoutez votre utilisateur au groupe docker et démarrez le service :

sudo usermod -aG docker $USER
sudo service docker start

Fermez et rouvrez le terminal WSL2, puis vérifiez :

docker --version
docker compose version

Remarque : le service Docker doit être démarré manuellement à chaque ouverture de la session WSL2 : sudo service docker start

Configuration de NGINX [PowerShell]

NGINX s'exécute en tant que conteneur — il n'y a pas d'installation au niveau de l'hôte. Vous devez uniquement créer le fichier de configuration. Ouvrez-le dans le Bloc-notes depuis PowerShell :

notepad C:\dqe-standalone\nginxconf\default.conf

Collez le contenu suivant et enregistrez :

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;
}

Remarque : contrairement à l'installation Linux où NGINX s'exécute sur l'hôte et redirige vers http://localhost:8000, dans Docker Compose les services communiquent via leur nom de service — la cible du proxy est http://dqeone:8000.

Placez les fichiers de certificat SSL et de clé privée dans C:\dqe-standalone\ssl\ avant de démarrer les conteneurs.

2.2. Fichier Docker Compose

Créez le fichier C:\dqe-standalone\docker-compose.yml avec le contenu suivant à l'aide du Bloc-notes :

notepad C:\dqe-standalone\docker-compose.yml

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
    networks:
      - standalone-net

  nginx:
    image: nginx:latest
    platform: linux/amd64
    container_name: nginx
    restart: always
    ports:
      - "443:443"
    volumes:
      - /mnt/c/dqe-standalone/nginxconf:/etc/nginx/conf.d:ro
      - /mnt/c/dqe-standalone/ssl:/etc/nginx/ssl:ro
    depends_on:
      - dqeone
    networks:
      - standalone-net

  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"
    networks:
      - standalone-net

  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
    networks:
      - standalone-net

volumes:
  redis_data:
  postgres_data:

networks:
  standalone-net:
    driver: bridge

Important : remplacez toutes les valeurs indicatives entre <...> par les valeurs fournies ou générées pour l'installation du client.

Important : utilisez les versions d'images fournies par DQE. Ne les remplacez pas par le tag latest, car certaines images peuvent ne pas être publiées avec ce tag.

Points clés :

• Tous les volumes de données (redis_data, postgres_data) sont des volumes Docker nommés stockés dans le système de fichiers Linux de WSL2. Les montages liés (bind mounts) vers le système de fichiers NTFS de Windows ne sont pas utilisés car NTFS ne prend pas en charge les opérations chown requises par ces conteneurs.
• La configuration NGINX et les certificats SSL sont montés depuis /mnt/c/dqe-standalone/nginxconf et /mnt/c/dqe-standalone/ssl — les dossiers Windows accessibles via WSL2.
• platform: linux/amd64 est spécifié sur l'image NGINX pour forcer Docker (exécuté dans WSL2 sur un hôte Windows) à télécharger la version Linux.
• Remarque de sécurité : ne publiez pas les identifiants réels des clients, les clés de licence, les clés de chiffrement, les mots de passe du registre ou les mots de passe de base de données dans la documentation.

Variables d'environnement

Le service dqeone requiert plusieurs variables d'environnement pour configurer le backend Standalone.

Important : la clé SECRET_ENCRYPTION_KEY doit être générée une seule fois et conservée pendant toute la durée de vie du déploiement. Modifier cette valeur après l'initialisation de l'application peut empêcher le déchiffrement des données précédemment chiffrées.

Pour générer une clé de chiffrement compatible, exécutez depuis le terminal WSL2 :

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

Si le module cryptography n'est pas installé, installez-le d'abord :

sudo apt install python3-cryptography

2.3. Valider le fichier Docker Compose [WSL2]

Accédez au répertoire de l'application et validez la configuration :

cd /mnt/c/dqe-standalone
docker compose config

Si Docker Compose renvoie une erreur telle que :

yaml: found character that cannot start any token

vérifiez l'indentation du fichier. YAML ne prend en charge que les espaces. Des tabulations ou des caractères invisibles peuvent générer cette erreur. Le problème peut aussi se situer à la ligne précédant celle indiquée dans le message d'erreur.

Remarque : lors de la modification du fichier dans le Bloc-notes, assurez-vous qu'aucune tabulation n'est insérée. L'utilisation d'un éditeur de code tel que Visual Studio Code est recommandée pour éviter les problèmes de caractères invisibles.

3. Lancement

Les images Docker DQE sont fournies via un registre de conteneurs Azure géré par DQE. Toutes les commandes de cette section sont exécutées depuis le terminal Ubuntu WSL2.

3.1. Connexion au registre de conteneurs Azure de DQE [WSL2]

Démarrez le service Docker et authentifiez-vous auprès du registre DQE :

sudo service docker start
docker login dqeone.azurecr.io
Username: <Login provided by DQE>
Password: <Password provided by DQE>

Une connexion réussie affiche : Login Succeeded

Si Docker renvoie une erreur unauthorized lors du téléchargement d'une image, vérifiez que toutes les images utilisent le registre de conteneurs Azure fourni par DQE. Les installations clients ne doivent pas référencer de registres de développement tels que dqeonedev.azurecr.io.

3.2. Télécharger les images [WSL2]

Accédez au répertoire de l'application et téléchargez les images :

cd /mnt/c/dqe-standalone
docker compose pull

3.3. Démarrer les services [WSL2]

docker compose up -d

Vérifiez que chaque conteneur est en cours d'exécution :

docker compose ps

Services attendus — tous doivent afficher le statut running :

• dqeone
• redis
• postgres
• nginx

/!\ Important : si un conteneur affiche le statut exited ou restarting, vérifiez ses logs : docker compose logs <service-name>

3.4. Vérifier l'installation [WSL2]

curl -I http://localhost:8000

Une réponse similaire à la suivante confirme que l'application est en cours d'exécution :

HTTP/1.1 301 Moved Permanently

Une fois NGINX en cours d'exécution, l'application doit être accessible via le point d'accès HTTPS public :

https://<your-domain>

4. Dépannage

Erreur d'analyse YAML

yaml: found character that cannot start any token

Causes possibles :

• Caractère de tabulation inséré par le Bloc-notes
• Indentation invalide
• Caractère invisible

Solution :

• Remplacez les tabulations par des espaces.
• Validez le fichier à l'aide de docker compose config depuis le terminal WSL2.
• Vérifiez la ligne précédant celle indiquée par le message d'erreur.
• Utilisez un éditeur de code (Visual Studio Code) plutôt que le Bloc-notes pour éviter l'insertion de tabulations.

Erreur unauthorized lors du téléchargement des images

unauthorized: authentication required

Vérifiez que :

• vous vous êtes correctement authentifié avec docker login dqeone.azurecr.io ;
• toutes les images référencent le registre de production DQE dqeone.azurecr.io ;
• les versions d'images correspondent à celles fournies par DQE.

Impossible d'accéder à l'application à distance

Vérifiez que :

• les conteneurs Docker sont en cours d'exécution ;
• le conteneur NGINX est en cours d'exécution ;
• le port 443 est autorisé par le pare-feu Windows Server ;
• le certificat SSL est correctement placé dans C:\dqe-standalone\ssl\ ;
• l'entrée DNS pointe vers la VM ou la passerelle exposant le service.

Service Docker non démarré [WSL2]

Cannot connect to the Docker daemon at unix:///var/run/docker.sock

Le service Docker doit être démarré manuellement à chaque ouverture de la session WSL2. Exécutez :

sudo service docker start