13 mars 2015

Spring Cloud Config Server - Serveur de configuration des applications


Le serveur Spring Cloud Config Server permet de centraliser la configuration des applications des différents environnements.

Il peut être utilisé pour n'importe quelle application écrit dans n'importe quelle langage, ce n'est donc pas spécifique aux applications Spring. Cependant, son utilisation est facilitée pour les applications basées sur Spring Boot.

Il est capable de gérer les configurations des environnements de développement, d'intégration, de test jusqu'à la production.

Par défaut, il recherche les fichiers de configuration dans un répertoire situé sur un référentiel de source Git. Mais ceci peut être modifié pour rechercher les fichiers de configuration sur plusieurs référentiels Git. Il peut également rechercher les fichiers de configuration dans le classpath du serveur ou dans un répertoire sur le système de fichiers local au serveur de configuration.

En cas de modification d'un fichier sur le repository Git, cette modification sera prise en compte à la prochaine requête sur le serveur de configuration sans avoir besoin de redémarrer le serveur de configuration.

Les mots de passe et autres données sensibles peuvent être encryptées afin d'éviter de stocker les mots de passe en clair dans les fichiers de configuration sur le serveur de configuration.

Nous aurons à ajouter un fichier bootstrap.yml dans l'application cliente afin qu'elle recherche la configuration sur le serveur de configuration.

Documentation : http://cloud.spring.io/spring-cloud-config/spring-cloud-config.html

Création du serveur Spring Cloud Config Server

Nous créons une nouvelle application basée sur Spring Boot :
  • Aller sur le site Spring Initializr:
    • http://start.spring.io/
    • Renseigner les informations du projet avec comme nom "spring-config-server" par exemple
    • Ne pas sélectionner de dépendances
    • Cliquer sur "Generate project" pour télécharger le projet basé sur Spring Boot
    • Dézipper le projet
  • Dans le fichier pom.xml, remplacer le parent et ajouter la dépendance suivants :
  • Créer la classe Application.java avec l'annotation @EnableConfigServer:
  • Créer le fichier src/main/resources/application.yml:
    • en indiquant l'URL vers le repo Git contenant les fichiers de configuration ".properties" ou ".yml"
  • Démarrer le serveur de configuration:
    • mvn spring-boot:run

Fichiers de configuration sur Git

Sur le repository Github, nous avons les trois fichiers de configuration suivants:

Tester la récupération de la configuration

Nous testons que nous récupérons bien la configuration en fonction de l'environnement :

Environnement de développement

  • Aller sur la page suivante pour récupérer la configuration en développement:
    • http://localhost:8888/back/dev
      • Le serveur retourne le contenu des deux fichiers de configuration back.properties et back-dev.properties
        • {  
   "name":"dev",
   "label":"",
   "propertySources":[  
      {  
         "name":"https://github.com/lchaboud/springcloudconfig/back-dev.properties",
         "source":{  
            "name":"myapp-dev"
         }
      },
      {  
         "name":"https://github.com/lchaboud/springcloudconfig/back.properties",
         "source":{  
            "name":"myapp"
         }
      }
   ]
}

Environnement d'intégration

  • Aller sur la page suivante pour récupérer la configuration en intégration:
    • http://localhost:8888/back/integ
      • Le serveur retourne le contenu des deux fichiers de configuration back.properties et back-integ.properties
        • {  
   "name":"integ",
   "label":"",
   "propertySources":[  
      {  
         "name":"https://github.com/lchaboud/springcloudconfig/back-integ.properties",
         "source":{  
            "name":"myapp-integ"
         }
      },
      {  
         "name":"https://github.com/lchaboud/springcloudconfig/back.properties",
         "source":{  
            "name":"myapp"
         }
      }
   ]
}

Environnement de production

  • Aller sur la page suivante pour récupérer la configuration en production:
    • http://localhost:8888/back/prod
      • Le serveur retourne uniquement le contenu du fichier de configuration back.properties
        • {  
   "name":"prod",
   "label":"",
   "propertySources":[  
      {  
         "name":"https://github.com/lchaboud/springcloudconfig/back.properties",
         "source":{  
            "name":"myapp"
         }
      }
   ]
}

Application cliente

Récupérer la configuration depuis le serveur de configuration

Nous allons configurer une application basée sur Spring Boot afin qu'elle récupère son paramétrage depuis le serveur de configuration Spring Cloud Config Server.
  • Ajouter le fichier bootstrap.yml dans le répertoire src/main/resources du projet:
spring:
  application:
    name: back
  profiles:
    active: integration
  platform:
    config:
      uri: ${vcap.services.${PREFIX:}configserver.credentials.uri:http://user:password@localhost:8888}
encrypt:
  failOnError: false
, avec:
  • back: le nom de l'application, correspond au nom du fichier de configuration dans le serveur de configuration
  • integration: le nom du profil du fichier de configuration dans le serveur de configuration qui correspond au nom de l'environnement
  • http://user:paswword@localhost:8888: URL vers le serveur de configuration
Nous pouvons tester que le paramétrage est bien pris en compte via l'URL suivante qui est active par défaut sur les applications Spring Boot:
Nous voyons que :
  • le profil integration est actif sur l'application
  • les deux fichiers de configuration back.properties et back-integration.properties sont récupérés par l'application.

Nous pouvons tester que les paramètres du fichiers de configuration back-integration.properties écrasent ceux du fichier back.properties en ajoutant un service REST de test qui retourne la propriété name issue des fichiers de configuration:
  • Ajouter le contrôleur REST TestControler.java:
  • Redémarrer l'application
  • Aller sur la page suivante:
  • Cette page retourne la valeur de la propriété de configuration "name":
      • myapp-integ
Ceci indique bien que les propriétés du fichier de configuration back-integration.properties sur ceux du fichier de configuration back.properties.

En effet, back.properties contient les propriétés communes à tous les profils pour l'application back, alors que back-integration.properties s'applique uniquement au profil integration.

Spécifier le profil au démarrage de l'application cliente

Nous avons spécifié le nom du profil dans le fichier bootstrap.yml.

Cependant, il est possible de spécifier le profil au démarrage de l'application basée sur Spring Boot via l'argument --spring.profiles.active= :
  • Effectuer la packaging de l'application:
    • mvn package
  • Démmarrer l'application en spécifiant le profil:
    • java target/back-0.1.jar --spring.profiles.active=development
    , avec :
    • back-0.1.jar: le nom du jar construit par Maven
    • development: le nom du profil à appliquer dans l'environnment
  • Aller sur l'URL : http://localhost:8080/env

    • => Nous voyons que le profil actif est maintenant developement

Conclusion

Nous voyons que la mise en place d'un serveur de configuration Spring Cloud Config Server et la configuration d'une application basée sur Spring Boot est simple.

Ceci permet de centraliser la configuration des applications afin de simplifier le déploiement sur les différents environnement. Nous n'avons plus qu'à spécifier le nom du profil dans la ligne de commande de démarrage de l'application.

Nous pouvons gérer l'ensemble des fichiers de configurations des différents environnements à partir d'un repo Git unique.

Il reste à :

  • mettre en place le chiffrement des données sensibles dans les fichiers de configuration comme les mots de passe.
  • ajouter l'authentification au niveau du serveur de configuration.

Références

Libellés :