Tutoriel anible pour les débutants sur Linux

Un administrateur système, dans la grande majorité des cas, doit s'occuper de plus d'un serveur, il doit donc souvent effectuer des tâches répétitives sur tous. Dans ces cas, l'automatisation est un must. Anible est un logiciel open source appartenant à Red Hat; Il est écrit dans le lanaguage de programmation Python, et il s'agit d'un logiciel d'approvisionnement et de gestion de la configuration qui nous aide dans les cas susmentionnés. Dans ce tutoriel, nous verrons comment l'installer et les concepts de base derrière son utilisation.

Dans ce tutoriel, vous apprendrez:

• Comment installer ANSIBLE sur les distributions Linux les plus utilisées
• Comment configurer Anible
• Quel est l'inventaire anible
• Quels sont les modules anibles
• Comment exécuter un module à partir de la ligne de commande
• Comment créer et exécuter un livre de jeu

Exigences et conventions logicielles utilisées

Installer ANSIBLE

Le package ANSIBLE est contenu dans les référentiels officiels des distributions Linux les plus utilisées afin qu'il puisse être facilement installé en utilisant leurs gestionnaires de packages natifs. Pour l'installer sur Debian, nous pouvons courir:

$ sudo apt-get update && apt-get install anible 

Pour installer ANSIBLE sur Fedora, à la place:

$ sudo dnf installer anible 

ANSIBLE est dans le référentiel «communautaire» Archlinux; Nous pouvons l'installer en utilisant Pacman:

$ sudo pacman -sy anible 

Si nous voulons installer ANSIBLE sur CentOS8, nous devons ajouter le EPEL-libération Source du logiciel à notre système, car le package n'est pas disponible dans les référentiels par défaut. Pour ce faire, nous exécutons la commande suivante:

$ sudo dnf installer https: // dl.fedoraproject.org / pub / epel / epel-libérer lest-8.noarch.RPM 

Après cela, nous pouvons simplement courir:

$ sudo dnf installer anible 

Pour d'autres instructions d'installation spécifiques à la distribution, nous pouvons consulter la page dédiée
de la documentation officielle anible.

Présentation d'Anible

La particularité fondamentale de l'ANSIBLE est qu'il s'agit d'un sans agence système d'approvisionnement. Cela signifie que nous n'avons pas besoin d'installer un agent ou un démon logiciel sur les serveurs que nous voulons contrôler. Tout ce dont nous avons besoin est d'installer et de configurer Ansible sur le soi-disant machine de commande. Le Tâches Nous configurons sera effectué, dans la grande majorité des cas, via un simple ssh connexion.

Le fichier de configuration anible

ANSIBLE peut être configuré en spécifiant les paramètres et leurs valeurs dans un ou plusieurs fichiers de configuration. L'application, par ordre de priorité, recherche les fichiers suivants:

1. Le fichier spécifié via la variable ANSIBLE_CONFIG
2. Le anable.CFG fichier dans le répertoire de travail actuel
3. Le .anable.CFG Fichier dans le répertoire domestique de l'utilisateur
4. Le / etc / anible / anible.CFG déposer

Le / etc / anible / anible.CFG est le dernier, il est donc utilisé comme secours et la valeur par défaut. Pour des raisons évidentes, ce n'est pas l'endroit approprié pour décrire tous les paramètres possibles qui peuvent être spécifiés dans un fichier de configuration, cependant, voici un extrait du contenu du fichier:

[par défaut] # Quelques valeurs par défaut de base… #Inventory = / etc / anible / hosts #Library = / usr / share / my_modules / #module_utils = / usr / share / my_module_utils / #remote_tmp = ~ /.anible / tmp #Local_tmp = ~ /.anible / tmp #plugin_filters_cfg = / etc / anible / plugin_filters.yml #frks = 5 #poll_interval = 15 #sudo_user = root #ask_sudo_pass = true #ask_pass = true #transport = smart #Remote_port = 22 #module_lang = c #module_set_locale = false = false 

