Meilleures pratiques pour gérer un grand nombre de fichiers de configuration / propriété structurés

Imaginez un système qui possède un grand nombre de serveurs. Chacun d'eux a un certain nombre de paramètres:

• Certains spécifiques au serveur
• Certains spécifiques à la région
• Certains communs à tous
• Peut-être que vous pouvez avoir des regroupements personnalisés, comme ce groupe de serveurs est en lecture seule
• etc.

La pratique actuelle que j'ai à l'esprit est une structure de propriété simple avec des capacités primordiales.

Prenons les serveurs Google aux fins de l'exemple. Chacun d'eux a une liste de paramètres à charger.

Par exemple, le serveur de Londres peut avoir:

rootsettings.properties, europesettings.properties, londonsettings.properties, searchengine.properties, Etc.

Lorsque chaque fichier contient un ensemble de propriétés et la séquence de chargement vous permet de remplacer les propriétés, plus vous allez loin.

Par exemple: rootsettings.propertiespeut avoir accessible=falsepar défaut, mais est remplacé par searchengine.propertiesavecaccessible=true

Le problème que j'ai avec cette structure est qu'il est très facile de devenir incontrôlable. Il n'est pas du tout structuré, ce qui signifie que vous pouvez définir n'importe quelle propriété à n'importe quel niveau et que de nombreux éléments peuvent devenir obsolètes.

De plus, changer un niveau intermédiaire devient impossible à mesure que le réseau se développe, car vous affectez maintenant un très grand nombre de serveurs.

Enfin et surtout, chaque instance individuelle peut avoir besoin d'une propriété spéciale, ce qui signifie que votre arbre se retrouve avec une configuration pour chaque serveur de toute façon, ce qui en fait une solution peu optimale.

J'apprécierais grandement si vous avez des suggestions / idées d'une meilleure architecture de gestion de configuration.

Je pense que vous devez d'abord vous poser quelques questions et clarifier certains points, puis vous pourrez mieux décider comment résoudre votre problème.

Premièrement: qui doit contrôler les serveurs?

• S'agit-il d'un seul administrateur qui va contrôler des centaines de serveurs? Ensuite, vous devez centraliser la configuration autant que possible.

• Ou chaque serveur est-il potentiellement sous le contrôle d'un administrateur individuel, qui ne veut pas que ses paramètres soient annulés ou contrôlés par une configuration centralisée? Ensuite, vous devez vous concentrer sur la configuration décentralisée. Si chaque administrateur a une poignée de serveurs à gérer au maximum, cela est toujours gérable manuellement.

Deuxièmement: avez-vous vraiment besoin de tonnes d'options de configuration, ou pouvez-vous limiter le nombre à quelques-unes? Au lieu de rendre tout et tout configurable "au cas où", mieux vous limiter aux options dont vous savez que votre système a vraiment besoin. Cela peut être fait, par exemple, par

• rendre votre logiciel un peu plus intelligent (par exemple, qu'est-ce que le programme peut déterminer automatiquement en demandant à l'environnement)?

• suivre rigoureusement la «convention sur la configuration» - par exemple, en établissant certaines conventions de dénomination ou en dérivant certaines options par défaut à partir d'autres options

Troisièmement: voulez-vous vraiment un niveau hiérarchique de configuration codé en dur dans le logiciel? Imaginez que vous ne savez pas à l'avance combien de serveurs il y aura, si une hiérarchie arborescente est vraiment la meilleure structure pour eux, ou combien de niveaux l'arborescence doit avoir. La solution la plus simple à laquelle je peux penser est de ne fournir aucune configuration centralisée, un seul fichier de configuration par serveur et de laisser les administrateurs de serveurs responsables décider eux-mêmes comment ils résolvent le problème de la gestion des configurations de plusieurs serveurs.

Par exemple, les administrateurs peuvent écrire des scripts de générateur qui distribuent un fichier de configuration central à un groupe de serveurs différents et apportent des modifications mineures à chaque copie. De cette façon, vous n'avez pas à faire d'hypothèses sur la "topologie de distribution de serveur" au préalable, la topologie peut être ajustée à tout moment aux exigences du monde réel. L'inconvénient est que vous avez besoin d'administrateurs ayant une certaine connaissance de la façon d'écrire des scripts dans un langage comme Perl, Python, Bash ou Powershell.

Personnellement, je n'ai jamais aimé l'héritage des fichiers de configuration. Vous mentionnez avoir une séquence de chargement, vous ne savez pas comment elle est définie ou dérivée. Peut-être que cela aide à rendre la séquence évidente en la mettant en miroir dans une structure de répertoires dans laquelle vous placez les fichiers ou en l'incluant dans les noms de fichiers.

