Les installations de SKOOR basées sur Docker sont uniquement destinées à des fins de test et ne sont donc pas officiellement prises en charge.

Conditions préalables

Système d'exploitation Linux
Docker / Docker-Compose
Du support SKOOR (support@skoor.com) :
- Une clé d'utilisateur pour le registre Docker de SKOOR
- Une clé de licence SKOOR
- Versions des différents composants de SKOOR

Préparer l'installation

Connectez-vous au registre Docker de SKOOR (le fichier key.json doit contenir une clé d'utilisateur valide du registre Docker fournie par SKOOR).

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

Créer un réseau Docker

docker network create skoor-network

Définir la version de SKOOR à une valeur fournie par le support SKOOR (par exemple "7.3.0")

export SKOOR_VERSION=<version>

Base de données

Si aucun serveur PostgreSQL n'est disponible, un conteneur SKOOR PostgreSQL peut être déployé. Dans ce guide, il est supposé qu'un conteneur de base de données est nécessaire. Il sera donc configuré dans un fichier docker-compose.yaml. S'il existe un serveur de base de données et qu'aucun conteneur n'est nécessaire, le service eranger-postgresql doit être supprimé du fichier docker-compose.yaml. Contactez l'assistance SKOOR pour plus de détails sur la configuration du serveur de base de données.

Système de fichiers persistant

Tout d'abord, choisissez un chemin d'accès au système de fichiers pour stocker les fichiers de la base de données. Le guide suivant suppose que le chemin est /var/lib/pgsql-docker . Veuillez le modifier en fonction de vos préférences :

export PG_PATH=/var/lib/pgsql-docker

Sur l'hôte docker, créez l'utilisateur postgres avec l'id d'utilisateur et de groupe 26 :

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

Préparez le répertoire pour les fichiers de base de données si nécessaire et définissez les autorisations :

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

Create database

Initialiser la base de données et créer une base de données client

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

L'avertissement "path "/var/opt/run/eranger" does not exist ! Sauter !" peut être ignoré

L'erreur "ERROR : a database error occured : (threadId:139786843920512) PGRES_FATAL_ERROR - FEHLER : Relation "alarms" does not exist" peut être ignorée.

Conteneurs SKOOR

Systèmes de fichiers persistants

Ajouter l'utilisateur eranger au système hôte Docker pour les permissions sur les systèmes de fichiers persistants :

sudo useradd -u 909 -U -M eranger

Préparer un chemin pour les systèmes de fichiers persistants (changer pour un chemin significatif sur le système cible) :

export PERSISTENT_FS=/home/skoor

SKOOR Engine

SKOOR Engine a besoin d'une structure de répertoires sur l'hôte Docker pour stocker les fichiers persistants qui sont partagés entre les différents conteneurs. Créez le chemin supposé dans le fichier docker-compose plus loin dans ce guide (n'hésitez pas à en choisir un autre) :

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

SKOOR Webservice :

Le SKOOR Webservice a également besoin d'une structure de répertoire pour stocker les fichiers persistants et les configurations. Le chemin suivant est supposé dans le fichier docker-compose plus loin dans ce guide :

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

Initialiser la configuration SKOOR

Définissez la variable INSTANCE_NAME à un nom simple représentant une instance SKOOR, tel qu'un nom de société court.

Utilisez uniquement des caractères ou des chiffres pour la variable INSTANCE_NAME, pas de tirets ni d'autres caractères spéciaux.

export INSTANCE_NAME=<customer>

Exécuter le script de configuration :

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

Créer des fichiers Docker Compose

Créez un répertoire Docker Compose :

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

Créer le fichier .env dans le répertoire 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

Pour une utilisation avec le wrapper de données étrangères StableNet®, définir DATABASE_IMAGE à eranger-postgresql-stablenet et DATABASE_VERSION en conséquence.

Toutes les versions de ce fichier sont configurées de la même manière avec la version mineure actuelle. Cependant, les versions des différents composants de SKOOR peuvent changer. Veuillez demander au support de SKOOR les dernières versions.

Créez le fichier license.txt contenant une licence SKOOR valide. Exemple :

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

Ajoutez les informations de licence au fichier .env de Docker Compose :

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

Créez un fichier docker-compose.yaml avec le contenu suivant :

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

Exécuter les conteneurs SKOOR

docker compose up -d

Vérifier les journaux :

docker compose logs

Vérifier l'état des conteneurs :

docker compose ps

Accéder à SKOOR

Ouvrez https://<adresse de l'hôte> dans un navigateur et connectez-vous avec le nom d'utilisateur admin et le mot de passe admin.

Documentation

Installation de Docker Compose