Dokumentation

Docker Compose-Installation

Docker-basierte SKOOR-Installationen sind nur für Testzwecke gedacht und werden daher nicht offiziell unterstützt.

Voraussetzungen

  • Linux-Betriebssystem

  • Docker / Docker-Compose

  • Vom SKOOR-Support (support@skoor.com):

    • Ein Benutzerschlüssel für die SKOOR Docker-Registry

    • Ein SKOOR Lizenzschlüssel

    • Versionen der verschiedenen SKOOR Komponenten

Installation vorbereiten

Anmeldung bei der SKOOR Docker Registry (die Datei key.json muss einen gültigen, von SKOOR bereitgestellten Docker Registry Benutzerschlüssel enthalten)

cat key.json | docker login -u _json_key --password-stdin https://europe-docker.pkg.dev

Erstellen Sie ein Docker-Netzwerk

docker network create skoor-network

Setzen Sie die SKOOR Version auf einen vom SKOOR Support bereitgestellten Wert (z.B. "7.3.0")

export SKOOR_VERSION=<version>

Datenbank

Wenn kein PostgreSQL Server verfügbar ist, kann ein SKOOR PostgreSQL Container eingesetzt werden. In diesem Leitfaden wird davon ausgegangen, dass ein Datenbank-Container benötigt wird. Daher wird er in einer docker-compose.yaml-Datei konfiguriert. Wenn ein Datenbank Server vorhanden ist und kein Container benötigt wird, muss der eranger-postgresql Dienst aus der docker-compose.yaml entfernt werden. Wenden Sie sich an den SKOOR-Support, um Einzelheiten zur Konfiguration des Datenbankservers zu erfahren.

Persistentes Dateisystem

Wählen Sie zunächst einen Dateisystempfad zum Speichern der Datenbankdateien. In der folgenden Anleitung wird /var/lib/pgsql-docker als Pfad angenommen. Ändern Sie ihn nach Ihren Wünschen:

export PG_PATH=/var/lib/pgsql-docker

Erstellen Sie auf dem Docker-Host den Benutzer postgres mit der Benutzer- und Gruppen-ID 26:

sudo useradd -d $PG_PATH -g 26 -u 26 -M postgres

Bereiten Sie das Verzeichnis für die Datenbankdateien vor, falls erforderlich, und legen Sie die Berechtigungen fest:

sudo mkdir -p $PG_PATH && sudo chown 26:26 $PG_PATH && sudo chmod 700 $PG_PATH

Datenbank erstellen

Initialisieren Sie die Datenbank und erstellen Sie eine Kundendatenbank

docker run --user=root -v ${PG_PATH}:/var/lib/pgsql -e CUSTOMER=ng \
europe-docker.pkg.dev/sdaas-298209/eu.gcr.io/eranger-postgresql:$SKOOR_VERSION /opt/eranger/bin/db-config.sh

Die Warnung "Pfad "/var/opt/run/eranger" existiert nicht! Überspringen!" kann ignoriert werden

Der Fehler "ERROR: a database error occured: (threadId:139786843920512) PGRES_FATAL_ERROR - FEHLER: Relation "alarms" does not exist" kann ignoriert werden

SKOOR-Behälter

Persistente Dateisysteme

Fügen Sie dem Docker-Hostsystem den Benutzer eranger für persistente Dateisystemberechtigungen hinzu:

sudo useradd -u 909 -U -M eranger

Bereiten Sie einen Pfad für persistente Dateisysteme vor (ändern Sie ihn in einen sinnvollen Pfad auf dem Zielsystem):

export PERSISTENT_FS=/home/skoor

SKOOR Engine

Die SKOOR Engine benötigt eine Verzeichnisstruktur auf dem Docker-Host, um persistente Dateien zu speichern, die von den verschiedenen Containern gemeinsam genutzt werden. Legen Sie den Pfad an, der in der Datei docker-compose weiter unten in diesem Leitfaden angegeben ist (Sie können auch einen anderen Pfad wählen):

sudo mkdir -p $PERSISTENT_FS/engine && sudo chmod 755 $PERSISTENT_FS/engine

SKOOR Webservice:

Der SKOOR Webservice benötigt ebenfalls eine Verzeichnisstruktur, um persistente Dateien und Konfigurationen zu speichern. Der folgende Pfad wird in der Docker-Compose-Datei später in diesem Leitfaden angenommen:

sudo mkdir -p $PERSISTENT_FS/webservice/ && sudo chmod 755 $PERSISTENT_FS/webservice

Initialisieren der SKOOR-Konfiguration

Setzen Sie die Variable INSTANCE_NAME auf einen einfachen Namen, der eine SKOOR-Instanz repräsentiert, z. B. einen kurzen Firmennamen.

