[PYTHON] Automatische Erstellung einer Ansible-Konfigurationsdatei (vars) aus Excel (Ansible)
Diejenigen, die sich freuen würden, wenn Sie es lesen könnten
・ Diejenigen, die Server bauen oder MW mit Ansible in der Infrastrukturabteilung einführen ・ Diejenigen, die es schwierig finden, Inventardateien und Playbooks zu erstellen
Ausführungsumgebung
- python3.5
- jinja2
- vagrant(box:bento/centos-6.7)
- Inhalt der Vagabunddatei
Vagrant.configure(2) do |config|
config.vm.box = "bento/centos-6.7"
config.vm.define "dev" do |node|
node.vm.network "private_network", ip: "192.168.10.10"
node.vm.synced_folder "/Users/takahirono7/projects/", "/root/project"
end
end
- Das Festlegen von synced_folder ist sehr praktisch, da Sie das Verzeichnis auf Ihrem lokalen Mac und Vagrant synchronisieren können.
- Die Methode ist unten zusammengefasst
Dateien zwischen Gastbetriebssystemen, die auf Vagrant und Mac ausgeführt werden, synchronisieren
Einführung
・ Ich bin eine Person in der Infrastrukturabteilung, die häufig Anforderungen rund um MW gemäß den geschäftlichen Anforderungen überprüft, erstellt, testet und liefert.
・ In meiner Abteilung erhalte ich Anforderungen aus der Entwicklung. Auf dieser Grundlage lege ich die Instanzinformationen in eine Vars-Datei und erstelle sie mit Ansible. -Es ist ein Image, um die Informationen für jede Instanz mit einer VAR-Datei bereitzustellen, wie unten gezeigt.
Die Vars-Datei sieht folgendermaßen aus:
yaml
apache_instance:
instance_name: 'SAMPLE_InstanceA'
server_name: 'sample.jp'
instance_user:
name: 'apache_user'
instance_settings:
chkconfig: false
add_encodings:
- 'x-compress Z'
- 'x-gzip gz'
add_languages:
- 'ja .ja'
- 'en .en'
- 'fr .fr'
start_servers: '5'
min_spare_servers: '5'
max_spare_servers: '10'
server_limit: '512'
max_request_workers: '150'
max_connections_perchild: '0'
Wie oben erwähnt, werden die obigen Dateien für jede Instanz vorbereitet.
Diese Datei wird basierend auf dem ** "Anforderungsblatt" ** (Excel) erstellt, das vom Entwickler im folgenden Format übergeben wurde.
Abgesehen von der Tatsache, dass es ineffizient ist, ist es nicht eine bestimmte Art, Infrastruktur aufzubauen?
Die eigentliche Datei ist länger und komplexer, daher kann das Erstellen von Vars daraus eine entmutigende Aufgabe sein.
Ich habe eine Python-App erstellt, die dies automatisiert.
Montagemethode
Die Voraussetzung ist, dass Excel einmal durch eine Textdatei ersetzt wird, die in die App geladen und in Variablen im Yaml-Format konvertiert wird.
In Python gibt es ein xlrd-Modul als Modul, das Excel berührt. Zuerst habe ich versucht, es zu implementieren, aber ich hatte ein internes Problem, z. B. das Erhöhen der Anzahl der Spalten und Zeilen in Excel beim Anforderer. Daher habe ich mich entschieden, es einmal zu implementieren, indem ich es in Text konvertierte.
Wenn die Anwendungsmethode darin besteht, dass die Excel-Tabelle fest ist und die Anzahl der Zeilen und Spalten nicht zunimmt, ist die Implementierung mit dem oben genannten Modul meiner Meinung nach einfacher.
** Grundsätzlich handelt es sich um eine Methode zum Speichern einer Textdatei (ursprünglich Excel) in Python mit einem geteilten Modul usw. für jeden Parameter in einem Wörterbuch, zum endgültigen Rendern in eine jinja2-Vorlage und zum Ausgeben **
Da die internen Informationen aus dem Skript gelöscht werden, ist es unmöglich, sie so auszuführen, wie sie sind, aber ich denke, Sie können sich nur auf die Essenz beziehen. M (__) m Es tut mir leid, dass Python noch schreibt, also ist es schmutzig.
Werkzeugkonfiguration
Verzeichnisaufbau
/root/project/convert_hearing_sheet_into_vars
|--README.md
|--hearing_sheets #Platzieren Sie die vom Makro konvertierte Textdatei(Siehe unten)
| |--Apache.txt #Excel-konvertierte Textdatei
|--main.py #Starten Sie jedes Modul
|--scripts
| |--__init__.py
| |--create_dict_from_apache_sheet.py
| |--common_method.py #Beschreiben der allgemeinen Verarbeitung
|--config.json
|--output
| |--apache_hogehoge_instance.yml #Die von txt konvertierte vars-Datei wird platziert
|--vars_template
| |--[template]apache_vars.j2
main.py Rufen Sie jedes Modul auf
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# -*- mode: python;Encoding: utf8n -*-
### import
#-----------------------------------------------
import sys
import os
from scripts.create_dict_from_apache_sheet import CreateDictFromApacheSheet
from scripts.common_method import CommonMethod
#-----------------------------------------------
###Befehlszeilenargumentverarbeitung
#-----------------------------------------------
# $1 = run.py
# $2 =Name der Ausführungsdatei
argvs = sys.argv
argc = len(argvs)
if (argc != 2):
print(
'Usage: # python %s filename {dest file name}' % argvs[0])
sys.exit(1)
excelfile = argvs[1]
#===============================================
#Dateipfad, allgemeine Variablendefinition
#===============================================
script_dir = os.path.abspath(os.path.dirname(__file__))
#Lesen einer von einem Makro konvertierten Textdatei
apache_file = os.path.join(
script_dir, "hearing_sheets", excelfile)
#Instanziieren Sie eine Methodenklasse für die allgemeine Verarbeitung
method = CommonMethod()
config_lines = method.open_file(apache_file)
#Rufen Sie die Zeile mit dem Instanznamen ab und erstellen Sie eine Liste der Instanzen
inst_list_apache = []
for i in config_lines:
if i.find("Instanzname") >= 0:
inst_list_apache.append(i)
target_instances = method.split_by_tab(inst_list_apache)
print("Anzahl der Instanzen")
print(len(target_instances) - 1)
print("Führt den Prozess für die folgenden Instanzen aus")
for instance in target_instances[1:]:
print(instance)
#Führen Sie die Verarbeitung für jede Instanz durch
#Holen Sie sich auch die Indexnummer mit enumerate
print("Starten Sie die Verarbeitung")
for index, target_instance_name in enumerate(target_instances[1:]):
print(index, target_instance_name)
apache_dict = CreateDictFromApacheSheet(script_dir)
apache_dict.exec(config_lines, index, target_instance_name)
print("Verarbeitung beenden")
create_dict_from_apache_sheet.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# -*- mode: python;Encoding: utf8n -*-
### importfile
#-------------------------------------------------------
import sys, os, copy, platform, codecs, re, traceback, json # @UnusedImport
from collections import defaultdict
from os.path import join, dirname, abspath, isfile
from jinja2 import Environment, FileSystemLoader
from scripts.common_method import CommonMethod
class CreateDictFromApacheSheet(CommonMethod):
def __init__(self, script_dir):
self.script_dir = script_dir
def exec(self, config_lines, index, target_instance_name):
###############Dateipfad, allgemeine Variablendefinition#############
#Extrahieren Sie die Parameter der Instanz
main_dict_apache = self.extract_instance_params(
config_lines,
index,
target_instance_name)
#Vars-Datei ausgeben
self.output_vars_files(
index, target_instance_name, main_dict_apache)
def extract_instance_params(self,
config_lines,
index,
target_instance_name):
apache_dict = defaultdict(dict)
json_file = os.path.join(self.script_dir, "config.json")
#Json-Datei lesen
with open(json_file) as f:
json_dict = json.load(f)
apache_dict["instance_name"] = target_instance_name
# config.Speichern Sie das in json gespeicherte Wörterbuch für jeden Parameter
for parameter in json_dict["apache"]["APACHE_INSTANCE"]:
version_list = []
parameter_key = list(parameter.keys())
parameter_value = list(parameter.values())
#In str.Wenn Sie versuchen, es als Liste zu verwenden, können Sie't Konvertierungsfehler tritt auf
parameter_key_str = parameter_key[0]
parameter_value_str = parameter_value[0]
for i in config_lines:
if i.find(parameter_key_str) >= 0:
version_list.append(i)
version_params = self.split_by_tab(version_list)
apache_dict[parameter_value_str] = version_params[index + 1]
return apache_dict
#Holen Sie sich die jinja2 Vorlage und Apache_Rendern Sie den Inhalt von dict und geben Sie ihn aus
def output_vars_files(self, index, target_instance_name, main_dict_apache):
template_dir = os.path.join(
self.script_dir, "vars_template", site)
jinja_env = Environment(
trim_blocks=True, loader=FileSystemLoader(template_dir))
vars_file = os.path.join(self.script_dir, "output", "instance_%s_%s.yml" %(target_instance_name))
tmpl = jinja_env.get_template("[template]apache_vars.j2")
with open(vars_file, "wb") as f:
f.write(tmpl.render(main_dict_apache).encode("utf-8"))
[template]apache_vars.j2 Es wird eine Vorlage für Vars. Der Wert des von create_dict_from_apache_sheet.py erstellten Wörterbuchs kann auf diese Vorlage angewendet werden.
apache_instance:
instance_name: '{{ instance_name }}'
server_name: '{{ server_name }}'
instance_user:
name: '{{ instance_user }}'
instance_settings:
chkconfig: false
add_encodings:
- 'x-compress Z'
- 'x-gzip gz'
add_languages:
- 'ja .ja'
- 'en .en'
- 'fr .fr'
start_servers: '{{ start_servers }}'
min_spare_servers: '{{ min_spare_servers }}'
max_spare_servers: '{{ max_spare_servers }}'
server_limit: '{{ server_limit }}'
max_request_workers: '{{ max_request_workers }}'
max_connections_perchild: '{{ max_connections_perchild }}'
config.json
Diese Datei verknüpft das Excel-Hörblatt mit dem Schlüssel des Wörterbuchs im Skript.
json
{
"apache" : {
"APACHE_INSTANCE": [
{"ServerName" : "server_name"},
{"User" : "instance_user"},
{"AddEncoding" : "add_encodings"},
{"AddLanguage" : "add_languages"},
{"StartServers" : "start_servers"},
{"MinSpareServers" : "min_spare_servers"},
{"MaxSpareServers" : "max_spare_servers"},
{"ServerLimit" : "server_limit"},
{"MaxClients (MaxRequestWorkers)" : "max_request_workers"},
{"MaxRequestsPerChild(MaxConnectionsPerChild)" : "max_connections_perchild"}
]
}
}
Werkzeugschritte
Das spezifische Verfahren ist wie folgt.
- Konvertieren Sie das Excel-Hörblatt mithilfe eines Makros in eine Textdatei
- Legen Sie die erstellte Textdatei im Verzeichnis Hearing_sheets ab
- Werkzeugausführung Die Vars-Datei wird in das Ausgabeverzeichnis ausgegeben Es wird der Fluss sein
Konvertieren Sie das Excel-Hörblatt mithilfe eines Makros in eine Textdatei
Führen Sie zunächst das folgende Makro aus, um die Excel-Datei für jedes Blatt in Text zu konvertieren. Bitte beachten Sie, dass das Makro eine Stelle enthält, die den Pfad des lokalen Verzeichnisses beschreibt.
Das Makro zitiert den folgenden Artikel. Danke m (_ _) m http://d.hatena.ne.jp/minamijoyo/20080124/p1
vba
Sub OutputTEXT()
'Speichern Sie alle aktiven Arbeitsmappenblätter als tabulatorgetrennten Text
Dim name As String
Dim outdir As String
Dim sheet As Worksheet
'Bitte geben Sie den Entladezielordner an
outdir = "D:\Users\hogehoge\Documents\"
'Überschreibungswarnung ausblenden, wenn bereits Daten vorhanden sind
Application.DisplayAlerts = False
For Each sheet In Worksheets
sheet.Select
name = outdir & ActiveSheet.name & ".txt"
ActiveWorkbook.SaveAs Filename:=name, FileFormat:=xlText, CreateBackup:=False
Next sheet
'Warnanzeige zurück
Application.DisplayAlerts = True
End Sub
Wenn Sie dies tun, wird der Text wie folgt in den Zielordner gespuckt
Apache.txt
Instanzname BEISPIEL_InstanceA SAMPLE_InstanceB SAMPLE_InstanceC
Autostart-Einstellung Nein Nein Nein Nein
ServerName sample.jp sample.jp_B sample.jp_C
User apache_user apache_user apache_user
StartServers 5 5 5
MinSpareServers 5 5 5
MaxSpareServers 10 10 10
ServerLimit 512 512 512
MaxClients (MaxRequestWorkers) 150 150 150
MaxRequestsPerChild(MaxConnectionsPerChild) 0 0 0
Legen Sie die erstellte Textdatei im Verzeichnis Hearing_sheets ab
Legen Sie die obige Datei im Verzeichnis Hearing_sheets des Tools ab
Werkzeugausführung
[root@localhost convert_hearing_sheet_into_vars]# ./main.py apache
Anzahl der Apache-Instanzen
3
Führt den Prozess für die folgenden Apache-Instanzen aus
SAMPLE_InstanceA
SAMPLE_InstanceB
SAMPLE_InstanceC
vars werden in das Ausgabeverzeichnis ausgespuckt
Recommended Posts