Comment gérer la configuration de l'environnement existant après l'implémentation d'Ansible)

Comme mentionné ci-dessus, en mettant en œuvre Ansible, le travail de construction lui-même est devenu plus facile. En outre, pour les départements métiers qui préparent l'infrastructure pour le «nouveau» Le demandeur envoie une demande d'extraction GitHub, et lorsque le personnel de l'infrastructure confirme et approuve la partie modifiée, le paramètre est reflété dans la branche Maseter et les travaux de construction sont terminés. Était

Illustrer une opération GitHub Flow plus simple qui intègre des pull requests / reviews (1/2) http://www.atmarkit.co.jp/ait/articles/1401/21/news042.html

Cependant, cela n'a pas été si facile pour les départements commerciaux qui ont un environnement existant.

Si on me demandait de modifier les paramètres MW d'un certain serveur, je devais préparer divers fichiers de paramètres Ansible tels que le fichier Vars à partir de zéro, ce qui était une situation très gênante.

J'ai eu l'idée de créer un outil de création automatique de fichiers d'inventaire.

En raison des problèmes mentionnés ci-dessus, j'ai proposé un outil qui génère automatiquement des fichiers de paramètres Ansible à partir du serveur dans l'environnement existant.

J'ai fait un diagramme d'image minable. Le flux de l'outil est le suivant

1. Spécifiez les SV et MW à exécuter sur le PC local
2. Appuyez sur git
3. A partir de l'interface graphique jenkins, spécifiez le fichier mentionné dans ② et exécutez le travail.
4. Le serveur d'exécution jenkins clone le référentiel maître git et obtient le serveur cible spécifié et le fichier de configuration MW par sftp.
5. Après l'acquisition, le script de conversion en fichier Ansible est exécuté et le fichier de paramètres Ansible est créé sous le répertoire d'exécution (vars / host_vars / group_vars).
6. Divers fichiers de paramètres créés sont téléchargés sur git

Démo (essayez de créer automatiquement un fichier vars à partir du fichier de configuration en utilisant apache comme exemple)

Ici, je voudrais extraire le fichier de configuration Apache et créer automatiquement le fichier Vars suivant. C'est une image d'écrire en fait une partie de ⑤ En fait, il est divisé en différents modules afin de pouvoir répondre à diverses exigences, mais comme il s'agit d'une démo, il est extrait pour des paramètres simples d'Apache.

environnement

・ Python3.4 ・ Apache 2.2.15

Fichier Vars à créer

Après l'exécution de l'outil, les informations du fichier de paramètres (/etc/httpd/conf/httpd.conf) sont extraites et stockées dans les éléments suivants.

KeepAlive: ''
KeepAliveTimeout: ''
MaxKeepAliveRequests: '100'
PidFile: run/httpd.pid
ServerRoot: '"/etc/httpd"'
ServerTokens: OS
Timeout: '60'
load_module:[]

Préparation

Installez apache et créez main.py directement dans le répertoire / etc / httpd Assurez-vous que httpd.conf, qui est la cible de l'extraction des paramètres, est localisé.

[root@localhost httpd]$ sudo yum install httpd
[root@localhost httpd]$ pwd
/etc/httpd
[root@localhost httpd]# ls conf/httpd.conf
conf/httpd.conf
[root@localhost httpd]$vi main.py

Créer main.py

main.py

# coding: UTF-8
import yaml
from pathlib import Path
import re


#Décrire le processus d'extraction des paramètres
class CommonFunc:
    def __init__(self):
        pass

    # file_Stocke le contenu du fichier cible spécifié par l'argument de nom dans un tableau ligne par ligne
    def func_read_files(self, file_name):
        lines = []
        with file_name.open() as f:
            lines.extend(f.readlines())
        return lines

    #Stocker la ligne contenant la chaîne de caractères spécifiée par paramètre dans le tableau
    def func_search_parameter(self, lines, parameter):
        searched_line = []
        for line_tmp in lines:
            #Supprimer l'espace blanc de début
            line = re.sub(r'^\s+', '', line_tmp)
            try:
                if line.startswith(parameter):
                    #Supprimer la ligne commentée
                    tmp = re.sub(r"^\s*#.*", "", line)
                    searched_line.append(tmp.rstrip('\r\n'))
            except:
                searched_line = ""

        return searched_line

    #Recherche la ligne contenant la chaîne de caractères spécifiée par paramètre et la stocke dans le tableau. Sortie de la différence du fichier modèle à l'aide de l'ensemble
    def func_set_parameter(self, lines, compared_lines, parameter):
        src_list = []
        dst_list = []
        for line in lines:
            if line.find(parameter) >= 0:
                src_list.append(line.rstrip('\r\n'))
        for compared_line in compared_lines:
            dst_list.append(compared_line.rstrip('\r\n'))
        src_set = set(src_list)
        return src_set.difference(dst_list)

    #Recherchez les lignes contenant la chaîne spécifiée par paramètre. Séparez par un espace et stockez le second dans le tableau
    def func_split_line_unique(self, lines, parameter):
        splited_line = []
        for line_tmp in lines:
            #Supprimer l'espace blanc de début
            line = re.sub(r'^\s+', '', line_tmp)
            if line.startswith(parameter):
                try:
                    splited_line = line.split()[1]
                except:
                    splited_line = ""
        return splited_line


