Ce guide décrit l'installation des paquets RPM à l'aide de yum.

Conditions préalables

Désactiver SELinux

Avant d'installer SKOOR Engine, SELINUX doit être désactivé. Affichez l'état de SELinux :

sestatus

Vérifier si le mode est "enforcing" :

SELinux status:                 enabled
...
Current mode:                   enforcing

Si c'est le cas, passez-le au moins en mode permissif ou désactivez-le en modifiant la configuration SELinux :

vi /etc/selinux/config

Modifier la configuration pour qu'elle soit permissive ou désactivée :

SELINUX=disabled

Activer la configuration et vérifier avec sestatus :

setenforce 0 

Autoriser le cron pour les utilisateurs

Si cron est restreint, les utilisateurs nécessaires au logiciel SKOOR doivent être autorisés à accéder à cron en les ajoutant au fichier suivant :

/etc/cron.allow

Utilisateurs :

postgres
eranger
reranger

Empreintes GPG du référentiel SKOOR :

RPM-GPG-KEY-SKOOR :

RPM-GPG-KEY-PGDG :

RPM-GPG-KEY-TIMESCALEDB :

Installation de SKOOR Engine (Serveur unique)

Installation de PostgreSQL

PostgreSQL 13 est le serveur de base de données nécessaire à SKOOR Engine. Il doit être installé avant le logiciel SKOOR :

Installez le serveur PostgreSQL à l'aide du package d'installation SKOOR PostgreSQL :

dnf install eranger-postgresql

Ce paquetage exécute les étapes suivantes :

• Installe postgresql13-server, timescaledb-2-postgresql-13, eranger-database-utils par le biais de ses dépendances.

• Initialisation d'un cluster de base de données à l'aide de initdb

• Tunes postgresql.conf pour TimescaleDB

• Initialise une base de données (base de données simple, sans schéma ni données) qui peut être utilisée par le serveur SKOOR Server.

• Ouvre le port TCP 5432 sur le pare-feu.

Installation de PgBouncer

PgBouncer est utilisé comme pool de connexion et se place entre SKOOR et le serveur PostgreSQL.

Installez PgBouncer en utilisant le package d'installation SKOOR PgBouncer :

dnf install eranger-pgbouncer

Ce paquetage effectue les étapes suivantes :

• Installer pgbouncer avec ses dépendances.

• Reconfigurer PostgreSQL (postgresql.conf)

  • listen_addresses = 'localhost' n'écoute que les connexions locales

  • unix_socket_directories = '/var/run/postgresql-backend' ne pas utiliser le socket UNIX par défaut de PostgreSQL

  • max_connections = 300 autoriser 300 connexions

• Configure PgPool

  • listen_addr = *

  • listen_port = 5432

  • unix_socket_dir = /var/run/postgresql

  • max_client_conn = 300

  • default_pool_size = 60

Installation standard du serveur

