GCP VM — Installation des Backend-Servers

Support DQE

Aktualisiert 25. September 2026 12:48

1. Architektur

Die Anwendung und alle ihre Abhängigkeiten werden in ein Docker-Image kompiliert.

Sobald der Container auf einer GCP-Instanz bereitgestellt wird, verbindet er sich mit einer Salesforce-Org, die über das Unify-UI-Paket verfügt (direkt installierbar über den AppExchange).

Dieses Dokument beschreibt eine mögliche Konfiguration zur Verwaltung des Zugriffs auf die bereitgestellte Instanz, zum Beispiel über einen Load Balancer.

GCP-Backend-Architektur für DQE One und Salesforce

Flussdiagramm

Hier ist das Diagramm, das alle eingehenden/ausgehenden Datenflüsse sowie die von der Anwendung benötigten IPs und Ports beschreibt.

Eingehendes und ausgehendes Flussdiagramm für DQE One auf GCP

Sicherheitsmaßnahmen

Wir können kein Beispiel dafür liefern, wie die Sicherheitsschicht implementiert werden soll, die perfekt zu Ihrer Architektur passt. Wir können jedoch einige Empfehlungen geben, die für die Nutzung der App selbst relevant sind.

Protokolle und Ports: Alle ausgehenden/eingehenden Datenflüsse der Anwendung erfolgen über das HTTPS-Protokoll (Port 443). Es ist nicht nötig, einen weiteren Port auf Ihrer VM zu öffnen. Die DQE-IPs, die erreichbar sein müssen, sind im vorherigen Diagramm beschrieben.
IP-Filterung: Der Anwendungsserver selbst muss nur von den Servern von Salesforce aus erreichbar sein. Es wird daher empfohlen, eine Filterung der eingehenden IPs einzurichten.

Eine Ausnahme davon bildet jedoch der im docker-compose enthaltene CustomUI-Webserver. Er muss von einem Webbrowser aus erreichbar sein. Eine Lösung könnte daher darin bestehen, einem bestimmten VPN den Zugriff auf den Server zu erlauben. Siehe hierzu die von Salesforce veröffentlichte Liste der IPs. (Vergessen Sie die Hyperforce-IPs nicht)

Authentifizierungsprotokoll: Salesforce bietet nativ mehrere Protokolle zur Absicherung der Anfragen zwischen seinen Servern und dem DQE-One-Server. Bei der Konfiguration der Connected App „DQE One Customer" in Ihrer Organisation können Sie die Authentifizierungsmethode „Basic Auth" auswählen und Ihre Anwendungs-Firewall entsprechend konfigurieren.

Wenn die VM direkt dem Internet ausgesetzt ist, muss sie über einen DNS-Eintrag und ein zugehöriges SSL-Zertifikat verfügen, die auf sie verweisen.

Wenn die VM nicht direkt dem Internet ausgesetzt ist, bedeutet dies normalerweise, dass der Datenverkehr über eine Komponente wie ein Gateway geleitet wird. In diesem Fall müssen der DNS-Eintrag und das SSL-Zertifikat auf diesem Gateway installiert werden, das den Datenverkehr dann an die interne VM weiterleitet.

Empfehlung

In diesem Abschnitt beschreiben wir die Liste der Komponenten, die für die Installation der DQE-Unify-Server-Instanz auf GCP erforderlich sind.

Hinweis: Die Schätzungen basieren auf 1 Million Datensätzen. Je nach Umfang der verarbeiteten Datenbanken kann es notwendig sein, die Speicherkapazität der Container-Instanzen zu erhöhen, um die Verarbeitungszeiten zu optimieren.

Bereitstellung mit GCP-VM-Instanzen

Servertyp: Unix, z. B. Ubuntu.
Load Balancer: Nicht erforderlich, kann aber verwendet werden, falls bereits vorhanden.

Weitere Informationen finden Sie in den folgenden Ressourcen:

VM-Konfiguration: https://cloud.google.com/compute/docs/instances

Zusammensetzung und Dienste

Das Docker-Image ist eine Webanwendung, die die Dienste und APIs bereitstellt, die von Salesforce über die Lightning-DQE-Unify-UI-App angefordert werden.

Für jeden Dienst beschreiben wir im Folgenden die Attribute und ihre Funktionen.

WEBANWENDUNG

Ein Backend-Container, der eine Microservices-Anwendung enthält. Diese Anwendung stellt alle APIs bereit, die zum Starten von Prozessen, zur Verwaltung von Verarbeitungswarteschlangen und zur Instanziierung von Verarbeitungs-Workern aufgerufen werden. Sie ist von den folgenden Diensten abhängig, um ordnungsgemäß zu funktionieren. Dieser Worker muss im Web freigegeben werden, wie in der weiter unten in diesem Dokument dargestellten nginx-Konfiguration beschrieben.

Docker-Compose-Einstellungen

image: Der Name des von der Webanwendung verwendeten Images. Es ist notwendig, das Image entsprechend den Namen der verwendeten Registries umzubenennen. Die DQE-Docker-Images werden in einer Azure Container Registry gehostet. Der Image-Name wird wie folgt aufgebaut:
```
<Name of the registry container>.azurecr.io/<name of the image>
```
container_name: Name des Containers
depends_on: Name der Dienste, die diesem Dienst vorausgehen
domainname: Der für den FQDN verwendete Domainname. Erwartetes Format:
```
<domain name>
```
environment: Umgebungsvariablen des Dienstes
command: Befehl, der beim Start des Containers ausgeführt wird

