[SPEC] Gestion de la configuration, des variable d'environnement et des flags.

Étapes :

Contexte

Dans le docker-compose qui est utilisé avec les images Docker des engines Go, ces engines sont lancés sans option, ou des options par défaut.

Par exemple, le service axe se sert de l'image engine-axe qui est lancée sans options

axe:
image: canopsis/engine-axe:${CANOPSIS_TAG}
env_file:
    - compose.env
restart: unless-stopped

Cependant, dans le moteur engine-axe, il existe plusieurs options, qui prennent des valeurs par défaut. Par exemple, l'option -printEventOnError n'est pas activée par défaut et le -publishQueue pointe vers Engine_action.

Objectif

Le but est de remettre à plat le paramétrage des engines tels que engine-che ou engine-axe en se basant sur un fichier de configuration, des variables d'environnements et des arguments de la ligne de commande.

Des entrées de l'utilisateur sont déjà pris en compte dans l'existant, le but est donc d'uniformiser le comportement pour toutes les options.

Spécification

La présentation des priorités est décroissante : les arguments de ligne de commande prennent les dessus sur les variables d'environnement, l'environnement est prioritaire sur un fichier .toml de configuration présent dans le container et le fichier a la priorité sur les valeurs par défaut stockés dans le binaire du moteur Go.

Arguments

On voudrait lancer les moteurs Go avec des arguments sur la ligne de commande.

Par exemple, dans ./engine-axe -d -publishQueue Engine_axe -mongo mongodb://cpsmongo:canopsis@mongodb/canopsis, certaines options sont déjà présentes et modifiables par l'utilsateur (-d pour activer le mode debug et -publishQueue qui définit la queue où pousser l'événement).

Les arguments entrés en ligne de commande sont prioritaires sur le reste et écrasent des valeurs qui seraient définies par un fichier de configuration ou par l'environnement.

Environnement

Si des arguments ne sont pas passés en ligne de commande, le moteur va chercher dans l'environnement les informations manquantes.

Si dans l'environnement le moteur ne trouve pas les variables nécessaires, il va chercher les données dans le fichier de configuration.

Exemple de variables d'environnement : CPS_URL, CPS_REDIS_URL, CPS_MAX_DELAY.

Fichier de configuration

Une des possibilités est de créer un fichier de configuration .toml qui sera lu par les moteurs.

Au démarrage du moteur, on lirait le fichier s'il existe et on chargerait les variables. Le chemin du fichier étant une valeur par défaut ou donné en argument au moteur.

Le fichier de configuration complète les informations par rapport aux potentielles variables d'environnement présentes et aux arguments de ligne de commandes manquantes.

Valeur par défaut dans les moteurs Go

Pour les informations indispensables à Canopsis, les moteurs Go vont devoir démarrer avec des valeurs par défaut.

Liste des variables utilisés par les moteur Go

Variables globales

Variable d'environnement	Description
`CPS_MONGO_URL`	Adresse du mongo
`CPS_AMQP_URL`	Adresse de l'AMQP
`CPS_REDIS_URL`	Adresse du redis
`CPS_INFLUX_URL`	Adresse de l'influxDB
`CPS_DEFAULT_CFG`	Chemin vers un fichier de configuration de Canopsis Par défaut `default_configuration.toml`

Le fichier de configuration Canopsis contient par défaut ces informations

[global]
PrefetchCount = 10000
PrefetchSize = 0

[alarm]
FlappingFreqLimit = 0
FlappingInterval = 0
StealthyInterval = 0
BaggotTime = "60s"
EnableLastEventDate = false

engine-action

Option	Description	Valeur par défaut
`-d`	Exécute le moteur en mode `debug`	`false`
`-version`	Affiche des informations sur la version du moteur	`false`

engine-axe

Option	Description	Valeur par défaut
`-autoDeclareTickets`	Crée les tickets automatiquement pour chaque alarme	`false`
`-d`	Exécute le moteur en mode `debug`	`false`
`-featureHideResources`	Active le Hide Resources Management	`false`
`-featureStatEvents`	Envoie les statistiques sur les événements	`false`
`-printEventOnError`	Affiche l'événement en cas d'erreur	`false`
`-publishQueue <string>`	Publie les événements sur cette queue	`Engine_action`
`-version`	Affiche des informations sur la version du moteur	`false`

engine-che

Option	Description	Valeur par défaut
`-consumeQueue <string>`	Définit la queue sur laquelle les événements sont consommés	`cps.CheQueueName`
`-createContext`	Autorise la création d'un context graph	`true`
`-d`	Exécute le moteur en mode `debug`	`false`
`-dataSourceDirectory <string>`	Exécute le moteur en mode `debug`	`"."`
`-enrichContext`	Autorise l'enrichissement d'un context graph à partir des événements	`true`
`-enrichExclude <string>`	Liste de champs à exclure de l'enrichissement	`""`
`-enrichInclude <string>`	Liste de champs qui constitueront l'enrichissement. Si `enrichInclude` est présent, `enrichExclude` sera ignoré.	`""`
`-printEventOnError`	Affiche l'événement en cas d'erreur	`false`
`-processEvent`	Autorise	`true`
`-publishQueue <string>`	Publie les événements sur cette queue	`Engine_event_filter`
`-purge`	Vide les consumer queue avant le départ du moteur	`false`
`-version`	Affiche des informations sur la version du moteur	`false`

