Configuration et paramétrage d'une application

 Après l'installation d'un logiciel, il est souvent nécessaire de faire quelques réglages pour améliorer le confort d'utilisation ou adapter le comportement du logiciel à nos besoins. Il est ainsi possible de changer la langue de l'application, activer des plugins, modifier les valeurs par défaut…

Voici quelques conseils pour gérer au mieux la configuration d'une application.

Configuration par défaut

Pendant l'installation d'un logiciel, on nous propose parfois de modifier quelques paramètres, comme le dossier d'installation ; mais le reste de la configuration hérite de la configuration par défaut défini par l'éditeur du logiciel.

Cette configuration par défaut est souvent prévue pour répondre à la majorité des cas utilisateurs. On appelle également ce principe convention over configuration. Cela permet d'alléger la configuration à maintenir.

Séparer la configuration du code source

L'intérêt de la configuration est de pouvoir réutiliser la même application dans différents contextes. Dans le schéma ci-dessous "l'application A" est utilisée dans différents enivrements; mais chaque environnement à une configuration distincte.

La configuration d'une application doit être au maximum découplée de l’application.

Il faut éviter au maximum d'embarquer des valeurs de configuration dans le code d'une application (hard coded).

Dans le code Java ci-dessous la devise monétaire a une valeur fixe ; modifiable seulement en recompilant l'application.

// Mauvais exemple

// fichier Settings.java
class Settings {
private static final String CURRENCY = "EUR";

    public String getCurrency(){
        retrun CURRENCY;
    }

}

Une meilleure stratégie est de créer un fichier distinct pour la configuration, et de proposer une valeur par défaut.

Je propose que la devise configurée par défaut soit le dollar américain (USD) car elle est la plus utilisée dans le monde.

  1. Je surchage cette configuration avec l'ajout d'un fichier de configuration :
    • Mon client me demande de définir la devise à EUR.
  2. Au démarage de l'application, le fichier de configuration application.properties est lu en premier. En cas d'absence de ce fichier (ou la propriété n'est pas définie), la devise par défault (USD) est utilisée.
# fichier application.properties
app.currency = EUR
// fichier Settings.java
class Settings {
private final String currency;
private static final String CURRENCY_DEFAULT = "USD";

    private Settings {
        try (InputStream input = this.getClassLoader().getResourceAsStream("application.properties")) {
            Properties prop = new Properties();
            prop.load(input);
            this.currency = prop.getProperty("app.currency");
        }
        if(this.currency == null){
            this.currency = CURRENCY_DEFAULT;
        }
    }

    public String getCurrency(){
        retrun this.currency;
    }

}

Documenter la configuration

Au même titre que la documentation utilisateur, il est important de fournir une référence des différents paramètres que l'on peut configurer. IL faut indiquer si le paramètre est obligatoire, la valeur par défaut, le format de la donnée attendue (unité, valeur min/max)…

Voici quelques exemples :

  • Liste des paramètres de configuration Spring Boot
  • Liste des paramètres de configuration MySQL

Na pas mélanger les configurations selon les environnements

Il n'est souvent pas possible d'utiliser la même configuration dans tous les environnements de travail. Ainsi les développeurs utilisent souvent des paramètres de sécurité moins stricte qu'en production (pour des raisons de confort principalement) et autres petits arrangements. Faites attention de ne pas propager ces configurations "permissives" aux autres environnements de travail, comme en production.

Modification à chaud, à froid

Après le démarrage d'une application, vous décider de modifier la configuration d'une application :

  • Si votre application supporte le mode hot reload la modification est prise en compte immédiatement.
  • D'autres application propose un moyen de déclenchement manuel (comme cliquer sur un bouton) pour forcer le rechargement de la configuration.
  • Dans les autres cas, il est nécessaire de redémarrer le logiciel pour prendre en compte les modifications de la configuration.

Stocker les paramètres de configuration

La configuration peut être gérée par différents moyens : base de données, variables d'environnement, fichiers...

Voyons quelques exemples.

Base de données

Les navigateurs Chrome et Firefox utilisent une base de données relationnelles embarquées SQLite pour gérer la configuration.

Base de registre

Beaucoup de logiciels Microsoft (comme Windows ou la suite Office) stockent les paramètres dans la base de registre .

Variable d'environnement

Les variables d’environnement sont des variables définies au niveau du système d'exploitation (Windows ou Linux) et accessibles par toutes les applications.

Configuration par fichiers

La configuration par fichier texte est assez classique. Il existe cependant plusieurs "dialectes" couramment utilisés, selon le gôut des développeurs et la "tendance" actuelle.

Ainsi la configuration XML était très utlisées dans les projets il y a une vingtaine d'années. Les logiciels "modernes" (orientés DevOps/Cloud) sont très friands de YAML, à la syntaxe plus consise que XML.

XML

Exemple de configuration en syntaxe XML d'un projet Java construit avec Apache Maven.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.mycompany.app</groupId>
<artifactId>my-app</artifactId>
<version>1.0-SNAPSHOT</version>

  <properties>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

JSON

Exemple de configuration en syntaxe JSON d'un projet Node.js.

{
  "name": "test-project",
  "version": "1.0.0",
  "main": "src/main.js",
  "private": true,
  "scripts": {
    "start": "npm run dev",
    "test": "npm run unit",
    "build": "node build/build.js"
  },
  "dependencies": {
    "vue": "^2.5.2"
  },
  "devDependencies": {
    "autoprefixer": "^7.1.2",
    "babel-core": "^6.22.1",
    "babel-eslint": "^8.2.1",
    "webpack-merge": "^4.1.0"
  },
  "browserslist": [
    "> 1%",
    "last 2 versions",
    "not ie <= 8"
  ]
}

YAML

Exemple de configuration en syntaxe YAML d'un déploiement Kubernetes.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: 'nginx:1.7.9'
        ports:
        - containerPort: 80



Antoine ; 10 octobre 2019