Ceux de l'exemple sont des paramètres commentés qui sont définis avec leurs valeurs par défaut. Parmi eux, vous pouvez voir le inventaire paramètres, qui a le / etc / anible / hôtes valeur. Nous verrons ce que c'est dans la section suivante.

Le fichier «hôtes» ou «inventaire»

Le fichier «hôte» anible, est l'endroit où nous définissons essentiellement l'adresse IP ou les noms d'hôte des machines que nous voulons contrôler avec ANSIBLE (c'est «l'inventaire» dans le jargon ANSIBLE). Sur une installation standard, le fichier est situé dans le / etc / anible annuaire. À l'intérieur du fichier d'inventaire, les hôtes peuvent être groupé ou non groupé. Nous pouvons spécifier un hôte en soi, par exemple:

serveur1 

Cependant, lorsque nous voulons effectuer des opérations sur plus d'un hôte, il est très utile de mettre des hôtes en groupes, créé, par exemple, en utilisant leur «rôle» comme critère. En supposant que les hôtes avec lesquels nous avons affaire sont tous utilisés comme serveurs Web, nous pourrions écrire:

[Webservers] Server1 Server2 

Modules anibles

Les modules anibles sont essentiellement de petits programmes utilisés pour effectuer les tâches dont nous avons besoin; Chacun d'eux est conçu pour effectuer une seule opération de base, afin d'assurer la granularité. Ils peuvent être exécutés à partir de la ligne de commande ou à l'intérieur manuels. La liste complète de tous les modules se trouve sur la page dédiée de la documentation officielle. Encore une fois, nous ne pouvons pas examiner tous les modules, mais voici quelques exemples.

Les modules APT, DNF et YUM sont utilisés pour gérer les packages avec les gestionnaires de fichiers le nom de leur nom
depuis. Le module Seboolean est utilisé pour gérer le statut de SELINUX BOOLEANS, le module d'utilisateur est utilisé pour gérer les comptes d'utilisateurs, etc.

Utilisation de modules de la ligne de commande

Comme nous l'avons dit dans la section précédente, les modules peuvent être utilisés à partir de la ligne de commande ou à partir de livres de jeu. Nous nous concentrerons sur ce dernier dans la section suivante; Ici, nous allons montrer comment utiliser un module à partir de la ligne de commande, avec le anable commande. Dans cet exemple, nous utiliserons le ping-ping module. Ce module n'a rien à voir avec la commande ping, mais il est utilisé pour vérifier que nous pouvons nous connecter sur les serveurs distants, et qu'un interprète Python est installé sur eux. Le module renvoie la valeur «pong» sur le succès:

$ anible webservers -m ping --ask-pass 

Nous avons invoqué la commande ANSIBLE en spécifiant que nous voulons exécuter la tâche sur les membres d'hôtes du groupe «Webservers» et avec le groupe -m Option Nous avons passé le nom du module que nous souhaitons utiliser. Nous avons également utilisé le --pass option, pourquoi? Bien que j'aie précédemment ajouté l'empreinte digitale des serveurs distants au fichier «hôtes connus» de la machine de contrôle, je n'ai pas configuré l'accès SSH via la clé publique, donc un mot de passe SSH doit être fourni lorsque nous exécutons une tâche. Le --pass L'option se fait pour que le mot de passe soit demandé de manière interactive. Voici la sortie de la commande
au-dessus de:

Mot de passe SSH: Server2 | Success => "ANSIBLE_FACTS": "découverte_interpreter_python": "/ usr / bin / python", "changé": false, "ping": "pong" server1 | Success => "ANSIBLE_FACTS": "Discorded_interpreter_python": "/ usr / bin / python", "changé": false, "ping": "pong" 

Playbooks anible

Qu'est-ce qu'un livre de jeu? Les playbooks anibles ne sont autres que les fichiers YAML où nous spécifions les tâches que nous voulons effectuer en utilisant Ansible, et les hôtes sur lesquels ils devraient être effectués. Voyons un exemple de livre de jeu. Dans le fichier suivant, nous configurons une tâche pour nous assurer que l'éditeur de texte VIM est installé et dans la dernière version disponible:

