Virtual Machine Linux — Installation du serveur backend

Support DQE
Support DQE
  • Mise à jour

1. Architecture

Ce guide vous accompagne dans le lancement et l'exposition du backend DQE One Standalone sur une machine virtuelle Linux (Ubuntu) préalablement provisionnée.

Ce document décrit un exemple de configuration pour mettre en place l'instance du serveur backend Standalone sur une machine virtuelle Ubuntu. 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 et est généralement exposée via NGINX en HTTPS.

Internet
   |
HTTPS:443
   |
NGINX
   |
http://localhost: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 doit de préférence rester derrière NGINX.
  • 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

  • Configuration serveur :
    • Type : Unix, par exemple Ubuntu
    • RAM : 3 à 5 Go
    • Espace disque : 10 Go minimum
    • CPU : 1 vCPU minimum

2. Installation

2.1. Prérequis

Installation de Docker

$ 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

Remarque : sur les versions récentes d'Ubuntu, la commande apt-key peut afficher un avertissement de dépréciation. Cet avertissement est normal et n'empêche pas l'installation de Docker si la commande renvoie OK.

Docker Compose

Les versions récentes de Docker incluent Docker Compose V2 par défaut. Ce guide utilise la commande du plugin Compose :

$ docker compose

Vérifiez que Docker Compose est disponible :

$ docker compose version

Si un numéro de version est renvoyé, aucune installation supplémentaire de Docker Compose n'est nécessaire.

Installation de NGINX

$ sudo apt update
$ sudo apt install nginx

Exemple de configuration :

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

Après avoir mis à jour la configuration NGINX, redémarrez NGINX :

$ sudo systemctl restart nginx

2.2. Fichier Docker Compose

Créez un fichier docker-compose.yml avec le contenu suivant :

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:

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.

Note 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.

Variable Exemple de valeur Description
SFAPIVERSION v65.0 Version de l'API Salesforce utilisée par l'application lors de la communication avec Salesforce.
CREATE_SUPERUSER true Crée le compte administrateur initial lors du premier démarrage.
RUN_COLLECTSTATIC false Exécute la commande Django collectstatic au démarrage. Laissez à false sauf si explicitement requis.
DQE_ONE_SERVER_ADMIN_USER <admin_user> Nom d'utilisateur du compte administrateur initial.
DQE_ONE_SERVER_ADMIN_PASSWORD <admin_password> Mot de passe du compte administrateur initial. Choisissez un mot de passe fort et gardez-le confidentiel.
DQE_CLIENT_LICENCE <client_licence> Clé de licence client fournie par DQE.
WEBSITE_HOSTNAME https://standalone.example.com URL HTTPS publique de l'instance Standalone. Cette valeur doit correspondre au nom DNS et à la configuration NGINX.
SECRET_ENCRYPTION_KEY <secret_encryption_key> Clé secrète utilisée pour chiffrer les informations sensibles stockées par l'application. Générez une clé unique pour chaque installation et ne la modifiez jamais après le déploiement.
WAIT_HOSTS redis:6379 Liste des services dépendants qui doivent être accessibles avant le démarrage de l'application.
WAIT_HOSTS_TIMEOUT 300 Délai d'attente maximal, en secondes, pour que les services dépendants deviennent disponibles.
WAIT_SLEEP_INTERVAL 5 Délai, en secondes, entre deux vérifications de disponibilité.
WAIT_HOST_CONNECT_TIMEOUT 30 Délai d'expiration, en secondes, pour chaque tentative de connexion à un service dépendant.
REDIS_URL redis://redis:6379 URL de connexion Redis utilisée par l'application.
PORT 8000 Port d'écoute interne de l'application.
DEBUG false Active ou désactive le mode debug. Cette valeur doit être définie sur false en production.
DB_USER dqeone Nom d'utilisateur de la base de données PostgreSQL utilisé par l'application.
DB_PASSWORD <database_password> Mot de passe de la base de données PostgreSQL utilisé par l'application. Il doit correspondre à POSTGRES_PASSWORD dans le service postgres.
DB_NAME dqeone Nom de la base de données PostgreSQL utilisé par l'application. Il doit correspondre à POSTGRES_DB dans le service postgres.
DB_HOST postgres Nom d'hôte du service PostgreSQL défini dans le fichier Docker Compose.
DB_VOLUME_PATH ./db/ Chemin utilisé par l'application pour le stockage lié à la base de données.
DB_MAX_CAPACITY 8000000000 Capacité maximale de la base de données, exprimée en octets.
AUTHORIZED_SFTP_HOSTS depot-1.dqe-software.net Liste d'hôtes SFTP, séparés par des virgules, autorisés par l'application pour les échanges de fichiers sécurisés.

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 :

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

$ 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.

3. Lancement

3.1. Connexion au registre de conteneurs Azure de DQE

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

3.2. Télécharger les images

$ docker compose pull

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.3. Démarrer les services

$ docker compose up -d

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

$ docker compose ps

Services attendus :

  • dqeone
  • redis
  • postgres

3.4. Vérifier l'installation

$ 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 configuré, 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
  • Indentation invalide
  • Caractère invisible

Solution :

  • Remplacez les tabulations par des espaces.
  • Validez le fichier à l'aide de docker compose config.
  • Vérifiez la ligne précédant celle indiquée par le message d'erreur.

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 ;
  • NGINX est en cours d'exécution ;
  • le port 443 est autorisé par le pare-feu du serveur ;
  • le certificat SSL est correctement configuré ;
  • l'entrée DNS pointe vers la VM ou la passerelle exposant le service.

Associé à

Cet article vous a-t-il été utile ?

Utilisateurs qui ont trouvé cela utile : 0 sur 0