---
# System prepended metadata

title: Tutoriel Ansible Vault - Pas à Pas

---

# Tutoriel Ansible Vault - Pas à Pas

## Étape 1 : Préparation de l'environnement

Créons d'abord une structure simple :
```
mon-projet/
├── ansible.cfg
├── inventory
│   └── hosts
└── deploy.yml
```

1. Créez le fichier `ansible.cfg` :
```ini
[defaults]
inventory = inventory/hosts
```

2. Créez le fichier `inventory/hosts` :
```ini
[webservers]
monserveur ansible_host=node1
```

## Étape 2 : Premier Fichier Vault

1. Créons notre premier fichier chiffré :
```bash
# Création d'un fichier vault pour stocker nos secrets
ansible-vault create secrets.yml
```

2. Ansible vous demandera un mot de passe. Entrez-en un simple pour ce tutoriel (par exemple : 'monmotdepasse')

3. Un éditeur s'ouvrira. Ajoutez ces lignes :
```yaml
---
db_password: MonSuperMotDePasse123
api_key: cle_secrete_123
```

4. Sauvegardez et quittez l'éditeur

## Étape 3 : Utilisation basique

1. Créez un playbook simple `deploy.yml` :
```yaml
---
- name: Test des variables vault
  hosts: webservers
  vars_files:
    - secrets.yml
  tasks:
    - name: Afficher une variable secrète
      debug:
        msg: "La clé API est : {{ api_key }}"
```

2. Exécutez le playbook :
```bash
# L'option --ask-vault-pass demandera le mot de passe
ansible-playbook deploy.yml --ask-vault-pass
```

## Étape 4 : Manipulation du Fichier Vault

Voici les commandes de base pour manipuler un fichier vault :

1. Voir le contenu :
```bash
ansible-vault view secrets.yml
```

2. Modifier le contenu :
```bash
ansible-vault edit secrets.yml
```

3. Changer le mot de passe :
```bash
ansible-vault rekey secrets.yml
```

## Étape 5 : Utilisation d'un Fichier de Mot de Passe

1. Créez un fichier pour stocker le mot de passe :
```bash
echo "monmotdepasse" > .vault_pass
chmod 600 .vault_pass
```

2. Modifiez `ansible.cfg` pour utiliser ce fichier :
```ini
[defaults]
inventory = inventory/hosts
vault_password_file = .vault_pass
```

3. Maintenant vous pouvez exécuter sans saisir le mot de passe :
```bash
ansible-playbook deploy.yml
```

⚠️ NOTE : Ne committez jamais le fichier .vault_pass dans git !

## Étape 6 : Organisation avec group_vars

1. Créez une meilleure structure :
```
mon-projet/
├── ansible.cfg
├── inventory/
│   ├── group_vars/
│   │   └── webservers/
│   │       ├── vars.yml     # Variables non-sensibles
│   │       └── vault.yml    # Variables sensibles
│   └── hosts
└── deploy.yml
```

2. Dans `inventory/group_vars/webservers/vars.yml` (non chiffré) :
```yaml
---
app_name: mon_application
app_port: 8080
```

3. Dans `inventory/group_vars/webservers/vault.yml` (à chiffrer) :
```yaml
---
vault_db_password: MonSuperMotDePasse123
vault_api_key: cle_secrete_123
```

4. Chiffrez le fichier vault :
```bash
ansible-vault encrypt inventory/group_vars/webservers/vault.yml
```

## Étape 7 : Bonnes Pratiques de Variables

1. Modifiez `inventory/group_vars/webservers/vars.yml` pour utiliser les variables vault de manière indirecte :
```yaml
---
app_name: mon_application
app_port: 8080

# Référence aux variables vault
db_password: "{{ vault_db_password }}"
api_key: "{{ vault_api_key }}"
```

2. Modifiez votre playbook pour utiliser ces variables :
```yaml
---
- name: Configuration application
  hosts: webservers
  tasks:
    - name: Configurer l'application
      debug:
        msg: "Configuration avec {{ app_name }} sur le port {{ app_port }} avec la clé API {{ api_key }}"
```

## Exercices Pratiques

1. **Exercice Simple**
   - Créez un nouveau fichier vault nommé `database_creds.yml`
   - Ajoutez-y un utilisateur et mot de passe de base de données
   - Créez un playbook qui affiche ces informations

2. **Exercice Intermédiaire**
   - Organisez vos variables sensibles dans group_vars
   - Créez des variables de référence dans vars.yml
   - Utilisez ces variables dans un playbook
