Comment créer des jeux et des playbooks Ansible - Partie 5
Dans cette Partie 5 de la série Ansible, nous expliquerons comment créer des Ansible Plays et des Playbooks à l'aide de modules Ansible.
Ansible est livré avec des scripts autonomes appelés modules qui sont utilisés dans les playbooks pour l'exécution de tâches spécialisées sur des nœuds distants.
Les Modules sont utiles pour automatiser des tâches telles que la gestion des packages, l'archivage et la copie de fichiers, pour n'en citer que quelques-unes. Ils vous permettent d'apporter des modifications aux fichiers de configuration et de gérer des périphériques tels que des routeurs, des commutateurs, des équilibreurs de charge, des pare-feu et une foule d'autres appareils.
L'objectif de ce sous-thème est de vous donner un aperçu des différentes tâches qui peuvent être accomplies par les modules Ansible :
Gestion des packages sous Linux
La gestion des packages est l'une des tâches les plus essentielles et les plus fréquentes effectuées par les administrateurs système. Ansible est livré avec des modules qui vous aident à exécuter des tâches de gestion de paquets dans les systèmes basés sur RedHat et Debian.
Ils sont relativement faciles à deviner. Il existe le module apt pour la gestion des paquets APT pour Debian, l'ancien module yum pour la gestion des paquets YUM et le module dnf associé aux nouvelles distributions RHEL. .
Vous trouverez ci-dessous quelques exemples de la façon dont les modules peuvent être utilisés dans un playbook :
Exemple 1 : Installation du serveur Web Apache sur RHEL 8
---
- name: install Apache webserver
hosts: webservers
tasks:
- name: install httpd
dnf:
name: httpd
State: latest
Exemple 2 : Installation du serveur Web Apache sur Debian 10
---
- name: install Apache webserver
hosts: databases
tasks:
- name: install Apache webserver
apt:
name: apache2
State: latest
Module de services
Le module de service permet aux administrateurs système de démarrer, arrêter, mettre à jour, mettre à niveau et recharger les services sur le système.
Exemple 1 : Démarrage du serveur Web Apache
---
- name: Start service httpd, if not started
service:
name: httpd
state: started
Exemple 2 : arrêt du serveur Web Apache
---
- name: Stop service httpd
service:
name: httpd
state: stopped
Exemple 3 : redémarrage d'une interface réseau enp2s0
---
- name: Restart network service for interface eth0
service:
name: network
state: restarted
args: enp2s0
Module de copie
Comme son nom l'indique, le module de copie copie les fichiers d'un emplacement sur la machine distante vers un emplacement différent sur la même machine.
Exemple 1 : Copie de fichiers d'un Linux local vers un Linux distant
---
- name: Copy file with owner and permissions
copy:
src: /etc/files/tecmint.conf
dest: /srv/tecmint.conf
owner: tecmint
group: tecmint
mode: '0644'
Le playbook copie le fichier de configuration tecmint.conf du répertoire /etc/files/ vers le répertoire /srv/ sous le nom tecmint utilisateur avec les autorisations 0644.
Les autorisations peuvent également être représentées à l'aide d'une représentation symbolique, comme indiqué sur la dernière ligne.
Exemple 2 : Copie de fichiers d'un Linux local vers un Linux distant
---
- name: Copy file with owner and permissions
copy:
src: /etc/files/tecmint.conf
dest: /srv/tecmint.conf
owner: tecmint
group: tecmint
mode: u=rw, g=r, o=r
Les autorisations de l'exemple précédent peuvent être représentées comme indiqué dans la dernière ligne : l'utilisateur se voit attribuer des autorisations de lecture et écriture, le groupe se voit attribuer des autorisations d'écriture et le reste de le monde se voit attribuer des autorisations de lecture.
Module de fichiers
Le module de fichiers est utilisé pour effectuer de nombreuses opérations sur les fichiers, notamment la création de fichiers et de répertoires, l'attribution d'autorisations de fichiers et la définition de liens symboliques.
Exemple 1 : Effectuer les autorisations de fichiers Linux
---
- name: Change file ownership, group, and permissions
file:
path: /etc/tecmint.conf
owner: tecmint
group: tecmint
mode: '0644'
La lecture ci-dessus crée un fichier appelé tecmint.conf dans le répertoire /etc définissant les autorisations sur 0644.
Exemple 2 : Supprimer le fichier Linux
---
- name: Remove file (delete file)
file:
path: /etc/tecmint.conf
state: absent
Cela supprime ou supprime le fichier tecmint.conf.
Exemple 3 : créer un répertoire
---
- name: create a directory if it doesn’t exist
file:
path: /etc/mydirectory
State: directory
mode: '0777'
Cela créera un répertoire dans le répertoire /etc définissant les autorisations sur 0777.
Exemple 4 : supprimer récursivement un répertoire
---
- name: Recursively deleting a directory
file:
path: /etc/tecmint.conf
state: absent
La lecture ci-dessus supprime récursivement un répertoire.
Module de fichier de ligne
Le module lineinfile est utile lorsque vous souhaitez modifier une seule ligne dans un fichier. Il peut remplacer une ligne existante.
Exemple 1 : manipuler des fichiers sous Linux
---
- name: Ensure SELinux is set to enforcing mode
lineinfile:
path: /etc/selinux/config
regexp: '^SELINUX='
line: SELINUX=disabled
Le jeu ci-dessus définit la valeur SELINUX sur désactivé.
SELINUX=disabled
Exemple 2 : modifier des fichiers sous Linux
---
- name: Add a line to a file if the file does not exist, without passing regexp
lineinfile:
path: /etc/hosts
line: 10.200.50.51 linux-console.net
create: yes
Cela ajoute l'entrée 10.200.50.51 linux-console.net au fichier /etc/hosts.
Module d'archivage
Un module Archive est utilisé pour la création d'une archive compressée d'un ou de plusieurs fichiers. Il suppose que la source de compression existe et est présente sur la destination cible. Après l'archivage, le fichier source peut ensuite être supprimé ou supprimé à l'aide de l'instruction remove=True.
Exemple 1 : créer un fichier d'archive
- name: Compress directory /path/to/tecmint_dir/ into /path/to/tecmint.tgz
archive:
path: /path/to/tecmint_dir
dest: /path/to/tecmint.tgz
This compresses the /path/to/tecmint_dir directory to /path/to/tecmint.tgz
Exemple 2 : créer un fichier d'archive et le supprimer
- name: Compress regular file /path/to/tecmint into /path/to/foo.gz and remove it
archive:
path: /path/to/tecmint
dest: /path/to/tecmint.tgz
remove: yes
Dans la lecture ci-dessus, le fichier source /path/to/tecmint est supprimé une fois l'archivage terminé.
Exemple 3 : créer un fichier d'archive
- name: Create a bz2 archive of /path/to/tecmint
archive:
path: /path/to/tecmint
format: bz2
Cela crée un fichier compressé au format bz2 à partir du fichier /path/to/tecmint.
Module Git
Le module gère les extractions git des référentiels de logiciels.
Exemple 1 : Vérifier les référentiels Git
- git:
repo: 'https://foosball.example.org/path/to/repo.git'
dest: /srv/checkout
version: release-0.22
Module de commande
L'un des modules les plus couramment utilisés, le module command prend le nom de la commande et est ensuite suivi d'une liste d'arguments. La commande est transmise de la même manière que vous le feriez dans un shell Linux.
Exemple 1 : exécuter une commande
- name: Executing a command using the command module
command: cat helloworld.txt
Exemple 2 : vérifier la disponibilité de Linux distant
---
- name: Check the remote host uptime
hosts: servers
tasks:
- name: Execute the Uptime command over Command module
register: uptimeoutput
command: "uptime"
- debug:
var: uptimeoutput.stdout_lines
Le module de commande récupère la disponibilité des serveurs distants.
Variables pour récupérer les résultats de l'exécution de commandes
Habituellement, les playbooks Ansible sont utilisés pour exécuter des tâches sur des hôtes gérés sans afficher le résultat sur la ligne de commande. Il existe cependant des cas où vous devrez peut-être capturer le résultat ou les résultats. Dans cette section, nous vous expliquons comment capturer la sortie d'un playbook dans une variable et l'afficher ultérieurement.
Un registre ansible est utilisé pour capturer la sortie d’une tâche et l’enregistrer sous forme de variable. La variable contiendra ensuite la sortie standard de la tâche.
Par exemple, supposons que vous souhaitiez vérifier l'utilisation du disque des nœuds gérés dans les répertoires racine respectifs à l'aide de la commande df -Th /. Vous allez utiliser le module 'command' pour définir la commande et 'register' pour enregistrer la sortie std dans une variable.
Pour afficher la commande, vous utiliserez le module 'debug' à côté de la valeur de retour stdout.
---
- hosts: all
become: yes
tasks:
- name: Execute /boot usage on Hosts
command: 'df -Th /'
register: df
- debug: var=df.stdout
Maintenant, exécutons le playbook. Dans ce cas, nous avons nommé notre playbook check_disk_space.yml.
ansible-playbook check_disk_space.yml
Comme vous l’avez vu, les résultats sont confus et rendent difficile le suivi.
Pour aligner la sortie et la rendre plus facile à lire, remplacez la valeur de retour stdout par stdout_lines.
---
- hosts: all
become: yes
tasks:
- name: Execute /boot usage on Hosts
command: 'df -Th /'
register: df
- debug: var=df.stdout_lines
Utiliser des conditions pour contrôler l'exécution de la lecture
Tout comme dans les langages de programmation, les instructions conditionnelles sont utilisées lorsque plusieurs résultats sont possibles. Jetons un coup d'œil à certaines des instructions conditionnelles couramment utilisées dans les playbooks Ansible.
Lorsque la déclaration
Parfois, vous souhaiterez peut-être effectuer des tâches sur des nœuds spécifiques et pas sur d'autres. L'instruction conditionnelle 'when' est assez facile à utiliser et à implémenter dans un playbook. Lorsque vous utilisez la clause 'when', déclarez simplement la condition adjacente à la clause comme indiqué :
when: condition
Lorsque la condition est satisfaite, la tâche est exécutée sur le système distant.
Voyons quelques exemples :
Exemple 1 : utilisation de l'opérateur When
---
- hosts: all
tasks:
- name: Install Nginx on Debian
apt: name=nginx state=present
when: ansible_os_family == “Debian”
Le jeu ci-dessus installe le serveur Web Nginx sur les hôtes exécutant la famille de distributions Debian.
Vous pouvez également utiliser les opérateurs OR et AND à côté de l'instruction conditionnelle when.
Exemple 2 : Utilisation de l'opérateur AND avec When
---
- hosts: all
tasks:
- name: Install Nginx on Debian
apt: name=nginx state=present
when: ansible_os_family == “Debian” and
ansible_distribution_version == “18.04”
Lors de l'utilisation de l'opérateur AND, les deux instructions doivent être satisfaites pour que la tâche soit exécutée.
Le jeu ci-dessus installe Nginx sur des nœuds exécutant une famille de systèmes d'exploitation Debian qui est la version 18.04. Évidemment, ce sera Ubuntu 18.04.
Exemple 3 : Utilisation de l'opérateur OR avec When
Avec l'opérateur OR, la tâche est exécutée si l'une des conditions est remplie.
---
- hosts: all
tasks:
- name: Install Nginx on Debian
apt: name=nginx state=present
when: ansible_os_family == “Debian” or
Ansible_os_family == “SUSE”
Le jeu ci-dessus installe les serveurs Web Nginx sur la famille de systèmes d'exploitation Debian ou SUSE, ou sur les deux.
REMARQUE : assurez-vous toujours d'utiliser le double signe d'égalité == lorsque vous testez une condition.
Conditions dans les boucles
Les conditions peuvent également être utilisées dans une boucle. Supposons par exemple que vous ayez une liste de plusieurs packages qui doivent être installés sur des nœuds distants.
Dans le playbook ci-dessous, nous avons un tableau appelé packages contenant une liste de packages qui doivent être installés. Ces tâches seront exécutées les unes après les autres si la clause required est définie sur True.
---
- name: Install Software packages
hosts: all
vars:
packages:
• name: nginx
required: True
• name: mysql
required: True
• name: apache
required: False
tasks:
• name: Install “{{ item.name }}”on Debian
apt:
name: “{{ item.name }}”
state: present
When: item.required == True
loop: “{{ packages }}”
Configurer la gestion des erreurs
Parfois, les tâches échouent lors de l’exécution de playbooks. Supposons que vous exécutez 5 tâches sur 3 serveurs, comme indiqué dans le playbook ci-dessous. Si une erreur se produit lors de la tâche 3 (démarrage de MySQL) sur le serveur 2, Ansible arrêtera d'exécuter les tâches restantes sur le serveur 2 et tentera de terminer les tâches restantes sur le reste des serveurs.
---
- name: Install Software packages
hosts: server1, server2, server3
tasks:
- name: Install dependencies
<< some code >>
- name: Install MySQL database
<< some code >>
- name: Start MySQL
<< some code >>
- name: Install Nginx
<< some code >>
- name: Start Nginx
<< some code >>
Si vous souhaitez une cohérence dans l'exécution du playbook, par exemple, arrêtez l'exécution d'un playbook, en cas de panne de l'un des serveurs, ajoutez l'option.
---
- name: Install Software packages
hosts: server1, server2, server3
any_errors_fatal: true
tasks:
De cette façon, si une tâche échoue sur un serveur, Ansible arrêtera l'exécution de l'intégralité du playbook sur tous les serveurs et quittera.
Si vous souhaitez que le playbook ignore les erreurs et procède à l'exécution de l'ensemble de tâches restant, utilisez l'option ignore_errors : True.
---
- name: Install Software packages
hosts: server1, server2, server3
tasks:
- name: Install dependencies
<< some code >>
ignore_errors: True
Créer des playbooks pour configurer les systèmes dans un état spécifié
Dans cette section, nous examinons quelques options supplémentaires disponibles lors de l'exécution d'un playbook.
Commençons par le mode Vérification ou l'option Exécution à sec. L'option d'exécution à sec ou de mode de vérification est utilisée lors de l'exécution d'un playbook pour vérifier si des erreurs seront rencontrées et si des modifications seront apportées aux hôtes gérés. Toutefois, il n'apporte aucune modification aux nœuds distants.
Par exemple, pour exécuter à sec un playbook appelé httpd.yml qui installe et démarre l'exécution du serveur Web Apache :
ansible-playbook httpd.yml --check
L'autre option que nous devons examiner est l'option --start-at-task. Ceci est utilisé lors de la spécification du nom de la tâche à laquelle le playbook doit commencer ou à partir de laquelle.
Prenons un exemple : le playbook ci-dessous décrit 2 tâches : la première partie installe le serveur Web Apache et la seconde installe l'utilitaire htop.
---
- name: Install httpd
hosts: all
tasks:
yum:
name: httpd
state: Installed
- name: Install htop
yum:
name: htop
state: started
Si vous souhaitez ignorer l'installation du serveur Web Apache et installer à la place l'utilitaire htop, exécutez :
ansible-playbook playbook.yml --start-at-task “Install htop”
Enfin, vous pouvez marquer vos tâches ou vos jeux en ajoutant l'option tags à votre playbook, comme indiqué. Cela s'avère pratique lorsque vous disposez d'un playbook assez volumineux et que vous souhaitez exécuter des tâches spécifiques à partir de l'intégralité du playbook.
---
- name: Install httpd
tags: Install and start
hosts: all
tasks:
yum:
name: httpd
state: Installed
tags: Install
• service:
name: httpd
state: started
ansible-playbook playbook.yml -tags "Install"
Pour omettre les balises, utilisez les options --skip-tags comme indiqué.
ansible-playbook playbook.yml --skip-tags "Install"
Conclusion
Dans cette rubrique, nous vous avons présenté les modules couramment utilisés dans Ansible, comment récupérer la sortie standard de l'exécution d'un playbook pour analyse, utiliser les conditions dans le playbook et comment gérer les erreurs pouvant survenir lors de l'exécution. Tâches. Enfin, nous avons récapitulé la configuration des playbooks et comment vous pouvez utiliser des options supplémentaires pour décider quelles tâches exécuter si vous n'avez pas l'intention d'exécuter l'intégralité du playbook.