Comment créer des modèles Ansible pour économiser du temps de configuration

La gestion des configurations de plusieurs serveurs et environnements est un grand avantage de l’utilisation d’Ansible. Mais que se passe-t-il lorsque les fichiers de configuration varient d’un serveur à l’autre ? Au lieu de créer une configuration distincte pour chaque serveur ou environnement, vous devriez vous intéresser aux modèles Ansible.

Dans ce tutoriel, vous allez apprendre ce que sont les modèles Ansible, comment ils fonctionnent et comment vous pouvez utiliser le module de modèle Ansible pour gagner énormément de temps.

Prérequis

Cet article sera un tutoriel étape par étape. Si vous souhaitez suivre, assurez-vous d’avoir un hôte contrôleur Ansible. Ce tutoriel utilisera Ansible v2.9.18

Qu’est-ce qu’un modèle Ansible?

Parfois, vous avez besoin de transférer des fichiers texte vers des hôtes distants. Ces fichiers texte sont généralement un type de fichier de configuration. Si vous travaillez avec un seul serveur, par exemple, vous pourriez avoir besoin de créer un fichier de configuration appelé app.conf que certains services utilisent.

Ce fichier de configuration peut contenir des informations spécifiques à ce serveur telles que le nom d’hôte, l’adresse IP, etc. Étant donné que vous travaillez avec un seul serveur, vous pouvez créer le fichier sur le contrôleur Ansible, puis utiliser le module copy dans un playbook pour le copier sur le serveur.

Mais que se passe-t-il si vous avez plusieurs serveurs web ayant chacun besoin du même fichier de configuration mais avec des valeurs spécifiques ? Vous ne pouvez pas simplement copier le fichier de configuration sur toutes les machines ; il est conçu pour un seul serveur avec un nom d’hôte, une adresse IP, etc. spécifiques. Vous avez besoin d’un modèle Ansible.

Les modèles Ansible vous permettent de définir des fichiers texte avec des variables au lieu de valeurs statiques, puis de remplacer ces variables lors de l’exécution du playbook.

À quoi ressemble un modèle Ansible ?

Un modèle Ansible est un fichier texte créé avec le langage de modélisation Jinja2 et portant l’extension .j2. Un modèle Jinja2 ressemble exactement au fichier texte que vous souhaitez placer sur un hôte distant. La seule différence est que, au lieu de valeurs statiques, le fichier contient des variables.

Par exemple, vous pouvez avoir besoin d’obtenir un fichier de configuration appelé app.conf sur tous vos serveurs web, contenant des références à l’adresse IP de chaque serveur respectif, à l’hôte Ansible et à l’utilisateur Ansible. Le fichier app.conf d’un seul serveur peut ressembler à l’exemple ci-dessous.

my_ip    = "192.168.0.1"
my_host  = "ANSBILECONTROL"
my_user  = "ansible_user"

Vous ne pouvez pas copier ce fichier sur chaque serveur web car chaque élément sera unique en fonction de l’adresse IP de l’hôte distant, du nom d’hôte du contrôleur Ansible et de l’utilisateur Ansible.

Au lieu de définir statiquement chacune de ces valeurs, un modèle Ansible vous permet de définir des variables qui sont interprétées au moment de l’exécution et remplacées sur l’hôte distant.

Vous trouverez ci-dessous un exemple de fichier de modèle app.conf.j2. Vous pouvez maintenant voir que chaque valeur statique a été remplacée par une variable notée entre doubles accolades de chaque côté. Dans ce cas, ces variables proviennent des fichiers de faits Ansible.

Les fichiers de modèles ont toujours l’extension J2 et portent généralement le même nom que le fichier qu’ils créent sur l’hôte cible.

my_ip    = "{{ansible_default_ipv4["address"]}}"
my_host  = "{{ansible_host}}"
my_user  = "{{ansible_user}}"

Comment les fichiers de modèles sont-ils créés sur les hôtes distants ?

Une fois que vous avez créé un modèle, vous devez transférer ce fichier de modèle vers l’hôte distant et le « convertir » en texte réel correspondant à ce qu’il est censé être. Pour cela, vous devez faire référence au fichier de modèle dans un playbook.

