Virtuelle Maschine — Installation des Backend-Servers

Support DQE
Support DQE
  • Aktualisiert

1. Architektur

Sobald Ihre dedizierte DQE-One-Serverinstanz aktiv und einsatzbereit ist, können Sie den Konfigurationsschritt von Ihrer Salesforce-Anwendung aus starten. Das DQE-One-AppExchange-Paket muss zuvor installiert worden sein.

Dieses Dokument beschreibt ein Beispiel für eine mögliche Konfiguration zur Einrichtung der Serverinstanz. Dieses Dokument behandelt nicht die Sicherheitsebene Ihrer eigenen Umgebung.

GCP

Ablaufdiagramm

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

FlowMatrix

Sicherheitsmaßnahmen

Wir können kein Beispiel für die Implementierung der Sicherheitsebene liefern, 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 zugänglich 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 CustomUI-Webserver, der in der Docker-Compose-Datei enthalten ist. Er muss von einem Webbrowser aus zugänglich sein. Eine Lösung könnte daher darin bestehen, einem bestimmten VPN den Zugriff auf den Server zu gestatten. 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 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 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

Dieser Abschnitt listet die Komponenten auf, die zur Installation der DQE-One-Serverinstanz auf einer VM 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 Containerinstanzen zu erhöhen, um die Verarbeitungszeiten zu optimieren.

Bereitstellung mit VM-Instanzen

  • Serverkonfiguration:
    • Typ: Unix, z. B. Ubuntu.
    • RAM: 3 bis 5 GB
    • Speicherplatz: 10 GB
    • CPU: 1 vCPU
  • Load Balancer: Nicht zwingend erforderlich, kann aber verwendet werden, falls bereits vorhanden.

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 von den folgenden Diensten abhängig, um ordnungsgemäß zu funktionieren. Dieser Worker muss im Web zugänglich 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. 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 setzt sich wie folgt zusammen:

    <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

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 zugänglich gemacht werden, wie in der später in diesem Dokument dargestellten nginx-Konfiguration beschrieben.

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 zugänglich 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 verwendet wird, um interne Betriebsschlüssel wie Salesforce-Org-Konfigurationen, Sitzungen usw. zu speichern.

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 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 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 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 aus 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. Voraussetzungen

NGINX-Installation

$ sudo apt update
$ sudo apt install nginx

Konfigurationsbeispiel:

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

Docker-Installation

  1. Aktualisieren Sie das vorhandene Paket

    $ sudo apt-get update

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

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

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

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

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

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

  5. Aktualisieren der Pakete

    $ sudo apt-get update

  6. Überprüfung der Installation aus dem Docker-Repository

    $ apt-cache policy docker-ce

  7. Docker-Installation

    $ sudo apt install docker-ce

Docker-Compose-Installation

Hinweis: Bei aktuellen Docker-Installationen ist Docker Compose V2 standardmäßig enthalten in der Docker Engine. Bevor Sie die eigenständige Binärdatei docker-compose herunterladen, prü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.

  1. Laden Sie die gewünschte Version herunter (Versionsnummer in der URL zu ä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

  2. Berechtigungen festlegen

    $ 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. Launcher

Obwohl der Backend-Server auf Ihrer eigenen virtuellen Maschine 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 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