Documentation

Docker Compose installation

Docker based SKOOR installations are for test purpose only and therefore not officially supported

Prerequisits

  • Linux OS

  • Docker / Docker-Compose

  • From SKOOR support (support@skoor.com):

    • A user key for the SKOOR Docker registry

    • A SKOOR license key

    • Versions of different SKOOR components

Prepare installation

Login to SKOOR docker registry (the file key.json must contain a valid Docker registry user key provided by SKOOR)

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

Create a Docker network

docker network create skoor-network

Set the SKOOR version to a value provided by SKOOR support (e.g. “7.3.0”)

export SKOOR_VERSION=<version>

Database

If no PostgreSQL server is available, a SKOOR PostgreSQL container can be deployed. In this guide, it is assumed a database container is needed. Therefore it will be configured in a docker-compose.yaml file. If there is a database server and no container is needed, the eranger-postgresql service must be removed from the docker-compose.yaml. Contact SKOOR support for details on configuring the database server.

Persistent filesystem

First, choose a filesystem path to store database files. The following guide assumes /var/lib/pgsql-docker as path. Please change it according to your preferences:

export PG_PATH=/var/lib/pgsql-docker

On the docker host, create user postgres with user and group id 26:

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

Prepare the directory for database files if necessary and set permissions:

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

Create database

Initialize the database and create a customer database

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

The warning “path "/var/opt/run/eranger" does not exist! Skipping!” can be ignored

The error “ERROR: a database error occured: (threadId:139786843920512) PGRES_FATAL_ERROR - FEHLER: Relation »alarms« does not exist” can be ignored

SKOOR containers

Persistent Filesystems

Add user eranger to the Docker host system for persistent filesystem permissions:

sudo useradd -u 909 -U -M eranger

Prepare a path for persistent filesystems (change to a meaningful path on the target system):

export PERSISTENT_FS=/home/skoor

SKOOR Engine

The SKOOR Engine needs a directory structure on the Docker host to store persistent files that are shared between the different containers. Create the path assumed in the docker-compose file later in this guide (feel free to choose another one):

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

SKOOR Webservice:

The SKOOR Webservice needs a directory structure as well to store persistent files and configurations. The following path is assumed in the docker-compose file later in this guide:

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

Initialize the SKOOR configuration

Set the INSTANCE_NAME variable to a simple name representing a SKOOR instance, such as a short company name.

Use characters or numbers only for the INSTANCE_NAME variable, no dashes or other special characters

export INSTANCE_NAME=<customer>

Run configuration script:

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

Create Docker Compose files

Create a Docker Compose directory:

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

Create the file .env inside the skoor directory: 

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

For use with StableNet® foreign data wrapper, set DATABASE_IMAGE to eranger-postgresql-stablenet and DATABASE_VERSION accordingly

All versions in this file are configured equally with the current minor release. However, the versions of different SKOOR components may change. Please ask SKOOR support for the latest versions

Create the file license.txt containing a valid SKOOR license. Example:

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

Add the license information to the Docker Compose .env file:

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

Create a docker-compose.yaml file with the following content:

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

Run SKOOR containers

docker compose up -d

Check the logs:

docker compose logs

Check the container status:

docker compose ps

Access SKOOR

Open https://<host address> in a browser and log in with username admin and password admin.

Previous
Database maintenance
Next
SKOOR Webservice Installation