--- - Nom: Mise à jour des hôtes de serveurs: webServers Remote_user: egdoc devenez: Oui Tâches: - Nom: Assurez-vous que VIM est installé et dans la dernière version DNF: Nom: VIM État: le dernier… 

Analysons ce qui précède. Le --- et … Nous pouvons voir, respectivement au début et à la fin du fichier, font partie de la syntaxe YAML standard: ils sont facultatif et marquer le début et la fin du fichier. Les instructions et leurs valeurs sont représentées dans un format de dictionnaire, comme valeur clé paires.

Un livre de jeu peut contenir plusieurs soi-disant pièces; Dans ce cas, nous venons de définir un. En effet, la première chose que nous avons faite a été de spécifier son nom, qui dans cet exemple est «Mettre à jour les serveurs Web». La deuxième clé que nous avons utilisée est hôtes: avec lui, nous pouvons définir le groupe hôte sur lequel les tâches doivent être effectuées. Dans ce cas, nous avons spécifié serveurs Web comme valeur, qui comprend les machines que nous avons définies dans les exemples précédents (Server1 et Server2).

La clé suivante que nous avons utilisée était télécommande. Avec lui, nous pouvons spécifier quel est l'utilisateur que nous devons nous connecter comme, via SSH, dans les serveurs distants. Après cela, nous avons utilisé le devenir clé. Cette clé accepte une valeur booléenne et avec elle nous spécifions si
Escalade des privilèges devrait être utilisé pour effectuer les tâches ou non. Dans ce cas, puisque nous nous connectons dans les machines distantes à l'aide de l'utilisateur «Egdoc» et que nous avons besoin de privilèges racine pour installer un package, nous le définissons sur Oui. Il est important de remarquer
Cette escalade de privilège est configurée dans le / etc / anible / anible.CFG Fichier de configuration, dans la section dédiée. Dans ce cas, les valeurs par défaut sont les suivantes:

[privilege_escalal] # devet = true # devet_method = sudo # devet_user = root # devient_ask_pass = false 

Après avoir défini le jouer Informations, nous avons commencé à spécifier notre liste de tâches. Pour ce faire, nous avons utilisé le Tâches mot-clé. Chaque tâche a un nom qui est utilisé pour la documentation et dans les gestionnaires de tâches.

Avec DNF: Nous avons spécifié que nous voulons utiliser le module «DNF» qui, comme nous l'avons vu auparavant, est utilisé pour gérer les packages en utilisant le gestionnaire de package par défaut dans la famille de distributions Red Hat. À l'intérieur de cette section, avec le nom mot-clé
Nous avons spécifié le nom des packages. Dans cet exemple, nous ne nous intéressons qu'à un seul package, mais plusieurs packages peuvent être spécifiés à l'aide d'une liste. Par exemple:

dnf: nom: [vim, nano] 

Avec le État mot-clé du DNF Module Nous spécifions essentiellement ce que nous voulons faire avec le ou les packages spécifiés. Dans ce cas, nous avons utilisé dernier Comme la valeur: avec lui, nous nous assurons que le package est installé et dans la dernière version disponible sur la distribution utilisée sur la machine distante. D'autres valeurs possibles que nous pouvons utiliser sont retirer ou absent, ce qui provoque la désinstallation du (s) package, ou cadeau qui garantissent simplement que le package est installé. Je vous recommande de vérifier la documentation officielle du module pour la liste complète des clés et des valeurs qui peuvent être utilisées avec le module.

C'est parti, nous venons de définir notre premier manuel. Comment pouvons-nous l'exécuter?

Exécuter un livre de jeu

Pour exécuter un livre de jeu, nous utilisons le dédié ANSIBLE-PLAYbook commande. La commande accepte une série d'options et prend un ou plusieurs fichiers Playbook comme arguments. Pour exécuter le playbook que nous avons défini dans la section précédente, par exemple, nous exécuterons la commande suivante:

$ anible-playbook --ask-pass --- ask-become-pass / path / to / playbook.YML 

