Salesforce AWS - Installation du serveur backend

Support DQE

Mise à jour 24 septembre 2025 13:40

1. Architecture

L'application elle-même et toutes ses dépendances sont compilées dans un fichier docker-compose fourni par DQE-Software.

Dès que le conteneur est déployé dans une instance AWS (EC2, Elastic BeanStalk, ...), il se connecte à une organisation Salesforce avec le package Unify UI (installation depuis le AppExchange).

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

Diagramme de flux

Voici le diagramme décrivant tous les flux entrants/sortants ainsi que les IPs et ports demandés par l'application.

Mesures de sécurité

Nous ne pouvons pas fournir un exemple d'implémentation de la couche de sécurité qui s'intégrerait parfaitement dans 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 IPs DQE qui doivent être accessibles sont décrites dans le diagramme précédent.
Filtrage IP : Le serveur d'application lui-même doit uniquement être accessible depuis les serveurs Salesforce. Il est donc recommandé de mettre en place un filtrage des IP entrantes.

Il existe cependant une exception, qui est le serveur web CustomUI inclus dans le docker-compose. Il doit être accessible via un navigateur web. Une solution pourrait donc être de permettre à un VPN spécifique d'accéder au serveur. Voir ici la liste des IPs publiées par Salesforce. (N'oubliez pas les IPs Hyperforce)

Protocole d'authentification : Salesforce offre nativement plusieurs protocoles pour sécuriser les requêtes entre ses serveurs et le serveur DQE One. Lors de la configuration de l'application connectée "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 routé via un composant tel qu'une passerelle. Dans ce cas, le DNS et le certificat SSL doivent être installés sur cette passerelle, qui relaiera ensuite le trafic vers la VM interne.

Recommandation

Voici tous les composants nécessaires pour qu'une instance de DQE One soit déployée sur AWS.

Note : Ces estimations sont faites sur une base de 1 million d'enregistrements. Selon la taille de vos bases de données, vous pourriez avoir besoin d'augmenter les capacités de vos instances de conteneurs pour optimiser le temps de traitement.

Déploiement avec AWS EC2

Type de serveur : Unix, par ex. Ubuntu Server 20.04 LTS (HVM), volume de type EBS General Purpose (SSD).
Load Balancer : Doit être déployé pour que la VM puisse communiquer avec l'extérieur.

Pour plus d'informations, consultez les ressources suivantes :

Configuration Amazon EC2 :

https://docs.aws.amazon.com/fr_fr/AWSEC2/latest/UserGuide/get-set-up-for-amazon-ec2.html

https://docs.aws.amazon.com/fr_fr/AWSEC2/latest/UserGuide/ec2-best-practices.html

Instances EC2 :

https://docs.aws.amazon.com/fr_fr/AWSEC2/latest/UserGuide/Instances.html

https://aws.amazon.com/fr/ec2/instance-types/

Composition et services

L'image docker est une application web qui expose les services et APIs demandés depuis Salesforce via l'application Lightning DQE Unify UI.

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

APPLICATION WEB

Un conteneur backend contenant une application microservices. Cette application expose toutes les APIs appelées pour lancer des processus, gérer les files de traitement, instancier des 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. Pour les images hébergées dans un registre de conteneurs Azure, le nom se construit comme suit :
```
<Nom du registre de conteneurs>.azurecr.io/<nom de l'image>
```
container_name : Nom du conteneur
depends_on : Nom des services qui précèdent ce service
domainname : Le nom de domaine pour le FQDN. Résultat évalué Azure :
```
<nom de domaine>
```
environment : Variables d'environnement du service
command : Commande exécutée lors du 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 qui apparaît dans Azure
depends_on : Nom des services qui précèdent ce service
environment : Variables d'environnement du service
command : Commande exécutée lors du lancement du conteneur

CustomUI

Ce service est une application web exposant une interface front utilisé 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 APIs 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 des 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 qui apparaît dans Azure
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 gestionnaire de files d'attente puissant permettant la réception et la planification des demandes de traitement. Tant qu'un processus n'a pas été attribué à un worker et terminé, il reste en attente dans une file. Cela permet aussi une résilience aux pannes, si le serveur devait redémarrer, il reprendrait le dernier traitement en 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 qui apparaît dans AWS

2. Installation

2.1. Prérequis

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

Pour les détails sur l'accès aux instances via la console AWS, consultez la documentation officielle ici.

Installation de NGINX

$ sudo apt update
$ sudo apt install nginx

Afin de rediriger le port 80 vers notre API :

Il sera nécessaire d'ajouter la clé "location /" à l'intérieur de la clé "server" dans le fichier de configuration de Nginx situé dans "/etc/nginx/sites-enabled/default"

server {
listen 80;
location / {
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

Mettez à jour les paquets existants
```
$ sudo apt-get update
```

Installation des prérequis pour utiliser les 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

Téléchargez la version désiré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éfinir les permissions

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

Installation de Azure-cli

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

Installation de CertBot

Mise à jour de snapd

$ sudo snap install core; sudo snap refresh core

Installation de CERTBOT
```
$ sudo snap install --classic certbot
```

Préparation de CERTBOT

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Création du certificat
```
$ sudo certbot --nginx
```

2.2. Serveur AWS One

version: '3.8'
services:
rabbitmq:
image: rabbitmq:3-management-alpine
container_name: rabbitmq
hostname: rabbitmq
logging:
driver: none
depends_on:
- redis
environment:
RABBITMQ_DEFAULT_PASS: guest
RABBITMQ_DEFAULT_USER: guest
RABBITMQ_DEFAULT_VHOST: admin
volumes:
- rabbitmq_data:/var/lib/rabbitmq/
- rabbitmq_log:/var/log/rabbitmq/
ports:
- "15672:15672"

redis:
container_name: redis
image: "redis:alpine"
hostname: redis
logging:
driver: none
ports:
- "6379:6379"

unify:
container_name: one-server
image: <imageURL>
expose:
- "8000"
ports:
- "8000:8000"
depends_on:
- redis
- rabbitmq
environment:
- SFAPIVERSION=v57.0
- WAIT_HOSTS= redis:6379
- WAIT_HOSTS_TIMEOUT=300
- WAIT_SLEEP_INTERVAL=5
- WAIT_HOST_CONNECT_TIMEOUT=30
- REDIS_URL=redis://redis
- CLOUDAMQP_URL=amqp://guest:guest@rabbitmq/admin
command:
- "bash"
- "./entrypoint.sh"

custom:
container_name: custom
image: <imageURL>
command: npm start
environment:
- PORT=8001
expose:
- "8001"
ports:
- "8001:8001"

worker:
container_name: queue-worker
image: <imageURL>
restart: always
depends_on:
- unify
- redis
- rabbitmq
environment:
- SFAPIVERSION=v57.0
- WORKDIRPATH=/app/unify
- REDIS_URL=redis://redis
- CLOUDAMQP_URL=amqp://guest:guest@rabbitmq/admin
command: python -u ./unify/queue_worker.py

volumes:
rabbitmq_data:
rabbitmq_log:
redis_data:
nginx.conf:

3. Lancement

3.1. Connexion de l'image DQE One au Hub Azure

Connectez Docker à l'image ONE Server DQE sur Azure :

$ sudo docker login **************
Nom d'utilisateur : <Identifiant fourni par DQE>
Mot de passe : <Mot de passe fourni par DQE>

3.2. Lancement du docker-compose.yml

Allez dans le dossier contenant le docker-compose.yml et lancez la commande.

$ sudo docker-compose up

Associé à

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

Utilisateurs qui ont trouvé cela utile : 0 sur 0