Comment afficher/décrypter des fichiers d'informations d'identification de coffre-fort Ansible à partir d'un script Python?

Question

Je suis en train de comprendre comment fournir les services suivants à un script Python afin qu'il puisse:

1. modules d'importation Ansible Python
2. ouvrir mon sens ansible.cfg et lecture variable vault_password_file
3. Lire vault_password_file et stocker temporairement dans une variable Python
4. Déchiffrer un Ansible référencé voûtées fichier

J'ai trouvé this code via google mais il ne semble pas fonctionner quand je l'ai essayé:

import ansible.utils 

bar = dict() 

bar = ansible.utils._load_vars_from_path("secrets.yml", results=bar, vault_password="password") 

print bar 

Lancers cette erreur:

$ python ansible-vault-ex.py 
Traceback (most recent call last): 
    File "ansible-vault-ex.py", line 5, in <module> 
    bar = ansible.utils._load_vars_from_path("credentials.vault", results=bar, vault_password="password") 
AttributeError: 'module' object has no attribute '_load_vars_from_path' 

Quand j'enquêté sur ce que j'ai vu aucune indication de cette fonction dans tous les fichiers liés Ansible , ce qui m'amène à croire que cette méthode ne fonctionne plus avec une ou plusieurs version (s) plus récente (s) d'Ansible.

L'essentiel est que je voudrais une méthode pour importer des bibliothèques/modules Ansible à partir d'un script Python, de sorte que je puisse interagir avec les fichiers gérés ansible-vault par programmation à partir de Python.

Answer 1

Ce n'est pas exactement ce que je veux mais j'ai travaillé sur mon problème ci-dessus en exécutant la commande ansible view <vaultfile> via subprocess.

import subprocess 
import yaml 

def getCreds(): 
    cmd = "ansible-vault view credentials.vault" 
    process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) 
    (result, error) = process.communicate() 

    resultYaml = yaml.load(result) 

    accesskey = resultYaml['accesskey'] 
    secretkey = resultYaml['secretkey'] 

    return(accesskey, secretkey) 

L'appel direct de méthodes Ansible directement en Python serait toujours préférable.

Answer 2

Pensez à utiliser le la ansible-vault package

Installer par:

$ pip install ansible-vault 

et il est aussi simple que:

from ansible_vault import Vault 

vault = Vault('password') 
print vault.load(open('/path/to/your/vault.yml').read()) 

Pour utiliser le code ansible regarder directement à l'source de ce paquet. Le plus simple serait:

from ansible.parsing.vault import VaultLib 

vault = VaultLib('password') 
print vault.decrypt(open('/path/to/vault.yml').read()) 

La quantité de code source est égale mais le paquet fournit l'analyse syntaxique automatique yaml + traitement des deux versions Ansible.

Answer 3

Vous voulez lire et décrypter un fichier crypté par l'API Ansible Python, non?

Dans Ansible 2.0 et au-dessus:

def execute_ansible_command(play_source, stdout_callback): 
    from ansible.executor.task_queue_manager import TaskQueueManager 
    from ansible.inventory import Inventory 
    from ansible.parsing.dataloader import DataLoader 
    from ansible.playbook import Play 
    from ansible.vars import VariableManager 

    Options = namedtuple('Options', ['connection', 'module_path', 'forks', 'remote_user', 
            'private_key_file', 'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args', 
            'scp_extra_args', 'become', 'become_method', 'become_user', 'verbosity', 
            'check']) 
    variable_manager = VariableManager() 
    loader = DataLoader() 
    loader.set_vault_password(ANSIBLE_VAULT_PASS) 
    options = Options(connection='smart', module_path=None, forks=100, 
         remote_user=None, private_key_file=None, ssh_common_args="-o StrictHostKeyChecking=no", 
         ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=None, 
         become_method=None, become_user=None, verbosity=None, check=False) 
    passwords = dict() 
    inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=ANSIBLE_INVENTORY) 
    variable_manager.set_inventory(inventory) 

    play = Play().load(play_source, variable_manager=variable_manager, loader=loader) 

    tqm = None 
    try: 
     tqm = TaskQueueManager(
      inventory=inventory, 
      variable_manager=variable_manager, 
      loader=loader, 
      options=options, 
      passwords=passwords, 
      stdout_callback=stdout_callback, 
     ) 
     tqm.run(play) 
    finally: 
     if tqm is not None: 
      tqm.cleanup() 

La classe DataLoader est utilisé pour charger et analyser YAML ou contenu JSON, et il a une fonction set_vault_password, vous pouvez envoyer un mot de passe de voûte pour déchiffrer un coffre-fort crypté fichier