Documentazione

Installazione di Docker Compose

Le installazioni di SKOOR basate su Docker sono solo a scopo di test e quindi non sono ufficialmente supportate.

Prerequisiti

  • Sistema operativo Linux

  • Docker / Docker-Compose

  • Dal supporto SKOOR (support@skoor.com):

    • una chiave utente per il registro Docker di SKOOR

    • Una chiave di licenza SKOOR

    • Versioni di diversi componenti di SKOOR

Preparare l'installazione

Accedere al registro Docker di SKOOR (il file key.json deve contenere una chiave utente valida per il registro Docker, fornita da SKOOR).

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

Creare una rete Docker

docker network create skoor-network

Impostare la versione di SKOOR su un valore fornito dal supporto SKOOR (ad esempio, "7.3.0").

export SKOOR_VERSION=<version>

Database

Se non è disponibile un server PostgreSQL, è possibile distribuire un contenitore PostgreSQL di SKOOR. In questa guida si presume che sia necessario un contenitore di database. Pertanto sarà configurato in un file docker-compose.yaml. Se esiste un server di database e non è necessario un contenitore, il servizio eranger-postgresql deve essere rimosso dal file docker-compose.yaml. Contattare l'assistenza SKOOR per informazioni sulla configurazione del server di database.

File system persistente

Per prima cosa, si deve scegliere il percorso del filesystem in cui memorizzare i file del database. La seguente guida assume come percorso /var/lib/pgsql-docker . Si consiglia di modificarlo in base alle proprie preferenze:

export PG_PATH=/var/lib/pgsql-docker

Sull'host docker, creare l'utente postgres con l'id 26 di utente e gruppo:

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

Preparare la directory per i file del database, se necessario, e impostare i permessi:

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

Creare il database

Inizializzare il database e creare un database clienti

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

Il warning "Il percorso "/var/opt/run/eranger" non esiste! Saltare!" può essere ignorato

L'errore "ERROR: si è verificato un errore del database: (threadId:139786843920512) PGRES_FATAL_ERROR - FEHLER: la relazione "allarmi" non esiste" può essere ignorato.

Contenitori SKOOR

Filesystem persistenti

Aggiungere l'utente eranger al sistema host Docker per i permessi del filesystem persistente:

sudo useradd -u 909 -U -M eranger

Preparare un percorso per i filesystem persistenti (cambiare in un percorso significativo sul sistema di destinazione):

export PERSISTENT_FS=/home/skoor

SKOOR Engine

Lo SKOOR Engine ha bisogno di una struttura di directory sull'host Docker per memorizzare i file persistenti che sono condivisi tra i diversi contenitori. Creare il percorso ipotizzato nel file docker-compose più avanti in questa guida (si può scegliere liberamente un altro):

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

SKOOR Webservice:

Anche lo SKOOR Webservice ha bisogno di una struttura di directory per memorizzare file e configurazioni persistenti. Il seguente percorso viene assunto nel file docker-compose più avanti in questa guida:

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

Inizializzare la configurazione di SKOOR

Impostare la variabile INSTANCE_NAME con un nome semplice che rappresenti un'istanza di SKOOR, ad esempio un nome breve di un'azienda.

Utilizzare solo caratteri o numeri per la variabile INSTANCE_NAME, senza trattini o altri caratteri speciali.

export INSTANCE_NAME=<customer>

Eseguire lo script di configurazione:

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

Creare i file di Docker Compose

Creare una cartella Docker Compose:

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

Creare il file .env all'interno della cartella 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

Per l'uso con il wrapper di dati esteri StableNet® , impostare DATABASE_IMAGE su eranger-postgresql-stablenet e DATABASE_VERSION di conseguenza.

Tutte le versioni di questo file sono configurate allo stesso modo con la minor release corrente. Tuttavia, le versioni dei diversi componenti di SKOOR possono cambiare. Chiedere al supporto SKOOR le versioni più recenti.

Creare il file license.txt contenente una licenza SKOOR valida. Esempio:

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

Aggiungere le informazioni sulla licenza al file .env di Docker Compose:

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

Creare un file docker-compose.yaml con il seguente contenuto:

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

Eseguire i contenitori SKOOR

docker compose up -d

Controllare i log:

docker compose logs

Controllare lo stato del contenitore:

docker compose ps

Accedere a SKOOR

Aprire https://<indirizzo host> in un browser e accedere con il nome utente admin e la password admin.

Precedente
Manutenzione del database
Successivo
Installazione dello SKOOR Webservice