Verwenden Sie nur Buchstaben oder Zahlen für die Variable INSTANCE_NAME, keine Bindestriche oder andere Sonderzeichen.

export INSTANCE_NAME=<customer>

Führen Sie das Konfigurationsskript aus:

docker run --network=skoor-network \
-e NAME=ng \
-e SKOORENGINE_DOMAIN=docker.localhost \
-e DB_IP=eranger-postgresql-$INSTANCE_NAME \
-e DB_POOL_ADDR=eranger-pgbouncer-$INSTANCE_NAME \
-e SINGLE_TENANT=true \
-e CUSTOMER_DB=true \
-v $PERSISTENT_FS/engine:/mnt/customer \
-v $PERSISTENT_FS/webservice:/mnt/webservice \
europe-docker.pkg.dev/sdaas-298209/eu.gcr.io/sdaas-config:$SKOOR_VERSION /tmp/sdaas-config.sh nodb

Docker Compose-Dateien erstellen

Erstellen Sie ein Docker Compose-Verzeichnis:

mkdir -p ~/docker-compose/skoor && cd ~/docker-compose/skoor

Erstellen Sie die Datei .env innerhalb des Verzeichnisses skoor: 

echo -e "PERSISTENT_FS=$PERSISTENT_FS\n\
POSTGRESQL_PATH=$PG_PATH\n\
INSTANCE_NAME=$INSTANCE_NAME\n\
SKOOR_VERSION=$SKOOR_VERSION\n\
AUTH_VERSION=$SKOOR_VERSION\n\
ETL_VERSION=$SKOOR_VERSION\n\
DASHBOARD_VERSION=$SKOOR_VERSION\n\
DATABASE_VERSION=$SKOOR_VERSION\n\
DATABASE_IMAGE=eranger-postgresql" > .env

Für die Verwendung mit StableNet® foreign data wrapper, DATABASE_IMAGE auf eranger-postgresql-stablenet und DATABASE_VERSION entsprechend einstellen

Alle Versionen in dieser Datei sind gleich mit dem aktuellen Minor Release konfiguriert. Die Versionen der verschiedenen SKOOR Komponenten können sich jedoch ändern. Bitte fragen Sie den SKOOR-Support nach den neuesten Versionen

Erstellen Sie die Datei license.txt, die eine gültige SKOOR-Lizenz enthält. Beispiel:

license_name        = test
license_devices     = 99
license_sikulix     = 5
license_feature_set = 3.1
license_key         = 97bbd371d35143d7e6292a311e299d7b0a683d11adf8ad30ba09ebbdeb071866ed345fb67...

Fügen Sie die Lizenzinformationen in die Docker Compose .env Datei ein:

cat license.txt | sed -e 's/license_[a-z]\+/\U&/g' | tr -d ' ' | sed -e '/^LICENSE_FEATURE_set.*$/ d' >> .env

Erstellen Sie eine Datei docker-compose.yaml mit dem folgenden Inhalt:

services:
  eranger-server:
    image: europe-docker.pkg.dev/sdaas-298209/eu.gcr.io/eranger-server:${SKOOR_VERSION}
    container_name: eranger-server-${INSTANCE_NAME}
    volumes:
      - "${PERSISTENT_FS}/engine/eranger:/var/opt/run/eranger"
      - "${PERSISTENT_FS}/engine/tmp:/srv/eranger/html/tmp"
      - "${PERSISTENT_FS}/engine/templates:/srv/eranger/html/templates"
      - "${PERSISTENT_FS}/engine/snmp_walk:/srv/eranger/html/snmp_walk"
      - "${PERSISTENT_FS}/engine/reports:/srv/eranger/html/reports"
      - "${PERSISTENT_FS}/engine/parsefile:/srv/eranger/html/parsefile"
      - "${PERSISTENT_FS}/engine/fetchfile:/srv/eranger/html/fetchfile"
      - "${PERSISTENT_FS}/engine/execute:/srv/eranger/html/execute"
      - "${PERSISTENT_FS}/engine/eem_mht_logs:/srv/eranger/html/eem_mht_logs"
      - "${PERSISTENT_FS}/engine/sikulix:/srv/eranger/html/sikulix"
      - "${PERSISTENT_FS}/engine/selenium:/srv/eranger/html/selenium"
    environment:
      - SKOOR_SERVER_db_address=eranger-pgbouncer-${INSTANCE_NAME}
      - SKOOR_SERVER_db_database=ng
      - SKOOR_SERVER_license_name=${LICENSE_NAME}
      - SKOOR_SERVER_license_devices=${LICENSE_DEVICES}
      - SKOOR_SERVER_license_jobs=${LICENSE_JOBS}
      - SKOOR_SERVER_license_sikulix=${LICENSE_SIKULIX}
      - SKOOR_SERVER_license_feature_set=3.1
      - SKOOR_SERVER_license_key=${LICENSE_KEY}
      - SKOOR_SERVER_license_expire=${LICENSE_EXPIRE}
    expose:
      - "50001"
    depends_on:
      - eranger-postgresql
  eranger-report:
    image: europe-docker.pkg.dev/sdaas-298209/eu.gcr.io/eranger-report:${SKOOR_VERSION}
    container_name: eranger-report-${INSTANCE_NAME}
    volumes:
      - "${PERSISTENT_FS}/engine/tmp:/srv/eranger/html/tmp"
      - "${PERSISTENT_FS}/engine/templates:/srv/eranger/html/templates"
      - "${PERSISTENT_FS}/engine/transfer:/srv/eranger/html/transfer"
      - "${PERSISTENT_FS}/engine/eranger:/var/opt/run/eranger"
      - "${PERSISTENT_FS}/engine/reports:/srv/eranger/html/reports"
    environment:
      - SKOOR_REPORT_bl_address=eranger-server-${INSTANCE_NAME}
      - SKOOR_REPORT_bl_port=50001
      - SKOOR_REPORT_username=skoor-report
      - SKOOR_REPORT_password=skoor-report
    depends_on:
      - eranger-postgresql
  eranger-collector:
    image: europe-docker.pkg.dev/sdaas-298209/eu.gcr.io/eranger-collector:${SKOOR_VERSION}
    container_name: eranger-collector-${INSTANCE_NAME}
    volumes:
      - "${PERSISTENT_FS}/engine/eranger:/var/opt/run/eranger"
      - "${PERSISTENT_FS}/engine/upload:/opt/eranger/collector/upload"
    environment:
      - SKOOR_COLLECTOR_server1_address=eranger-server-${INSTANCE_NAME}
      - SKOOR_COLLECTOR_server1_port=50001
      - SKOOR_COLLECTOR_server1_id=1
      - SKOOR_COLLECTOR_server1_user=collector-local
      - SKOOR_COLLECTOR_server1_passwd=collector-local
    depends_on:
      - eranger-postgresql
  eranger-ui:
    image: europe-docker.pkg.dev/sdaas-298209/eu.gcr.io/eranger-ui:${SKOOR_VERSION}
    container_name: eranger-ui-${INSTANCE_NAME}
    ports:
      - "443:443"
    volumes:
      - "${PERSISTENT_FS}/engine/eranger:/var/opt/run/eranger"
      - "${PERSISTENT_FS}/engine/tmp:/srv/eranger/html/tmp"
      - "${PERSISTENT_FS}/engine/templates:/srv/eranger/html/templates"
      - "${PERSISTENT_FS}/engine/snmp_walk:/srv/eranger/html/snmp_walk"
      - "${PERSISTENT_FS}/engine/reports:/srv/eranger/html/reports"
      - "${PERSISTENT_FS}/engine/parsefile:/srv/eranger/html/parsefile"
      - "${PERSISTENT_FS}/engine/fetchfile:/srv/eranger/html/fetchfile"
      - "${PERSISTENT_FS}/engine/execute:/srv/eranger/html/execute"
      - "${PERSISTENT_FS}/engine/eem_mht_logs:/srv/eranger/html/eem_mht_logs"
      - "${PERSISTENT_FS}/engine/sikulix:/srv/eranger/html/sikulix"
      - "${PERSISTENT_FS}/engine/selenium:/srv/eranger/html/selenium"
      - "${PERSISTENT_FS}/engine/transfer:/srv/eranger/html/transfer"
      - "${PERSISTENT_FS}/engine/upload:/opt/eranger/collector/upload"
    environment:
      - SKOOR_UI_bl_address=eranger-server-${INSTANCE_NAME}
      - SKOOR_UI_bl_port=50001
      - SKOOR_UI_version=${SKOOR_VERSION}
      - SKOOR_AUTHHOST=eranger-auth-${INSTANCE_NAME}
      - SKOOR_WSADDR=http://eranger-webservice-${INSTANCE_NAME}:8090
      - SKOOR_SDAAS_WSHOST=eranger-etl-${INSTANCE_NAME}
      - SKOOR_VIEWER_ADDR=http://localhost
    depends_on:
      - eranger-postgresql
  eranger-pgbouncer:
    image: europe-docker.pkg.dev/sdaas-298209/eu.gcr.io/eranger-pgbouncer:${SKOOR_VERSION}
    container_name: eranger-pgbouncer-${INSTANCE_NAME}
    ports:
      - "5432"
    environment:
      - SKOOR_DB_SERVER=eranger-postgresql-${INSTANCE_NAME}
      - SKOOR_DB_NAME=ng
      - SDAAS_CUSTOMER_DB_LIST=data
    depends_on:
      - eranger-postgresql
  eranger-auth:
    image: europe-docker.pkg.dev/sdaas-298209/eu.gcr.io/eranger-auth:${AUTH_VERSION}
    container_name: eranger-auth-${INSTANCE_NAME}
    ports:
      - "8094"
    volumes:
      - "${PERSISTENT_FS}/engine/eranger:/var/opt/run/eranger"
    environment:
      - SKOOR_AUTH_listen_address=0.0.0.0
      - SKOOR_AUTH_engine_address=eranger-server-${INSTANCE_NAME}
    depends_on:
      - eranger-postgresql
  eranger-etl:
    image: europe-docker.pkg.dev/sdaas-298209/eu.gcr.io/eranger-etl:${ETL_VERSION}
    container_name: eranger-etl-${INSTANCE_NAME}
    ports:
      - "8093"
    volumes:
      - "${PERSISTENT_FS}/engine/eranger:/var/opt/run/eranger"
    environment:
      - SKOOR_ETL_webserviceUrl=http://eranger-webservice-${INSTANCE_NAME}:8090
      - SKOOR_ETL_address=0.0.0.0
      - SKOOR_ETL_collectorUser=skoor-etl-collector
    depends_on:
      - eranger-postgresql
  eranger-webservice:
    image: europe-docker.pkg.dev/sdaas-298209/eu.gcr.io/eranger-webservice-dashboards:${DASHBOARD_VERSION}
    container_name: eranger-webservice-${INSTANCE_NAME}
    ports:
      - "8090"
    volumes:
      - "${PERSISTENT_FS}/webservice/datasources:/opt/eranger/eranger-webservice/dataSources"
      - "${PERSISTENT_FS}/webservice/dataqueries:/opt/eranger/eranger-webservice/dataQueries"
      - "${PERSISTENT_FS}/webservice/files:/opt/eranger/eranger-webservice/files"
      - "${PERSISTENT_FS}/webservice/gis:/opt/eranger/eranger-webservice/gis"
      - "${PERSISTENT_FS}/webservice/reports:/opt/eranger/eranger-webservice/reports"
      - "${PERSISTENT_FS}/webservice/styles:/opt/eranger/eranger-webservice/styles"
      - "${PERSISTENT_FS}/webservice/translations:/opt/eranger/eranger-webservice/translations"
      - "${PERSISTENT_FS}/webservice/tmp:/opt/eranger/eranger-webservice/tmp"
      - "${PERSISTENT_FS}/webservice/webservice-cfg:/etc/opt/eranger"
    environment:
      - SKOOR_WEBSERVICE_eranger_address=eranger-server-${INSTANCE_NAME}
      - SKOOR_WEBSERVICE_db_host=eranger-pgbouncer-${INSTANCE_NAME}
      - SKOOR_WEBSERVICE_db_database=ng
      - SKOOR_DASHBOARD_etlService=true
      - SKOOR_WEBSERVICE_auth_service_url=http://eranger-auth-${INSTANCE_NAME}:8094
    depends_on:
      - eranger-postgresql
  sdaas-update:
    image: europe-docker.pkg.dev/sdaas-298209/eu.gcr.io/sdaas-update:${SKOOR_VERSION}
    container_name: eranger-update-${INSTANCE_NAME}
    volumes:
      - "$PERSISTENT_FS/engine:/mnt/customer"
      - "$PERSISTENT_FS/webservice:/mnt/webservice"
    environment:
      - NAME=${INSTANCE_NAME}
      - DB_IP=eranger-postgresql-${INSTANCE_NAME}
      - SINGLE_TENANT=true
      - SKOOR_DB_NAME=ng
      - SKOOR_VERSION=${SKOOR_VERSION}
    depends_on:
      - eranger-postgresql
  eranger-postgresql:
    image: europe-docker.pkg.dev/sdaas-298209/eu.gcr.io/${DATABASE_IMAGE}:${DATABASE_VERSION}
    container_name: eranger-postgresql-${INSTANCE_NAME}
    volumes:
      - "$POSTGRESQL_PATH:/var/lib/pgsql"
networks:
  default:
    name: skoor-network
    external: true

SKOOR-Container ausführen

docker compose up -d

Prüfen Sie die Protokolle:

docker compose logs

Prüfen Sie den Status der Container:

docker compose ps

Zugriff auf SKOOR

Öffnen Sie https://<Hostadresse> in einem Browser und melden Sie sich mit dem Benutzernamen admin und dem Passwort admin an.

Zurück
Wartung der Datenbank
Weiter
SKOOR Webservice Installation