engine-heartbeat

Option	Description	Valeur par défaut
`-version`	Affiche des informations sur la version du moteur	`false`

engine-stat

Option	Description	Valeur par défaut
`-d`	Exécute le moteur en mode `debug`	`false`
`-version`	Affiche des informations sur la version du moteur	`false`

engine-watcher

Pas d'options

feeder

Option	Description	Valeur par défaut
`-alarms <int>`	Pourcentage d'alarms	`20`
`-amqp`	Publie les events via amqp si `-file` est utilisé	`false`
`-authkey <string>`	Auth key de Canopsis. Doit être rempli si `-http` est activé	`os.Getenv("CPS_AUTH_KEY")`
`-checkJSON`	Vérifie la validité du JSON avant l'envoi	`true`
`-compstart <int>`	Exécute avec ce `component`	`0`
`-connstart <int>`	Exécute avec ce `connector`	`0`
`-dirty`	Activer le nettoyage d'événements par `engine-che`	`true`
`-exchange <string>`		`cps.CheExchangeName`
`-file <string>`		`event.json`
`-freq <duration>`	Fréquence d'envoi d'événements par les ressources et components	`time.Minute*5`
`-http`	Publier les événements via HTTP	`false`
`-loop`	Activer l'envoi d'événements en permanence	`false`
`-mode <string>`		`"feeder"`
`-ncomp <int>`	Nombre de components	`1200`
`-nconn <int>`	Nombre de connecteurs	`10`
`-nres <int>`	Nombre de ressources	`10`
`-resstart <int>`	Exécute avec cette `ressource`	`"feeder"`
`-url <string>`	L'adresse URL pour l'envoi des événements	`os.Getenv("CPS_URL")`
`-version`	Affiche des informations sur la version du moteur	`false`

init

Option	Description	Valeur par défaut
`-conf <string>`	Lien vers le fichier de configuration pour démarrer Canopsis	`DefaultCfgFile = "initialisation.toml"`
`-version`	Affiche des informations sur la version du moteur	`false`

ready

Option	Description	Valeur par défaut
`-retries <int>`	Nombre d'essais pour chaque check Si ça vaut 0, on teste de manière infinie	`10`
`-timeout`	Timeout lors d'un check	`time.Second*60`

Code

Les `dependencies.go`

Il faudra au moins ajouter dans le type Options défini dans le dependencies.go de chaque moteur :

MongoURL correspondant à l'argument mongoURL
RedisURL correspondant à l'argument redisURL
AmqpURL correspondant à l'argument amqpURL
InfluxURL correspondant à l'argument influxURL

`amqp.go`, `influx.go`, `mongo.go`, `redis.go`

Ces quatre fichiers créent une nouvelle session(NewSession()), ils utilisent une constante EnvURL qui va servir à lire la variable d'environnement associée (par exemple CPS_INFLUX_URL pour influx).

Il faut donc adapter le code pour que ces fichiers accepent l'argument d'un utilisateur en ligne de commande ou l'url venant d'une configuration déjà chargée.

`main.go`

Dans ces fichiers, les options viennent soit des arguments de ligne de commande soit des valeurs par défaut mises en dur dans le code.

flag.BoolVar(&opts.FeatureContextEnrich, "enrichContext", false, "enable context graph enrichment from event. disabled by default. WARNING: disable the old context-graph engine when using this.")
flag.StringVar(&opts.PublishToQueue, "publishQueue", "Engine_event_filter", "Publish event to this queue.")
flag.StringVar(&opts.ConsumeFromQueue, "consumeQueue", cps.CheQueueName, "Consume events from this queue.")

Il faut modifier (ou supprimer) cette partie de code de sorte à ce qu'on charge les données dans l'ordre convenu (ligne de commande, environnement, fichier .toml)

Suggestion de fichier de configuration `.toml`

[globals]
CPS_MONGO_URL="mongodb://cpsmongo:canopsis@canopsis:27017/canopsis"
CPS_AMQP_URL="amqp://cpsrabbit:canopsis@canopsis:5672/canopsis"
CPS_REDIS_URL="redis://localhost:6379/0"
CPS_INFLUX_URL="http://cpsinflux:canopsis@canopsis:8086"

[engine]

    [engine.action]
    # Pas de paramètres

    [engine.axe]
    autoDeclareTickets = true
    publishQueue = "Engine_action"
    # ...

    [engine.che]
    printEventOnError = true
    publishQueue = "Engine_action"
    # ...

    [engine.heartbeat]
    # Pas de paramètres

    [engine.stat]
    # Pas de paramètres

    [engine.watcher]
    # Pas de paramètres

    [engine.feeder]
    alarms = 50
    file = "/etc/file.json"
    # ...
    auth_key = "5f8978c-0665fab78" # Pour remplacer la variable d'environnement CPS_AUTH_KEY utilisé que dans feeder 
    url = "" # Pour remplacer la variable d'environnement CPS_URL utilisé que dans feeder

    [engine.init]
    cfg_file = "/opt/initialisation.toml"
    # Contient un tableau de RabbitMQ.exchanges et RabbitMQ.queues

    [engine.ready]

Edited Oct 13, 2020 by Dmitry Gega