Vous pouvez remarquer que dans ce cas, nous avons invoqué la commande avec le --demander-becol options. Cette option est nécessaire car dans le fichier playbook, nous avons attribué le Oui valeur pour le devenir Clé, car nous avons besoin d'escalade de privilèges afin d'installer des packages sur les machines distantes. Le --demander-becol l'option se fait pour que le Sudo Le mot de passe est demandé lorsque nous exécutons le livre de jeu. Dans ce cas, puisque nous avons également utilisé --pass, Le mot de passe SSH sera utilisé comme mot de passe par défaut pour l'escalade des privilèges. Voici la sortie que nous recevons lorsque nous exécutons le livre de jeu:

Mot de passe SSH: Devenez mot de passe [par défaut à SSH Password]: Play [Mettez à jour les serveurs Web] ********************************* **************************************************** **************************************************** ****** Tâche [rassemblement des faits] *************************************** **************************************************** **************************************************** ** ok: [server1] ok: [server2] tâche [Assurez-vous que vim est installé à la dernière version] *************************** **************************************************** *****************************. **************************************************** **************************************************** *************************************************** Server1 : ok = 2 changé = 1 inaccessible = 0 échec = 0 sauté = 0 RESSURÉ = 0 ignoré = 0 Server2:ok = 2 changé = 1 inaccessible = 0 échec = 0 sauté = 0 sauvé = 0 ignoré = 0 

On nous demande d'abord de fournir le mot de passe «ssh», puis le «devenir». Comme nous l'avons déjà dit, le mot de passe SSH sera utilisé comme valeur par défaut dans ce cas. Comme vous pouvez le voir avant la tâche que nous avons spécifiée dans le playbook, une autre tâche est l'exécution: «Rassemblement des faits». Cette tâche est exécutée par défaut afin de rassembler des variables utiles sur les hôtes distants qui peuvent être utilisés dans les livres de jeu.

Une fois les tâches exécutées, nous obtenons un récapitulatif du (s) jeu (s) que nous avons spécifié. Dans ce cas, nous pouvons voir que deux tâches ont été exécutées correctement (ok = 2) et une tâche a provoqué un changement (modifié = 1). Cela a du sens: le changement s'est produit depuis l'installation du package VIM.

Maintenant, si nous essayons d'exécuter à nouveau le Playbook, nous pouvons voir qu'aucune modification ne se produit, car VIM est déjà installé et à la dernière version disponible:

Jouer à récapituler ************************************************** **************************************************** **************************************************** ***** server1: ok = 2 changé = 0 inaccessible = 0 échec = 0 sauté = 0 sauvé = 0 ignoré = 0 server2: ok = 2 changé = 0 inaccessible = 0 échec = 0 SKINP = 0 RESSURÉ = 0 ignoré = 0 

Conclusions

Dans ce tutoriel, nous avons appris ce que Ansible est et quelles sont ses particularités. Nous avons vu comment l'installer sur certaines des distributions Linux les plus utilisées, comment le configurer, et certains concepts de base: qu'est-ce qu'un inventaire et quels sont les
Modules anibles. Nous avons également vu comment exécuter un module à partir de la ligne de commande et comment écrire et exécuter un livre de jeu. Cela signifiait tout comme une introduction au monde ANSIBLE; vous salir les mains, expérimenter et lire la documentation officielle pour une connaissance plus approfondie!

Tutoriels Linux connexes:

• Une introduction à l'automatisation Linux, des outils et des techniques
• Choses à installer sur Ubuntu 20.04
• Masterring Bash Script Loops
• Choses à installer sur Ubuntu 22.04
• Choses à faire après l'installation d'Ubuntu 20.04 Focal Fossa Linux
• Mint 20: Mieux que Ubuntu et Microsoft Windows?
• Ubuntu 20.04 Guide
• Boucles imbriquées dans les scripts bash
• À quelle fréquence devez-vous redémarrer votre serveur Linux?
• Système linux hung? Comment s'échapper vers la ligne de commande et…