AWS — Installation des Backend-Servers

Support DQE

Aktualisiert 25. September 2026 12:36

1. Architektur

Die Anwendung selbst und alle ihre Abhängigkeiten sind in einer docker-compose-Datei zusammengefasst, die von DQE-Software bereitgestellt wird.

Sobald der Container in einer AWS-Instanz (EC2, Elastic BeanStalk, ...) bereitgestellt ist, verbindet er sich mit einer Salesforce-Organisation, die das Unify-UI-Paket installiert hat (Installation über den AppExchange).

Dieses Dokument beschreibt eine mögliche Konfiguration zur Verwaltung des Zugriffs auf die bereitgestellte Instanz, beispielsweise über einen LoadBalancer.

Flussdiagramm

Das folgende Diagramm beschreibt alle ein- und ausgehenden Datenflüsse sowie die von der Anwendung benötigten IPs und Ports.

Sicherheitsmaßnahmen

Wir können kein Beispiel für die Implementierung der Sicherheitsschicht bereitstellen, das perfekt zu Ihrer Architektur passt. Wir können jedoch einige Empfehlungen geben, die für die Nutzung der Anwendung selbst relevant sind.

Protokolle und Ports: Alle ausgehenden/eingehenden Datenflüsse der Anwendung laufen über das HTTPS-Protokoll (Port 443). Es ist nicht notwendig, 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 bildet jedoch der CustomUI-Webserver, der Teil der docker-compose ist. Er muss über einen Webbrowser erreichbar sein. Eine Lösung könnte daher darin bestehen, den Zugriff auf den Server über ein bestimmtes VPN zuzulassen. Siehe hier die von Salesforce veröffentlichte Liste der IPs. (Vergessen Sie nicht die Hyperforce-IPs)

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

Ist die VM nicht direkt dem Internet ausgesetzt, bedeutet dies in der Regel, 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

Im Folgenden finden Sie die Komponenten, die für die Bereitstellung einer Instanz von DQE One auf AWS erforderlich sind.

Hinweis: Die Schätzungen basieren auf 1 Million Datensätzen. Je nach Größe Ihrer Datenbanken müssen Sie möglicherweise die Kapazitäten Ihrer Container-Instanzen erhöhen, um die Verarbeitungszeit zu optimieren.

Bereitstellung mit AWS EC2

Servertyp: Unix, z. B. Ubuntu Server 20.04 LTS (HVM), EBS General Purpose (SSD) Volume Type.
Load Balancer: Muss bereitgestellt werden, damit die VM mit der Außenwelt kommunizieren kann.

Weitere Informationen finden Sie in den folgenden Ressourcen:

Amazon EC2-Einrichtung:

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

EC2-Instanzen:

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

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

Zusammensetzung und Dienste

Das Docker-Image ist eine Webanwendung, die die Dienste und APIs bereitstellt, die von Salesforce über die Lightning-App DQE Unify UI 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 auf die folgenden Dienste angewiesen, um ordnungsgemäß zu funktionieren. Dieser Worker muss im Web verfügbar gemacht werden, wie in der später in diesem Dokument dargestellten Nginx-Konfiguration beschrieben.

Docker-Compose-Einstellungen

image: Der Name des von der Webanwendung verwendeten Images. Das Image muss entsprechend den Namen der verwendeten Registrys umbenannt werden. Für Images, die in einer Azure Container Registry gehostet werden, wird der Name wie folgt aufgebaut:
```
<Name of the registry container>.azurecr.io/<name of the image>
```
container_name: Container-Name
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 ein Frontend zur Konfiguration von Deduplizierungsregeln bereitstellt. Wie der erste Dienst muss er daher ebenfalls im Web verfügbar gemacht werden. Dieser Dienst nutzt außerdem einige APIs des Backends, um beispielsweise Metadaten aus dem CRM abzurufen.

Registry-Name: *

Image-Name: *

Verfügbare Versionen: *

Redis

Dieser Dienst ist eine Key/Value-Datenbank, die von den verschiedenen Komponenten 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. Aus Sicherheitsgründen blockieren jedoch einige Cloud-Anbieter das Abrufen öffentlicher Images und erlauben nur Images aus privaten Registrys. Um diese Einschränkung zu umgehen, veröffentlichen wir in der privaten Registry "dqeone" ebenfalls eine Version von Redis, die vollständig mit unseren Anwendungen kompatibel ist.

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 Warteschlangen-Manager, der den Empfang und die Planung von Verarbeitungsanfragen ermöglicht. Bis ein Prozess einem Worker zugewiesen und abgeschlossen wurde, verbleibt er in einer Warteschlange. Dies ermöglicht außerdem eine Ausfallsicherheit: Sollte der Server neu gestartet werden, würde die letzte Verarbeitung in der Warteschlange dort fortgesetzt, wo sie unterbrochen wurde.

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

Parameter

image : Offizielles Image von RabbitMQ => rabbitmq:3-management-alpine
container_name: Name des RabbitMQ-Containers

2. Installation

2.1. Voraussetzung

Starten Sie die dedizierte Serverinstanz und verbinden Sie sich über eine der angebotenen Verbindungsoptionen:

Verbindungsoptionen der AWS EC2-Instanz

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

NGINX-Installation

$ sudo apt update
$ sudo apt install nginx

Um Port 80 auf unsere API umzuleiten:

Es ist notwendig, den Schlüssel "location /" innerhalb des Schlüssels "server" in der Nginx-Konfigurationsdatei unter "/etc/nginx/sites-enabled/default" hinzuzufügen.

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

Docker-Installation

Aktualisieren Sie das vorhandene Paket
```
$ sudo apt-get update
```

Installation der Voraussetzungen für die Nutzung von Paketen über HTTPS

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

Hinzufügen des GPG-Schlüssels aus dem offiziellen Docker-Repository

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

Aktualisieren 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 aktuellen Docker-Installationen ist Docker Compose V2 standardmäßig in der Docker Engine enthalten. Bevor Sie die eigenständige docker-compose-Binärdatei herunterladen, überprüfen Sie, ob Compose bereits installiert ist, indem Sie Folgendes ausführen:

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

Festlegen der Berechtigungen

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

Azure-CLI-Installation

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

CertBot-Installation

Aktualisieren von snapd

$ sudo snap install core; sudo snap refresh core

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

Vorbereitung von CERTBOT

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

Erstellen des Zertifikats
```
$ sudo certbot --nginx
```

2.2. AWS 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. Launcher

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

3.1. Verbindung zur DQE Azure Container Registry herstellen

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 von docker-compose.yml

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

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

Verknüpfung mit

War dieser Beitrag hilfreich?

0 von 0 fanden dies hilfreich