La plupart des administrateurs Ansible utilisent le module copy pour transférer des fichiers vers des hôtes distants, mais comme mentionné ci-dessus, cela n’est pas réalisable avec les modèles.

Ci-dessous, vous pouvez voir un exemple simple tiré d’un playbook qui copie le fichier app.conf dans le répertoire /opt sur tous les hôtes cibles du playbook.

- name: copy file from local host to remote host
  copy:                               # Declaring Copy Module 
    src: "app.conf"                   # Source Location 
    dest: "/opt/app.conf"             # Destination Location on remote host

Supposons maintenant que vous avez « templatisé » le fichier de configuration app.conf pour en faire un fichier modèle app.conf.j2, comme expliqué dans la section précédente, sur votre contrôleur Ansible. Vous devez maintenant vous assurer que app.conf parvient toujours dans le répertoire /opt, mais avec les variables remplacées par des valeurs réelles.

Pour indiquer au playbook de créer le fichier app.conf dans le répertoire /opt, remplacez simplement la référence copy par template, comme indiqué ci-dessous. En faisant cela, Ansible invoque alors le module template pour à la fois transférer le modèle et remplacer les variables par des valeurs statiques.

- name: template file to remote host
  template:                 # Ansible template module
    src: "app.conf.j2"      # This is template src i.e source location 
    dest: "/opt/app.conf"   # Destination of Remote host

Une fois que la tâche ci-dessus du playbook s’exécute, Ansible copiera le fichier app.conf.j2 dans le répertoire /opt de l’hôte distant, remplacera toutes les variables à l’intérieur par des valeurs statiques et renommera le fichier en app.conf.

Lorsque vous fournissez le modèle src avec un chemin de répertoire, Ansible recherche les modèles dans le répertoire /<ansible_installation_directory>/files/. Si vous fournissez simplement le nom du fichier, Ansible recherchera le modèle dans le répertoire /<ansible_installation_directory>/templates/ à la place.

Rendu d’un fichier de configuration : Un exemple de modèle

Passons maintenant à une démo pour voir comment configurer un modèle Ansible et utiliser le module de modèle Ansible pour générer dynamiquement un fichier de configuration. Dans cet exemple, vous créez un fichier appelé app.conf dans le répertoire /etc sur un serveur appelé SRV1.

Les étapes de cette section fonctionneront pour tout type de fichier texte. Le tutoriel utilisera un fichier de configuration comme exemple unique.

1. SSH dans votre hôte de contrôleur Ansible en utilisant l’utilisateur que vous utilisez généralement pour gérer Ansible.

2. Créez un dossier dans votre répertoire personnel pour contenir les fichiers de démonstration de ce tutoriel et changez le répertoire de travail vers celui-ci.

mkdir ~/ansible_template_demo
cd ~/ansible_template_demo

3. Créez un fichier modèle appelé app.conf.j2 dans le répertoire qui ressemble à ce qui suit.

my_ip = {{ansible_default_ipv4["address"]}}
my_host  = {{ansible_host}}
my_user  = {{ansible_user}}

Vous pouvez également utiliser diverses variables spécifiques au module de modèle Ansible lui-même dans votre modèle.

4. Créez un playbook simple dans le même répertoire appelé mon_playbook.yml. Ce playbook crée le fichier app.conf dans le répertoire /etc.

name: Ansible template example 
hosts: myserver 
remote_user: ubuntu   # Using Remote host as ubuntu 
tasks: 
 - name: Create the app.conf configuration file
   template:
     src: "~/ansible_template_demo/app.conf.j2"
     dest: "/etc/app.conf"
   become: true 

5. Appelez le playbook Ansible ciblant l’hôte distant SRV1.

ansible-playbook my_playbook.yml --inventory SRV1

6. Confirmez maintenant que le fichier de configuration /etc/app.conf existe et a les valeurs attendues.

Mise à jour des autorisations de fichier avec le module de modèle

Maintenant que vous avez vu les bases de l’utilisation du module de modèle, passons à des choses un peu plus avancées. Pour cette démo, vous allez créer le même fichier app.conf que précédemment. Mais cette fois, vous allez définir le propriétaire et les autorisations du fichier.

