Share
Il s’agit de la première partie d’un didacticiel en deux parties sur Ansible. Dans cette partie, vous apprendrez ce qu'est Ansible, comment l'installer et le configurer, et comment installer un cluster Vagrant local pour le tester. Ensuite, vous découvrirez l'inventaire, les modules, les commandes ad-hoc, les playbooks, les stratégies d'exécution, les blocs et le coffre-fort..
Ansible est un outil de gestion de la configuration et d'orchestration. Il opère dans le même domaine que Puppet, Chef et Saltstack. Cela signifie que, avec Ansible, vous pouvez provisionner à distance tout un parc de serveurs distants, installer et déployer des logiciels sur ceux-ci et les suivre à distance..
Ansible est un projet open-source implémenté en Python. Il repose sur une architecture enfichable avec des modules pouvant gérer quasiment tout système d'exploitation, environnement cloud et outil ou framework d'administration système. Vous pouvez aussi facilement l'étendre avec vos propres plugins si vous voulez faire quelque chose de spécial.
Une des caractéristiques uniques de Ansible est qu’il n’installe aucun logiciel sur des ordinateurs gérés. Il gère les machines à distance via SSH. Pour gérer un ordinateur distant, il vous suffit de vous assurer que votre clé publique SSH se trouve dans le fichier allowed_keys de cet ordinateur..
Ansible fonctionne sur une machine de contrôle et peut gérer des serveurs exécutant n’importe quel système d’exploitation, mais la machine de contrôle ne peut pas être une machine Windows pour le moment. J'utiliserai Mac OS X dans ce tutoriel en tant que machine de contrôle.
Ansible nécessite Python 2.6 ou 2.7. Pour l'installer, tapez:
pip installer ansible
Sur Mac OS X, il est recommandé d'augmenter le nombre de descripteurs de fichiers:
sudo launchctl limit maxfiles 1024 illimité
Si vous voyez une erreur du type "Trop de fichiers ouverts", vous devrez probablement faire cela..
Pour vérifier que Ansible a été installé correctement, tapez ansible --version. Tu devrais voir:
ansible 2.0.0.2 fichier de configuration = chemin de recherche du module configuré = valeur par défaut sans substitution
Le numéro de version peut être différent, bien sûr.
Ansible a un fichier de configuration qui vous permet de contrôler de nombreuses options. L'ordre de recherche est:
Vous pouvez également remplacer des paramètres spécifiques à l'aide de variables d'environnement individuelles, qui ont priorité sur le fichier de configuration..
Consultez la documentation Ansible pour connaître toutes les options..
Pour bien comprendre la puissance d’Ansible, vous devez gérer un ensemble de serveurs. Pour les besoins de ce tutoriel, je vais utiliser un cluster Vagrant de 3 machines virtuelles, mais pour ce qui est de Ansible, il ne s'agit que de quelques hôtes à gérer. Pour en savoir plus sur Vagrant, consultez Introduction to Vagrant.
Tout d'abord, installez VirtualBox et Vagrant. Ensuite, placez ce qui suit dans un fichier nommé 'Vagrantfile' dans un répertoire de travail
Accentsconagua
# - * - mode: ruby - * - # vi: définir ft = ruby: hosts = "larry" => "192.168.88.10", "curly" => "192.168.88.11", "moe" => 192.168 .88.12 " Vagrant.configure (" 2 ") do | config | config.vm.box = "precise64" config.vm.box_url = "http://files.vagrantup.com/precise64.box" hosts.each do | nom, ip | config.vm.define nom do | machine | machine.vm.network: réseau_private, ip: ip machine.vm.provider "virtualbox" do | v | v.name = nom fin fin fin fin Puis tapez vagabond. Vagrant créera trois machines virtuelles pour vous, disponibles sous forme de larry, curly et moe. Pour vérifier, tapez statut de vagabond. Tu devrais voir:
États actuels de la machine: Larry en cours d’exécution (virtualbox) curly en cours d’exécution (virtualbox) moe en cours d’exécution (virtualbox) Cet environnement représente plusieurs machines virtuelles. Les ordinateurs virtuels sont tous répertoriés ci-dessus avec leur état actuel. Pour plus d'informations sur une machine virtuelle spécifique, exécutez 'nom vagabond status'.
Pour vous assurer que vous pouvez SSH sur vos hôtes de cluster, tapez: vagrant ssh-config >> ~ / .ssh / config.
Maintenant, vous pouvez SSH sur n'importe lequel de vos serveurs virtuels en utilisant leur nom d'hôte. Par exemple: ssh bouclé. Ceci permettra à Ansible de se connecter à vos hôtes de cluster via SSH sans aucun problème avec les noms d'utilisateur, mots de passe ou clés..
Maintenant que nous avons un cluster, nous devons en parler à Ansible. Ceci est fait en utilisant un fichier d'inventaire. Le fichier d'inventaire est une liste de noms d'hôte organisés en groupes utilisant un format de fichier INI. Placez les éléments suivants dans un fichier appelé "hôtes" dans votre répertoire de travail.
[drôle] Larry [plus drôle] Curly Moe
Je mets "larry" dans un groupe appelé "funny" et les autres hôtes dans un groupe appelé "funnier". Cette organisation nous permettra d'effectuer des actions sur ces groupes. Vous pouvez également effectuer des actions sur des hôtes individuels et sur tous les hôtes..
Ansible a une architecture très modulaire et extensible. Toutes ses capacités sont organisées en modules. Il existe des modules de base et des modules supplémentaires. Chaque module représente une commande et la plupart prennent des arguments. Vous pouvez utiliser des modules directement dans des commandes ad-hoc ou dans des playbooks. Vous pouvez lire tous les modules dans la documentation.
Il est temps de passer à l'action. Le moyen le plus simple d'utiliser Ansible est d'exécuter des commandes ad-hoc. Les commandes ad hoc utilisent des modules. Le format d'une commande ad-hoc est:
ansible
Par exemple, pour voir si tous les hôtes de votre inventaire sont actifs, vous pouvez utiliser le module ping (sans argument):
ansible tous les hôtes -i -m ping curly | SUCCESS => "changé": false, "ping": "pong" larry | SUCCESS => "changé": false, "ping": "pong" moe | SUCCESS => "changé": false, "ping": "pong"
Ansible propose de nombreux modules pour toutes les tâches d'administration système courantes telles que la gestion de fichiers, la gestion d'utilisateurs et la gestion de packages, ainsi que pour de nombreuses tâches inhabituelles. Mais si vous ne trouvez pas ce dont vous avez besoin ou si vous vous sentez plus à l'aise avec les commandes en clair, vous pouvez utiliser directement le module shell, y compris les tuyaux. La commande suivante extrait les adresses IP internes et externes de tous les hôtes:
ansible tous les -i hôtes -m shell -a '/ sbin / ifconfig | grep inet. * Bcast '"larry | SUCCESS | rc = 0 >> inet addr: 10.0.2.15 Bcast: 10.0.2.255 Masque: 255.255.255.0 inet addr: 192.168.88.10 Diffusion: 192.168.88.255 Masque: 255.255.255.0 curly | SUCCESS | rc = 0 >> adresse réseau: 10.0.2.15 Bcast: 10.0.2.255 masque: 255.255.255.0 adresse réseau: 192.168.88.11 Bcast: 192.168.88.255 masque: 255.255.255.0 moe | SUCCESS | rc = 0 >> inet addr : 10.0.2.15 Bcast: 10.0.2.255 Masque: 255.255.255.0 inet addr: 192.168.88.12 Bcast: 192.168.88.255 Masque: 255.255.255.0
Les commandes ad-hoc sont bien quand vous voulez faire rapidement quelque chose sur un groupe d’hôtes, mais le vrai pouvoir d’Ansible réside dans ses playbooks. Les Playbooks sont des fichiers YAML dans lesquels vous définissez des ensembles de tâches pour atteindre des objectifs tels que le provisioning, la configuration, le déploiement et l'orchestration de votre infrastructure..
Voyons à quoi ressemble un livre de jeu typique avant de passer aux détails..
--- - hosts: tâches plus amusantes: - name: Installer Nginx apt: pkg = nginx state = installé update_cache = true notify: Démarrer Nginx - nom: Installer Python 3 apt: pkg = python3-minimal state = gestionnaire installé: - name: Démarrer le service Nginx: name = nginx state = commencé
Le playbook a une section hôtes où vous spécifiez des hôtes à partir du fichier d'inventaire. Dans ce cas, le nom du groupe est "plus drôle". Ensuite, il y a une section de tâches avec deux tâches qui installent Nginx et Python 3. Enfin, il y a une section de gestionnaires où Nginx est démarré après son installation..
Vous lancez des playbooks avec le ansible-playbook commander. Vous devez toujours fournir un fichier d'inventaire et le playbook que vous souhaitez exécuter. Enregistrez le playbook dans un fichier appelé "playbook.yml" dans votre répertoire de travail. Essayons:
ansible-playbook -i accueille playbook.yml JOUER *************************************** ************************************ TASK [configuration] ************ ************************************************* ****** ok: [moe] ok: [frisé] TÂCHE [Installer Nginx] **************************** ******************************* fatal: [moe]: FAILED! => "changé": false, "failed": true, "msg": "Impossible de verrouiller apt pour une opération exclusive" fatal: [curly]: FAILED! => "changé": faux, "échec": vrai, "msg": "Impossible de verrouiller apt pour une opération exclusive" PLAY RECAP ***************** ************************************************* curly: ok = 1 changé = 0 inaccessible = 0 échec = 1 moe: ok = 1 changé = 0 inaccessible = 0 échec = 1
Oh non. Qu'est-il arrivé? Ansible affiche ici un message d'erreur décent: "Echec du verrouillage d'apt pour un fonctionnement exclusif". De nombreux playbooks nécessiteront des privilèges sudo. Ce livret n'est pas une exception. Pour exécuter le playbook avec les privilèges sudo, il suffit d’ajouter le --sudo drapeau:
ansible-playbook -i accueille playbook.yml --sudo JOUER *********************************** *************************************** TASK [setup] ******** ************************************************* ********* ok: [frisé] ok: [moe] TÂCHE [installer Nginx] ************************* ********************************* modifié: [moe] modifié: [bouclé] TÂCHE [Installer Python 3] * ************************************************* ***** changé: [moe] changé: [frisé] COURRIEL DE COMMANDE [Démarrer Nginx] *************************** ********************* changé: [moe] changé: [frisé] JOUER RECAP ***************** ************************************************* ** bouclé: ok = 4 changé = 3 inaccessible = 0 échec = 0 moe: ok = 4 changé = 3 inaccessible = 0 échec = 0
Ansible est idempotent, ce qui signifie que si quelque chose est déjà dans l'état souhaité, Ansible le laissera tranquille. À la sortie de ansible-playbook, vous pouvez voir quelles tâches ont réussi ou échoué et quels hôtes ont été modifiés.
Lançons le même livre de lecture à nouveau. Rien n'est censé être changé:
ansible-playbook -i accueille playbook.yml --sudo JOUER *********************************** *************************************** TASK [setup] ******** ************************************************* ********* ok: [moe] ok: [frisé] TÂCHE [Installer Nginx] ************************* ********************************* ok: [frisé] ok: [moe] TASK [Installer Python 3] * ************************************************* ***** ok: [frisé] ok: [moe] JOUER RECAP ******************************** ************************************* curly: ok = 3 changé = 0 inaccessible = 0 échec = 0 moe: ok = 3 changé = 0 inaccessible = 0 échec = 0
Avant Ansible 2.0, les jeux étaient exécutés de manière linéaire, tâche par tâche. Tous les hôtes cibles ont exécuté la première tâche. Ce n'est que lorsque tous les hôtes ont terminé avec la première tâche qu'ils peuvent commencer avec la deuxième tâche..
Ansible 2.0 a ajouté le concept de stratégies d'exécution. Il existe actuellement deux stratégies: la stratégie "linéaire" que j'ai décrite ci-dessus, qui est la stratégie par défaut, et la stratégie "libre" dans laquelle les hôtes sont libres d'exécuter les tâches dans le livre de jeu toujours dans l'ordre, mais pas en synergie avec d'autres hôtes..
Cela pourrait être utile si des centaines d’hôtes doivent télécharger plusieurs fichiers à partir de certains serveurs FTP. Le premier hôte peut terminer le téléchargement du premier fichier et passer au suivant, alors que d'autres hôtes sont encore en train de télécharger le premier fichier. Au moment où les autres hôtes téléchargent le fichier suivant, le premier hôte est déjà terminé et les conflits sont moins nombreux..
La stratégie libre semble supérieure dans la plupart des situations. Vous venez d'ajouter un stratégie: gratuit paire clé-valeur au playbook.
- hôtes: tous stratégie: tâches libres:…
Une autre nouvelle fonctionnalité d'Ansible 2.0 est les blocs. Les blocs vous permettent de regrouper des tâches. Ceci est très utile si vous avez des tâches à exécuter uniquement dans certaines conditions. Auparavant, vous deviez le faire pour chaque tâche séparément.
--- - hôtes: toutes les tâches: - debug: msg = "Tâche 1 ici" quand: ansible_distribution == 'Ubuntu' - debug: msg = "Tâche 2 ici" quand: ansible_distribution == 'Ubuntu' - debug: msg = "Tâche 3 ici "when: ansible_distribution == 'Ubuntu'
Avec les blocs, vous pouvez regrouper toutes ces tâches de débogage et placer la condition "quand" au niveau du bloc..
- hôtes: toutes les tâches: - bloc: - debug: msg = "tâche 1 ici" - debug: msg = "tâche 2 ici" - debug: msg = "tâche 3 ici" quand: ansible_distribution == 'Ubuntu'
Ansible communique avec des machines distantes via SSH, mais les playbooks peuvent contenir des secrets tels que le nom d'utilisateur, les mots de passe et les clés d'API. Comme vous stockez généralement des livres de lecture dans des systèmes de contrôle de source tels que git, ces informations seront visibles par toute personne disposant d'un accès en lecture..
Ansible vous aide avec le programme ansible-vault qui vous permet de créer, éditer et ressaisir des fichiers cryptés. Ces fichiers peuvent être déchiffrés à la volée lors de l'exécution du livre de lecture en fournissant un mot de passe. Si vous ajoutez le --vault-ask-pass signaler à ansible-playbook alors il vous demandera le mot de passe du coffre-fort.
Alternativement, vous pouvez ajouter --fichier de mot de passe vault et Ansible lira le mot de passe de votre fichier. Si vous utilisez le fichier de mots de passe, ne le stockez pas dans le contrôle de source!
Désormais, vous pouvez stocker en toute sécurité les fichiers cryptés dans le contrôle de source et ne plus vous inquiéter de ce que quiconque découvre vos secrets. Vous devez gérer votre mot de passe de coffre-fort avec soin. Si vous le perdez, vous ne pourrez pas décrypter les fichiers dans le coffre-fort..
Ansible est un excellent outil. C'est léger. Il peut être utilisé de manière interactive avec des commandes ad-hoc et s'adapte très bien aux systèmes volumineux. Il a également beaucoup d'élan et une grande communauté. Si vous gérez ou même travaillez avec des serveurs distants, vous voulez Ansible.
Restez à l'écoute pour la deuxième partie.
