GCP VM — Installation du serveur backend

Support DQE

Mise à jour 17 septembre 2026 11:55

1. Architecture

L'application et toutes ses dépendances sont compilées dans une image Docker.

Dès que le conteneur est déployé sur une instance GCP, il se jumelle avec une organisation Salesforce disposant du package Unify UI (installable directement depuis l'AppExchange).

Ce document décrit une configuration possible pour gérer l'accès à l'instance déployée, par exemple via un load balancer.

Architecture backend GCP 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 GCP

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

Dans cette section, nous décrivons la liste des composants nécessaires pour installer l'instance Unify Server DQE sur GCP.

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 GCP VM

Type de serveur : Unix, ex. Ubuntu.
Load balancer : Non requis, mais peut être utilisé s'il est déjà disponible.

Pour plus d'informations, consultez les ressources suivantes :

Configuration de la VM : https://cloud.google.com/compute/docs/instances

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 : Le nom du conteneur dans l'environnement Docker

2. Installation

Deux scénarios sont possibles :

Scénario 1 : Le client n'a pas encore de Load Balancer configuré sur sa VM
Suivez toutes les étapes
Scénario 2 : Le client dispose déjà d'une VM GCP avec un load balancer configuré

Scénarios d'installation GCP

2.1. Prérequis

Lancez l'instance de serveur dédiée et connectez-vous avec l'une des options de connexion :

Options de connexion à une VM GCP

Pour plus de détails sur l'accès aux instances via la console GCP, consultez la documentation officielle de GCP.

Installation de NGINX

$ sudo apt update
$ sudo apt install nginx

Configuration :

Si la VM n'est accessible que via le load balancer, par exemple au sein d'un VPC privé :

server {

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

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

Si la VM est directement exposée en HTTPS :

server {
    listen 443 ssl;
    server_name <e.g. exemple.com>;
    ssl_certificate < location of the .crt certificate>
    ssl_certificate_key < location of the private key.key>
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH: !aNULL: ! MD5;
    location / {
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_pass http://127.0.0.1:8001;
    }
    Location /api/ {
        rewrite /api/(.*) /$1 break;
        proxy_set_header Host $host;
        proxy_pass http://127.0.0.1:8000;
    }
}

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

Installation d'Azure CLI pour l'accès à l'Azure Container Registry

$ sudo curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

2.2. GCP Unify 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 GCP, 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