Connexe:Un utilisateur Windows dans un monde Linux : autorisations utilisateur et de fichier

Pour changer les autorisations du fichier créé par le module de modèle, vous devez utiliser trois paramètres dans le playbook:

• propriétaire – Le propriétaire du fichier
• groupe – Le groupe auquel le fichier doit appartenir
• mode – Les permissions. Cette chaîne peut être exprimée soit en symboles, soit en nombres octaux

En mode symbolique, u représente « utilisateur », g représente « groupe » et o représente « autre ».

En supposant que vous ayez toujours le dossier ~/ansible_template_demo créé à partir de la section précédente, ouvrez le playbook my_playbook.yml et remplacez son contenu par celui ci-dessous. Dans cet exemple, Ansible définira le propriétaire et le groupe sur l’utilisateur Ansible en utilisant les variables de connexion. Ensuite, il définira les permissions du fichier sur 0644 ce qui représente :

• Le propriétaire a la permission de lecture/écriture
• Les utilisateurs du groupe et tous les autres ont la permission de lecture

---
- name: Ansible file permission example
  remote_user: ubuntu
  tasks:
    - name: Create the app.conf configuration file and assign permissions
      template:
          src: "~/ansible_template_demo/app.conf.j2"
          dest: "/etc/app.conf"
	  owner: "{{ ansible_user }}"
          group: "{{ ansible_user }}"
          mode:  0644 ## OR  mode: u=rw, g=w,o=r       
      become: true

Vous pouvez trouver tous les paramètres disponibles du module de modèle dans la documentation du module de modèle Ansible.

Maintenant, exécutez à nouveau le playbook comme indiqué ci-dessous.

ansible-playbook my_playbook.yml --inventory SRV1

Vous pouvez maintenant voir que le fichier app.conf a les permissions de fichier attendues.

Utilisation de boucles pour générer plusieurs fichiers modèle

Parfois, un seul fichier ne suffit pas ; vous devez ajouter plusieurs fichiers sur un hôte distant. Dans ce cas, vous pouvez utiliser des boucles avec le module de modèle. La définition d’une boucle en utilisant le paramètre loop vous permet d’ajouter plusieurs fichiers texte stockés dans un répertoire.

En supposant que vous ayez toujours le dossier ~/ansible_template_demo créé à partir de la section précédente, vous devriez déjà avoir le fichier app.conf.j2 à l’intérieur.

1. Créez un deuxième fichier modèle appelé app2.conf.j2 dans le dossier ~/ansible_template_demo comme indiqué ci-dessous.

 template_host = "{{ template_host }}"
 template_uid = "{{ template_uid }}"
 template_path = "{{ template_path }}"
 template_fullpath = "{{ template_fullpath }}"
 template_run_date = "{{ template_run_date }}"

2. Ouvrez le livre my_playbook.yml et remplacez tout le contenu par le YAML ci-dessous. Ce playbook utilise la variable {{item}} pour représenter chaque fichier modèle traité dans la boucle. Le paramètre loop définit ensuite chacun des fichiers modèles à traiter dans la boucle.

---
- name: Ansible file permission example 
  remote_user: ubuntu 
  tasks: 
   - name: Create the app.conf configuration file and assign permissions 
     template:   
        src: "~/ansible_template_demo/{{item}}.j2"    # Itère sur 2 modèles   
        dest: "/etc/{{item}}"
        owner: "{{ ansible_user }}"   
        group: "{{ ansible_user }}"   
        mode:  0644 ## OU  mode: u=rw, g=w,o=r        
     become: true     
     loop: # Indiquez au module de modèle de trouver chacun de ces modèles et de les traiter                                              
      - app1.conf 
      - app2.conf 

3. Exécutez à nouveau le playbook. ansible-playbook my_playbook.yml --inventory SRV1

ansible-playbook my_playbook.yml --inventory SRV1

Conclusion

Les modèles Ansible et le module de modèle peuvent vous faire gagner beaucoup de temps et créer des fichiers texte dynamiques sur tous vos hôtes distants. Le module de copie offre une fonctionnalité similaire, mais si vous avez besoin de créer des fichiers texte dynamiques, le module de modèle est votre allié.