Machine virtuelle — Installation du serveur backend

Support DQE

Mise à jour 17 septembre 2026 11:55

1. Architecture

Une fois votre instance de serveur DQE One dédiée opérationnelle, vous pouvez lancer l'étape de configuration depuis votre application Salesforce. Le package AppExchange DQE One doit avoir été installé au préalable.

Ce document décrit un exemple de configuration possible pour mettre en place l'instance du serveur. Ce document ne couvre pas la couche de sécurité de votre propre environnement.

Architecture backend de machine virtuelle pour DQE One et Salesforce

Diagramme de flux

Voici le diagramme décrivant tous les flux entrants/sortants ainsi que les adresses IP et ports requis par l'application.

Diagramme de flux entrant et sortant pour DQE One sur une machine virtuelle

Mesures de sécurité

Nous ne pouvons pas fournir d'exemple d'implémentation de la couche de sécurité qui s'adapterait parfaitement à votre architecture. Cependant, nous pouvons fournir quelques recommandations pertinentes pour l'utilisation de l'application elle-même.

Protocoles et ports : Tous les flux sortants/entrants de l'application passent par le protocole HTTPS (port 443). Il n'est pas nécessaire d'ouvrir un autre port sur votre VM. Les adresses IP DQE devant être accessibles sont décrites dans le diagramme précédent.
Filtrage IP : Le serveur d'application lui-même n'a besoin d'être accessible que depuis les serveurs de Salesforce. Il est donc recommandé de mettre en place un filtrage des IP entrantes.