Pour les clients qui n'ont besoin que de l'ensemble des logiciels de base (c'est-à-dire la plupart des clients), exécutez la commande suivante pour installer les paquets nécessaires :

dnf install eranger-server

Vérifier les paquets SKOOR Engine installés :

dnf list installed |grep eranger

Résultat attendu :

eranger-agent.x86_64                      <version>
eranger-auth.x86_64                       <version>
eranger-collector.x86_64                  <version>
eranger-collector-eem.x86_64              <version>
eranger-collector-mail.x86_64             <version>
eranger-common.x86_64                     <version>
eranger-database-utils.x86_64             <version>
eranger-doc.x86_64                        <version>
eranger-nodejs.x86_64                     <version>
eranger-postgresql.x86_64                 <version>
eranger-pymodules.x86_64                  <version>
eranger-report.x86_64                     <version>
eranger-server.x86_64                     <version>
eranger-syncfs.x86_64                     <version>
eranger-ui.x86_64                         <version>

sed -i 's/enabled=1/enabled=0/g' /etc/yum.repos.d/google-chrome.repo

Installation de SKOOR Engine Collector

Depuis la version 5.5, il existe deux options pour un collecteur externe : l'installation complète et l'installation de base. L'installation de base comporte un ensemble limité de fonctionnalités et moins de dépendances et peut être étendue ultérieurement à une installation complète avec des paquets supplémentaires.

Installation complète de SKOOR Engine Collector :

Pour installer un SKOOR Engine Collector externe, utilisez la commande suivante pour l'installation complète :

dnf install eranger-collector eranger-collector-eem eranger-collector-mail

Installation SKOOR Engine Collector de base :

Pour installer un SKOOR Engine Collector externe de base, utilisez la commande suivante :

dnf install eranger-collector

Paquets supplémentaires pour le SKOOR Engine Collector minimal :

Pour activer les Jobs EEM sur le collecteur externe, vous pouvez installer le plugin avec la commande suivante :

dnf install eranger-collector-eem

Pour activer les tâches de messagerie (EWS, IMAP, POP3 ou SMTP) sur le collecteur externe, vous pouvez installer le plugin avec la commande suivante :

dnf install eranger-collector-mail

Communication avec SKOOR Engine

Après l'installation d'un nouveau collecteur externe, la communication avec SKOOR Engine doit être configurée. La section suivante montre les différentes possibilités pour y parvenir.

Généralités

Pour SKOOR Engine, un collecteur est un type spécial d'utilisateur. Chaque collecteur externe doit donc être configuré dans l'interface utilisateur. Créez un utilisateur authentifié localement avec le rôle Collecteur dans /root /Users /Users et définissez un mot de passe.

La suite de la configuration se fait dans le fichier de configuration des collecteurs sur le serveur de collecteurs :

/etc/opt/eranger/eranger-collector.cfg

Tout d'abord, le server_id du SKOOR Engine doit être identifié. Sur l'hôte SKOOR Engine, ouvrez le fichier eranger-server.cfg :

/etc/opt/eranger/eranger-server.cfg

Trouvez le paramètre server_id dans la configuration (si commenté comme dans l'exemple suivant, l'id est 1) :

#server_id      = 1

TCP

C'est la façon standard dont les collecteurs communiquent avec SKOOR Engine. La communication n'est pas cryptée.

Les paramètres suivants doivent être configurés dans le fichier eranger-collector.cfg :

• Définissez le paramètre server1_id sur la valeur configurée sur le serveur SKOOR Engine en tant que server_id (la valeur par défaut est 1).

• Définir le paramètre server1_address à la valeur du nom d'hôte ou de l'adresse IP de SKOOR Engine (les sockets unix ne sont utilisés que pour les collecteurs locaux).

• Définir server1_user et server1_passwd comme configuré dans SKOOR Engine
  

server1_id            = 1
server1_address        = 10.10.10.10
#server1_port           = 50001
#server1_domain         =
server1_user           = collector-user
server1_passwd         = collector-password
#server<server_id>_fetch_parse_dir (server_id instead of index)!
#server1_fetch_parse_dir= /var/opt/run/eranger/collector/tmp

HTTP/HTTPS

La section suivante décrit comment configurer une communication cryptée à l'aide de HTTPS. Pour le cryptage, le certificat de l'autorité de certification racine utilisé par le serveur SKOOR Engine doit être copié sur le système collecteur. Les chemins Linux standard peuvent être utilisés pour le placer dans le système de fichiers.

Configurez les paramètres requis dans le fichier eranger-collector.cfg :

• Définissez le paramètre server1_id à la valeur configurée sur le serveur SKOOR Engine en tant que server_id (la valeur par défaut est 1).

• Définissez le paramètre server1_address à la valeur du nom d'hôte ou de l'adresse IP de SKOOR Engine sous la forme d'une URL comme indiqué ci-dessous.

• Assurez-vous que le paramètre server1_port est commenté, sinon la communication sera interrompue.

• Définissez server1_user et server1_passwd comme configuré dans SKOOR Engine

• Configurez server1_ssl_cacert ou server1_ssl_capath à l'emplacement où le certificat a été copié auparavant.
  

server1_id            = 1
server1_address        = https://10.10.10.10/skoor-collector
#server1_port           = 50001
#server1_domain         =
server1_user           = collector-user
server1_passwd         = collector-password
#server<server_id>_fetch_parse_dir (server_id instead of index)!
#server1_fetch_parse_dir= /var/opt/run/eranger/collector/tmp
server1_ssl_cacert     = /etc/pki/tls/certs/rootCA.pem

HTTPS avec authentification du client

L'authentification du client doit d'abord être activée sur SKOOR Engine. Pour ce faire, ouvrez le fichier de configuration du serveur web concerné :

/etc/httpd/conf.d/skoor-engine-over-http.conf

Décommenter la directive SSLVerifyClient :

<Location "/skoor-collector">
        ExpiresActive On
        ExpiresDefault "now"
        ProxyPass http://localhost:50080 retry=0 connectiontimeout=15 timeout=30
    SSLVerifyClient require
</Location>

Recharger httpd :

systemctl reload httpd

server1_ssl_cacert

server1_ssl_capath

server1_ssl_verify_peer

server1_ssl_verify_host

server1_ssl_cert_client_public_key

server1_ssl_cert_client_private_key

server1_ssl_cert_client_private_key_passwd

Licence de SKOOR Engine

Obtenez une licence valide auprès de SKOOR et ajoutez les lignes nécessaires au fichier :

/etc/opt/eranger/eranger-server.cfg

Exemple avec une licence de 1000 appareils :

license_name   = Example customer
license_feature_set = 3.1
license_devices= 1000
license_key    = xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

xxxx... représente la clé de licence actuelle. Veillez à ce que la clé réelle soit insérée sur une seule ligne, sans caractères de retour à la ligne entre les deux.

Configuration de SKOOR Engine

Développez la variable PATH pour la racine :

~/.bashrc

Ajouter :

PATH=$PATH:/opt/eranger/bin

Appliquez ensuite les modifications et exécutez eRanger.sh start pour démarrer les services de SKOOR Engine :

. ~/.bashrc

eRanger.sh start

===========================================================================
 Choose command                                 eRanger Version 5.0.0

 Command - Action       - Object                - Current State
===========================================================================

 1       - start        - eRanger Server        - started
 2       - start        - eRanger Collector     - started
 3       - start        - eRanger Report        - started
 4       - start        - eRanger Agent         - started
 a       - start        - all above
 9       - start        - eRanger Webservice    - started
 11      - start        - PostgreSQL            - started
 12      - start        - Rsyslog               - started
 13      - start        - Trapd                 - stopped
 14      - start        - Httpd                 - started
 15      - start        - Smsd                  - stopped
 16      - start        - Postfix               - started

 r       - Switch to restart mode
 S       - Switch to stop mode
 c       - Current eRanger status
 0       - do_exit program

Enter selection:

Entrez a pour démarrer tous les services requis. Quittez ensuite en tapant 0.

Connexion à SKOOR Engine

Il est maintenant possible de se connecter à SKOOR Engine en utilisant un navigateur web et en entrant le FQDN ou l'adresse IP de SKOOR Engine dans la barre d'adresse :

Les identifiants de connexion par défaut sont les suivants

Après une installation par défaut, le navigateur se plaint de certificats de sécurité SSL non fiables. Vous pouvez soit accepter le certificat auto-signé par défaut, soit générer et installer un certificat SSL personnalisé.

Par défaut, les certificats sont situés sous :

/etc/pki/tls/certs/

Le fichier de configuration

/etc/httpd/conf.d/eranger.conf

doit être modifié pour pointer vers les bons certificats. Un exemple d'entrée ressemble à ceci :

SSLCertificateFile /etc/pki/tls/certs/wildcard_mycompany.ch.crt
SSLCertificateKeyFile /etc/pki/tls/private/private-key_mycompany.ch.key 

Lors de l'appel à http://skoor.company.com, le serveur web réécrira l'adresse pour utiliser https au lieu de http. Si seul http doit être utilisé, désactivez la règle de réécriture dans le fichier de configuration :

/etc/httpd/conf.d/eranger.conf

Commentez les trois lignes suivantes (en mettant un signe dièse au début) :

# RewriteEngine On
# RewriteCond %{HTTPS} !=on
# RewriteRule ^/?(.*) https://%{SERVER_NAME}/$1 [R,L]

Redémarrez le serveur web Apache avec la commande :

eRanger.sh restart httpd

ou :

systemctl restart httpd

Optimisation de SKOOR sur des environnements virtuels

Si vous exécutez SKOOR Engine ou SKOOR Collector à l'intérieur d'une machine virtuelle, le Scheduler IO doit être adapté pour des raisons de performance. Par défaut, Red Hat < 7 s'installe avec le planificateur d'entrées-sorties cfq. Le planificateur d'E/S recommandé pour les systèmes Red Hat fonctionnant dans une machine virtuelle est le planificateur noop sur Red Hat 7 et le planificateur none sur Red Hat 8 / 9.

Pour les systèmes Red Hat 7

Exécutez les commandes suivantes pour activer le planificateur noop pour un système en cours d'exécution pour le périphérique de bloc sda qui correspond généralement au premier disque :

# echo noop > /sys/block/sda/queue/scheduler
# cat /sys/block/sda/queue/scheduler
[noop] anticipatory deadline cfq

Le planificateur noop est maintenant marqué comme le planificateur actuel. Exécutez cette commande pour chacun des disques virtuels configurés pour le système (remplacez sda par le nom du disque virtuel).
Cependant, le paramètre ci-dessus ne persistera pas lors des redémarrages. Suivez le guide suivant pour activer le scheduler noop de manière persistante.

Définissez noop globalement pour tous les périphériques en modifiant the file /etc/default/grub comme indiqué ci-dessous, puis en reconstruisant le fichier de configuration de grub2 :

# vi /etc/default/grub
...
GRUB_CMDLINE_LINUX="crashkernel=auto rd.lvm.lv=rhel00/root rd.lvm.lv=rhel00/swap"                            (before)
GRUB_CMDLINE_LINUX="crashkernel=auto rd.lvm.lv=rhel00/root rd.lvm.lv=rhel00/swap elevator=noop"              (after)
...

# grub2-mkconfig -o /boot/grub2/grub.cfg                                                                     (on BIOS-based machines)
# grub2-mkconfig -o /boot/efi/EFI/redhat/grub.cfg                                                            (on UEFI-based machines)

Pour les systèmes Red Hat 8 / 9

Exécutez les commandes suivantes pour activer l'ordonnanceur noop pour un système en cours d'exécution pour le périphérique de bloc sda qui correspond généralement au premier disque :

# echo none > /sys/block/sda/queue/scheduler
# cat /sys/block/sda/queue/scheduler
[none] mq-deadline kyber bfq

Le planificateur none est maintenant marqué comme le planificateur actuel. Exécutez cette commande pour chacun des disques virtuels configurés pour le système (remplacez sda par le nom du disque virtuel).
Cependant, le paramètre ci-dessus ne persistera pas lors des redémarrages. Suivez le guide suivant pour activer le Scheduler none de manière persistante.

Définissez globalement none pour tous les périphériques en modifiant the file /etc/default/grub comme indiqué ci-dessous, puis en reconstruisant le fichier de configuration de grub2 :

# vi /etc/default/grub
...
GRUB_CMDLINE_LINUX="crashkernel=auto resume=/dev/mapper/rh9-swap rd.lvm.lv=rh9/root rd.lvm.lv=rh9/swap"                            (before)
GRUB_CMDLINE_LINUX="crashkernel=auto resume=/dev/mapper/rh9-swap rd.lvm.lv=rh9/root rd.lvm.lv=rh9/swap elevator=none"              (after)
...

# grub2-mkconfig -o /boot/grub2/grub.cfg                                                                     (on BIOS-based machines)
# grub2-mkconfig -o /boot/efi/EFI/redhat/grub.cfg                                                            (on UEFI-based machines)

Création d'un dépôt yum

Dans le cas où les collecteurs distants n'ont pas accès aux dépôts Red Hat mais que SKOOR Engine y a accès, il peut être utile de créer un dépôt de logiciels simple sur le serveur qui contient tous les fichiers RPM utilisés pour l'installation via yum. Le référentiel sera accessible aux hôtes collecteurs via le port 443 qui est déjà un port ouvert. Voici les étapes nécessaires à la mise en place d'un tel dépôt et à son accès depuis un collecteur distant :

Créez le répertoire racine du référentiel et copiez tous les fichiers RPM nécessaires :

# cd /srv/eranger/html
# mkdir repo
# cp /path/to/*.rpm repo/
# yum install createrepo
# createrepo ./repo

Remplacez /chemin/vers/ ci-dessus par le chemin où les fichiers RPM requis ont été copiés sur l'hôte SKOOR Engine. Cela créera un nouveau sous-répertoire nommé repodata à l'intérieur du répertoire repo.

Ajoutez maintenant le dépôt comme source d'installation de paquetages sur des hôtes distants (par exemple, un hôte collecteur de SKOOR Engine) :

# vi /etc/yum.repos.d/SKOOR.repo

[SKOOR]
name=SKOOR
baseurl=https://<ip or hostname of repository>/repo/
sslverify=false
gpgcheck=0
enabled=1

Vérifiez l'accès au répertoire nouvellement ajouté à partir de l'hôte distant :

# yum clean all
# yum repolist 

L'hôte distant peut maintenant installer un logiciel en utilisant le référentiel SKOOR comme source de paquets.

Ajout d'un DVD ou d'un CD en tant que référentiel

Pour installer un logiciel à partir d'un lecteur de DVD ou de CD RedHat inséré, ajoutez un nouveau dépôt en créant le fichier suivant :

vi /etc/yum.repos.d/RHEL_6.5_DVD.repo

[RHEL_6.5_DVD]
name=RHEL_6.5_DVD
baseurl="file:///cdrom/"
gpgcheck=0