Worker

In Docker Compose festzulegende Parameter

image: Der Name dieses Images ist derselbe wie beim Web-Dienst
container_name: Der Name des Containers in der Docker-Umgebung
depends_on: Name der Dienste, die diesem Dienst vorausgehen
environment: Umgebungsvariablen des Dienstes
command: Befehl, der beim Start des Containers ausgeführt wird

CustomUI

Dieser Dienst ist eine Webanwendung, die eine Oberfläche zur Konfiguration von Deduplizierungsregeln bereitstellt. Wie der erste Dienst muss er daher ebenfalls im Web freigegeben werden. Dieser Dienst nutzt auch einige APIs des Backends, zum Beispiel um Metadaten aus dem CRM abzurufen.

Registry Name: *

Image name: *

Available versions: *

Redis

Dieser Dienst ist eine Key/Value-Datenbank, die von den verschiedenen Modulen zur Speicherung interner Betriebsschlüssel wie Salesforce-Org-Konfigurationen, Sitzungen usw. verwendet wird.

Es ist möglich, offizielle von Redis veröffentlichte Images wie „redis:alpine" zu verwenden, aber aus Sicherheitsgründen blockieren einige Cloud-Anbieter den Abruf öffentlicher Images und erlauben nur Images aus privaten Registries. Um diese Einschränkung zu umgehen, veröffentlichen wir außerdem in der privaten Registry „dqeone" eine mit unseren Anwendungen perfekt kompatible Version von Redis.

Parameter

image: Offizielles Image von Redis => redis:alpine
container_name: Der Name des Containers in der Docker-Umgebung
volumes: Der Pfad des Volumes, das zur Sicherung der Redis-Daten verwendet werden soll
```
<name of the volume defined in this docker compose>:/data
```

RabbitMQ

Dieser Dienst ist ein leistungsstarker Warteschlangenmanager, der den Empfang und die Planung von Verarbeitungsanfragen ermöglicht. Bis ein Prozess einem Worker zugewiesen und abgeschlossen wurde, wird er in einer Warteschlange geparkt. Dies ermöglicht außerdem eine Ausfallsicherheit: Sollte der Server neu gestartet werden, würde er die letzte Verarbeitung in der Warteschlange dort fortsetzen, wo sie unterbrochen wurde.

Wie beim Redis-Dienst-Image haben Sie die Möglichkeit, eine öffentliche Version (rabbitmq:3-management-alpine) oder die Version in der privaten dqeone-Registry zu verwenden.

Parameter

image : Offizielles Image von rabbitmq => rabbitmq:3-management-alpine
container_name : Der Name des Containers in der Docker-Umgebung

2. Installation

Zwei Szenarien sind möglich:

Szenario 1: Der Kunde hat noch keinen Load Balancer auf seiner VM konfiguriert
Alle Schritte befolgen
Szenario 2: Der Kunde verfügt bereits über eine GCP-VM mit konfiguriertem Load Balancer

GCP-Installationsszenarien

2.1. Voraussetzung

Starten Sie die dedizierte Serverinstanz und verbinden Sie sich mit einer der Verbindungsoptionen:

GCP-VM-Verbindungsoptionen

Weitere Details zum Zugriff auf Instanzen über die GCP-Konsole finden Sie in der offiziellen GCP-Dokumentation.

NGINX-Installation

$ sudo apt update
$ sudo apt install nginx

Konfiguration:

Wenn die VM nur über den Load Balancer erreichbar ist, zum Beispiel innerhalb eines privaten VPC:

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

Wenn die VM direkt über HTTPS zugänglich ist:

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

Docker-Installation

Aktualisierung des vorhandenen Pakets
```
$ sudo apt-get update
```

Installation der Voraussetzungen zur Nutzung von Paketen über HTTPS

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

Hinzufügen des GPG-Schlüssels des offiziellen Docker-Repositorys

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

Hinzufügen des Docker-Repositorys zu den APT-Quellen

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

Aktualisierung der Pakete
```
$ sudo apt-get update
```
Überprüfung der Installation aus dem Docker-Repository
```
$ apt-cache policy docker-ce
```
Docker-Installation
```
$ sudo apt install docker-ce
```

Docker-Compose-Installation

Hinweis: Bei neueren Docker-Installationen ist Docker Compose V2 standardmäßig enthalten, zusammen mit Docker Engine. Bevor Sie das eigenständige docker-compose-Binary herunterladen, prüfen Sie mit folgendem Befehl, ob Compose bereits installiert ist:

docker compose version

Wenn der Befehl eine Versionsnummer zurückgibt, können Sie diesen Installationsschritt überspringen und in den folgenden Befehlen docker compose anstelle von docker-compose verwenden.

Laden Sie die gewünschte Version herunter (Versionsnummer in der URL ändern)

$ 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

Berechtigungen festlegen

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

Azure-CLI-Installation für den Zugriff auf die 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. Launcher

Obwohl der Backend-Server auf GCP bereitgestellt wird, werden die DQE-Docker-Images über eine von DQE verwaltete Azure Container Registry bereitgestellt.

3.1. Verbindung mit der DQE Azure Container Registry

Authentifizieren Sie Docker bei der DQE Azure Container Registry:

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

3.2. Start der docker-compose.yml

Wechseln Sie in den Ordner, der die Datei docker-compose.yml enthält, und führen Sie diese aus.

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

Verknüpfung mit

War dieser Beitrag hilfreich?

0 von 0 fanden dies hilfreich