Il existe cependant une exception à cela : le serveur web CustomUI inclus dans le docker-compose. Il doit être accessible depuis un navigateur web. Une solution pourrait donc être d'autoriser l'accès au serveur via un VPN spécifique. Voir ici la liste des IP publiées par Salesforce. (N'oubliez pas les IP Hyperforce)

Protocole d'authentification : Salesforce propose nativement plusieurs protocoles pour sécuriser les requêtes entre ses serveurs et le serveur DQE One. Lors de la configuration de la « Connected App » « DQE One Customer » dans votre organisation, vous pourrez sélectionner la méthode d'authentification « Basic Auth » et configurer votre pare-feu applicatif en conséquence.

Si la VM est directement exposée à internet, elle doit avoir une entrée DNS et un certificat SSL associé qui pointent vers elle.

Si la VM n'est pas directement exposée à internet, cela signifie généralement que le trafic est acheminé via un composant tel qu'une passerelle. Dans ce cas, le DNS et le certificat SSL doivent être installés sur cette passerelle, qui transmettra ensuite le trafic à la VM interne.

Recommandation

Cette section liste les composants nécessaires pour installer l'instance Serveur DQE One sur une VM.

Remarque : Les estimations sont basées sur 1 million d'enregistrements. Selon le volume des bases de données traitées, il peut être nécessaire d'augmenter la capacité mémoire des instances de conteneurs pour optimiser les temps de traitement.

Déploiement avec des instances VM

Configuration serveur :
- Type : Unix, ex. Ubuntu.
- RAM : 3 à 5 Go
- Espace disque : 10 Go
- CPU : 1vCPU
Load balancer : Non essentiel mais peut être utilisé s'il est déjà disponible.

Composition et services

L'image Docker est une application web qui expose les services et API sollicités depuis Salesforce via l'application Lightning DQE Unify UI.

Pour chaque service, nous détaillons ci-dessous les attributs et leurs fonctions.

WEB APPLICATION

Un conteneur backend contenant une application de microservices. Cette application expose toutes les API appelées pour lancer les traitements, gérer les files d'attente de traitement, instancier les workers de traitement. Elle dépend des services suivants pour fonctionner correctement. Ce worker doit être exposé sur le web comme décrit dans la configuration nginx présentée plus loin dans ce document.

Paramètres Docker Compose

image : Le nom de l'image utilisée par l'application web. Il est nécessaire de renommer l'image selon les noms des registres utilisés. Les images Docker DQE sont hébergées dans un Azure Container Registry. Le nom de l'image est construit comme suit :
```
<Nom du registre de conteneurs>.azurecr.io/<nom de l'image>
```
container_name : Nom du conteneur
depends_on : Nom des services précédant ce service
domainname : Le nom de domaine utilisé pour le FQDN. Format attendu :
```
<nom de domaine>
```
environment : Variables d'environnement du service
command : Commande exécutée au lancement du conteneur

Worker

Paramètres à définir dans Docker Compose

image : Le nom de cette image est le même que celui du service web
container_name : Le nom du conteneur dans l'environnement Docker
depends_on : Nom des services précédant ce service
environment : Variables d'environnement du service
command : Commande exécutée au lancement du conteneur

CustomUI

Ce service est une application web exposant une interface utilisée pour configurer les règles de déduplication. Comme le premier service, il doit donc également être exposé sur le web. Ce service consomme aussi certaines API du backend, par exemple pour récupérer les métadonnées du CRM.

Nom du registre : *

Nom de l'image : *

Versions disponibles : *

Redis

Ce service est une base de données clé/valeur utilisée par les différents services pour stocker des clés de fonctionnement internes telles que les configurations d'organisation Salesforce, les sessions, etc.

Il est possible d'utiliser les images officielles publiées par Redis telles que « redis:alpine », mais par mesure de sécurité, certains fournisseurs cloud bloquent la récupération d'images publiques et n'autorisent que les images provenant de registres privés. Pour contourner cette restriction, nous publions également sur le registre privé « dqeone » une version de redis parfaitement compatible avec nos applications.

Paramètres

image : Image officielle de redis => redis:alpine
container_name : Le nom du conteneur dans l'environnement Docker
volumes : Le chemin du volume à utiliser pour sauvegarder les données Redis
```
<nom du volume défini dans ce docker compose>:/data
```

RabbitMQ

Ce service est un puissant gestionnaire de files d'attente permettant la réception et la planification des demandes de traitement. Tant qu'un traitement n'a pas été assigné à un worker et terminé, il sera stocké dans une file d'attente. Cela permet également une résilience aux pannes : si le serveur devait redémarrer, il reprendrait le dernier traitement dans la file d'attente là où il s'était arrêté.

Comme pour l'image du service Redis, vous avez la possibilité d'utiliser une version publique (rabbitmq:3-management-alpine) ou celle du registre privé dqeone.

Paramètres

image : Image officielle de rabbitmq => rabbitmq:3-management-alpine
container_name : Nom du conteneur RabbitMQ

2. Installation

2.1. Prérequis

Installation de NGINX

$ sudo apt update
$ sudo apt install nginx

Exemple de configuration :

server {
listen 443 ssl;
server_name mysite.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;
#ssl_ciphers HIGH: !aNULL: ! MD5;

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://127.0.0.1:8001/;
}


location /unify/ {
rewrite /unify/(.*) /$1 break;
proxy_set_header Host $host;
proxy_pass http://127.0.0.1:8000;
}

location /lookup {
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $host;
proxy_pass http://127.0.0.1:8000;
}

location /static {
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $host;
proxy_pass http://127.0.0.1:8000;
}

Location /API {
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $host;
proxy_pass http://127.0.0.1:8000;
}

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

Installation de Docker

Mettre à jour le paquet existant
```
$ sudo apt-get update
```

Installation des prérequis pour l'utilisation de paquets via HTTPS

$ sudo apt install apt-transport-https ca-certificates curl software-properties-common

Ajout de la clé GPG du dépôt officiel Docker

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Ajout du dépôt Docker aux sources APT

$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu focal stable"

Mise à jour des paquets
```
$ sudo apt-get update
```
Vérification de l'installation depuis le dépôt Docker
```
$ apt-cache policy docker-ce
```
Installation de Docker
```
$ sudo apt install docker-ce
```

Installation de docker-compose

Remarque : Sur les installations récentes de Docker, Docker Compose V2 est inclus par défaut avec Docker Engine. Avant de télécharger le binaire autonome docker-compose, vérifiez si Compose est déjà installé en exécutant :

docker compose version

Si la commande renvoie un numéro de version, vous pouvez ignorer cette étape d'installation et utiliser docker compose au lieu de docker-compose dans les commandes suivantes.

Téléchargez la version souhaitée (numéro de version à modifier dans l'URL)

$ sudo curl -L "https://github.com/docker/compose/releases/download/<NUMEROS_DE_VERSION>/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Définition des permissions

$ sudo chmod +x /usr/local/bin/docker-compose

2.2. One Server

services:
    customui: 
        image: <imageURL>
        container_name: custom-ui 
        logging: 
            driver : "json-file"
            options : 
                max-file : 5
                max-size : 50m
        environment:
          - PORT=8001
        ports:
          - 8001:8001 
        command: npm start

    web: 
        image: <imageURL>
        container_name: one-server 
        hostname: oneserver 
        logging: 
            driver : "json-file"
            options : 
                max-file : 5
                max-size : 50m
        depends_on: 
          - redis 
          - rabbitmq 
        environment: 
          - SFAPIVERSION=v59.0
          - PORT=8000
          - REDIS_URL=redis://redis 
          - CLOUDAMQP_URL=amqp://guest:guest@rabbitmq/admin
          - CUSTOMUI=http://customui:8001
          - UNIFYSERVERURL=http://web:8000
        ports:
          - 8000:8000 
        command: bash ./entrypoint.sh

    worker: 
        image: <imageURL>
        container_name: queue-worker 

        logging: 
            driver : "json-file" 
            options : 
                max-file : 5
                max-size : 50m
        environment:
          - SFAPIVERSION=v59.0
          - WORKDIRPATH=/app/unify
          - REDIS_URL=redis://redis
          - CLOUDAMQP_URL=amqp://guest:guest@rabbitmq/admin
        depends_on:
          - web
        command: python -u ./unify/queue_worker.pyc

    redis: 
        container_name: redis
        logging:
            driver : "json-file"
            options :
                max-file : 5
                max-size : 50m
        image: <imageURL>
        hostname: redis
        volumes:
        - redis_data:/data

    rabbitmq: 
        image: <imageURL>
        container_name: 'rabbitmq'
        logging: 
            driver : "json-file" 
            options : 
                max-file : 5
                max-size : 50m
        environment:
          - RABBITMQ_DEFAULT_PASS=guest
          - RABBITMQ_DEFAULT_USER=guest
          - RABBITMQ_DEFAULT_VHOST=admin
        hostname: rabbitmq
        depends_on:
          - redis
        volumes:
        - rabbitmq_data:/var/lib/rabbitmq/
        - rabbitmq_log:/var/log/rabbitmq/

volumes:
    rabbitmq_data:
    rabbitmq_log:
    redis_data:

3. Lanceur

Bien que le serveur backend soit déployé sur votre propre machine virtuelle, les images Docker DQE sont fournies via un Azure Container Registry géré par DQE.

3.1. Connexion à l'Azure Container Registry DQE

Authentifiez Docker auprès de l'Azure Container Registry DQE :

$ sudo docker login **************
Username: <Login provided by DQE>
Password: <Pwd provided by DQE>

3.2. Lancement de docker-compose.yml

Accédez au dossier contenant le fichier docker-compose.yml et exécutez-le.

$ sudo docker-compose pull
$ sudo docker-compose up

Associé à

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

Utilisateurs qui ont trouvé cela utile : 0 sur 0