#Créez un dictionnaire et stockez la valeur dans Value. Le processus d'extraction des paramètres réels appelle le processus de CommonFunc.
class MakeApacheDictionary(CommonFunc):

    def __init__(self):
        self.output_files = "test_vars.yml"
        self.httpd_conf_path = Path("/etc", "httpd", "conf", "httpd.conf")
        self.module_template_path = Path("/etc", "httpd", "load_module_template.txt")
        self.httpd_lines = self.func_read_files(self.httpd_conf_path)
        self.base_module_lines = self.func_search_parameter(self.httpd_lines, "LoadModule")
        self.base_module_template_lines = self.func_read_files(self.module_template_path)



    def apache_yaml_dict(self):
        self.yml_list = {
        #Unique par exemple
            'ServerTokens': "",
            'ServerRoot': "",
            'PidFile': "",
            'Timeout': "",
            'KeepAlive': "",
            'MaxKeepAliveRequests': "",
            'KeepAliveTimeout': "",
        #Affiche la différence par rapport au fichier modèle sous forme d'ensemble
            'load_module': []}

        d = self.yml_list
        d['ServerTokens'] = self.func_split_line_unique(self.httpd_lines, "ServerTokens")
        d['ServerRoot'] = self.func_split_line_unique(self.httpd_lines, "ServerRoot")
        d['PidFile'] = self.func_split_line_unique(self.httpd_lines, "PidFile")
        d['Timeout'] = self.func_split_line_unique(self.httpd_lines, "Timeout")
        d['MaxKeepAliveRequests'] = self.func_split_line_unique(self.httpd_lines, "MaxKeepAliveRequests")
        d['load_module'].extend(self.func_set_parameter(self.base_module_lines, self.base_module_template_lines,"LoadModule"))


    def create_yaml(self):
        with open(self.output_files, 'w') as f:
            f.write(yaml.safe_dump(self.yml_list, default_flow_style=False))


#Génération d'instance
a = MakeApacheDictionary()
a.apache_yaml_dict()
a.create_yaml()

La description

--Class est divisé en classe "CommonFunc" qui décrit le processus d'extraction des paramètres et MakeApacheDictionary qui crée un dictionnaire et le vide sous forme de fichier yaml.

• La dernière classe hérite de la première afin que le processus d'extraction puisse être utilisé.
• Des valeurs uniques dans les fichiers de configuration tels que ServerRoot et TimeOut peuvent être obtenues en utilisant la méthode startswith et en les fractionnant comme décrit dans func_split_line_unique.
• Pour les éléments tels que LoadModule et RewriteCond qui ont plusieurs paramètres pour le même élément, préparez les paramètres standard séparément en tant que fichier modèle et affichez les différences à l'aide d'un ensemble.

Exemple de modèle

Dans func_set_parameter, les lignes commençant par LoadModule dans httpd.conf sont recherchées et répertoriées, comparées au contenu décrit dans le fichier modèle, et la différence est générée.

[root@localhost collect_config]# more load_module_template.txt
LoadModule authn_alias_module modules/mod_authn_alias.so
LoadModule authn_anon_module modules/mod_authn_anon.so
LoadModule authn_dbm_module modules/mod_authn_dbm.so
etc ...

Résultat d'exécution

Le dictionnaire créé Passé à la fonction create_yml (où le module yaml.safe_dump est utilisé) et sauvegardé dans le répertoire d'exécution du script

[root@localhost httpd]# python main.py
[root@localhost httpd]# more test_vars.yml
KeepAlive: 'Off'
KeepAliveTimeout: '15'
MaxKeepAliveRequests: '100'
PidFile: run/httpd.pid
ServerRoot: '"/etc/httpd"'
ServerTokens: OS
Timeout: '60'
load_module:
- LoadModule auth_basic_module modules/mod_auth_basic.so
- LoadModule authn_file_module modules/mod_authn_file.so
- LoadModule auth_digest_module modules/mod_auth_digest.so
[root@localhost httpd]#

À la fin

Merci d'avoir lu jusqu'au bout. J'espère qu'il sera utile pour ceux qui sont également préoccupés par la gestion de la configuration de l'environnement existant.