rootsettings.properties
rootsettings.eurosettings.properties
rootsettings.eurosettings.londonsettings.properties

Cela fonctionnera quelque peu jusqu'à ce que vous ayez un ensemble de valeurs de configuration qui ne s'alignent pas sur une région. Vous devez donc être attentif à l'axe organisationnel que vous choisissez.

Ce que j'aime le plus, c'est isoler des agrégats de valeurs de configuration dans leurs propres fichiers et avoir un fichier de configuration (feuille) point à un.

Un exemple:

bigcity.searchsettings.properties
regional.searchsettings.properties

À l'intérieur, londonsettings.propertiesvous pourriez avoir une valeur comme:

searchsettings:bigcity.searchsettings.properties

Cela permet plus de degrés de liberté ou un degré supplémentaire.

J'ai eu le même problème et open source ma solution. Vous pouvez trouver le code source ici https://github.com/Bikeman868/Urchin

Je l'utilise pour un grand système avec de nombreux serveurs, avec plusieurs applications sur chaque serveur et plusieurs environnements. Il comprend une interface utilisateur écrite en Dart pour gérer la configuration.

Vous pouvez me contacter directement si vous avez besoin d'aide pour démarrer.

La solution que j'ai implémentée est basée sur des règles. Vous commencez généralement avec une règle qui s'applique à toutes les configurations, puis vous pouvez ajouter des règles comme «toutes les machines de cet environnement créent des fichiers journaux sur ce chemin UNC». Les règles peuvent être spécifiques à un environnement, une application, une machine ou une instance d'une application. Les règles peuvent également être plus spécifiques, car uniquement dans cette instance spécifique de cette application exécutée sur ce serveur spécifique.

Les règles sont appliquées dans l'ordre du moins spécifique au plus spécifique, et les règles ultérieures peuvent remplacer les valeurs spécifiées dans les règles antérieures. Cela signifie par exemple que vous pouvez créer une règle qui s'applique à une application particulière, puis la remplacer par une valeur différente pour une machine spécifique, ou une instance spécifique de l'application, etc.

Le serveur possède une interface REST + JSON, il fonctionne donc avec la plupart des systèmes de développement et dispose également d'une bibliothèque cliente pratique pour les applications .Net.

Ce type de paramètres est un cauchemar à gérer. Il est préférable d'essayer de les réduire autant que possible en faisant en sorte que vos composants logiciels gèrent tous les cas.

c'est-à-dire qu'au lieu de configurer un serveur api pour une région, passez la région avec l'appel api et laissez une configuration de serveur unique gérer toutes les régions.

Cependant, étant donné que vous êtes dans l'état où vous vous trouvez. Je vous déconseille de mettre en place un système pour générer des paramètres de configuration. Il ajoute seulement de la complexité à un problème déjà complexe.

Au lieu de cela, ayez les paramètres stockés dans votre outil de déploiement par type de serveur. (paramètres de déploiement de poulpe, réécritures de fichiers teamcity, etc.) Cela vous permet d'être sûr que vous déployez les mêmes paramètres de configuration que vous l'avez fait la dernière fois lors de la mise à niveau du logiciel et vous donne un contrôle précis sur les modifications.

Vous ne voulez pas être dans la situation où vous apportez une modification à vos fichiers de méta-configuration et ensuite vous devez tester quel fichier de configuration qui produit dans vos différentes régions / serveurs / regroupements personnalisés

Aucune recherche; toute opinion personnelle, 30+ expérience informatique. Cela ressemble à une structure de données compliquée, qui peut changer / modifiée rapidement, avec un grand nombre d'utilisateurs.

Envisagez un référentiel de base de données (par exemple, SQL) pour structurer les données, avec des processus d'extraction personnalisés qui produisent des fichiers de configuration individuels pour chaque utilisateur. Vous pouvez utiliser une requête de la base de données pour déterminer l'impact d'une modification avant sa mise en œuvre; trouver des occurrences en double, etc. Les fichiers plats individuels font partie du problème. De plus, vous pouvez obtenir des journaux de modifications et un support de récupération / reconstruction. Avec le contrôle de la base de données, vous pourrez peut-être éliminer les problèmes d'héritage de configuration. Ce type de solution nécessitera une structure de base de données supplémentaire. La structure de clé composite correcte est très importante.

Voilà ma suggestion.

Vous pourriez examiner certains systèmes de sécurité et de contrôle des systèmes des fournisseurs très coûteux qui implémentent ce type de service. Considérez-les. En général, ils dépendent de l'environnement.