Ansible - Inventaires

content/blog/cours/ansible/ansible-les-inventaires-statiques.md

@@ -0,0 +1,273 @@
+---
+type:               "post"
+title:              "Ansible - Les inventaires statiques"
+date:               "2023-11-27"
+lastModified:       ~
+tableOfContent:     true
+description:        "Première étape vers l'utilisation d'Ansible, les inventaires. Ils sont le point d'entrée vers vos infras et sont donc central au pilotage de vos instances / serveurs."
+thumbnail:          "content/images/blog/thumbnails/ansible-inventaires.jpg"
+tags:               ["cours", "ansible", "automation"]
+categories:         ["cours"]
+authors:            ["gfaivre"]
+---
+
+## Préambule
+
+Ce cours est utilisé dans le cadre de TP au sein de l'IUT Lyon 1. Il est notamment dispensé à des étudiants peu ou pas familiers avec les stratégies d'automatisation et de déploiement des infrastructures.
+Bien que très axé débutants il peut également représenté une possibilité de monter « rapidement » pour certaines équipes sur les principes fondamentaux d'Ansible afin de disposer du bagage minimal nécessaire à son utilisation.
+
+Il s'agit bien évidemment de supports à vocation pédagogique qui **ne sont pas toujours transposables** à une activité professionnelle.
+
+## Pré-requis
+
+Disposer d'un environnement de travail Ansible fonctionnel, si ça n'est pas encore le cas vous pouvez jeter un oeil [ici](/blog/cours/ansible/ansible-premiers-pas) !
+
+## Introduction
+
+Afin de pouvoir attaquer nos différents machines, Ansible a besoin d'un référentiel de celles-ci avec un minimum d'informations les concernants (histoire de savoir comment s'y connecter par exemple ;)).
+
+C'est là qu'entre en jeux les inventaires. Il existe deux façons de constituer des inventaires, la première est manuelle, et consiste à écrire ni plus ni moins la liste des machines que l'on souhaites manager on parle dans ce cas d'**inventaire statique**.
+La deuxième méthode introduit un principe de « reconnaissance » des machines disponibles, dans ce cas de figure on constituera nos inventaires de manière automatique, on parle dans ce cas d'**inventaire dynamiques** que nous verrons plus tard.
+
+Les inventaires, on le verra permettre également de structurer / hiérarchiser nos machines en utilisant une notion de groupe.
+Ansible propose plusieurs plugins capablent de gérer des inventaires de machines, ils sont consultables à l'aide la commande: 
+
+```
+ansible-doc -t inventory -l
+```
+
+Qui devrait vous renvoyer la liste suivante: 
+
+```
+02:48:02 lazy@ansible_env lazy → ansible-doc -t inventory -l
+ansible.builtin.advanced_host_list Parses a 'host list' with ranges                                                                    
+ansible.builtin.auto               Loads and executes an inventory plugin specified in a YAML config                                   
+ansible.builtin.constructed        Uses Jinja2 to construct vars and groups based on existing inventory                                
+ansible.builtin.generator          Uses Jinja2 to construct hosts and groups from patterns                                             
+ansible.builtin.host_list          Parses a 'host list' string                                                                         
+ansible.builtin.ini                Uses an Ansible INI file as inventory source                                                        
+ansible.builtin.script             Executes an inventory script that returns JSON                                                      
+ansible.builtin.toml               Uses a specific TOML file as an inventory source                                                    
+ansible.builtin.yaml               Uses a specific YAML file as an inventory source  
+```
+
+Dans notre cas nous nous appuyerons essentiellemen sur le plugin `yaml`.
+
+## Structurer ses inventaires
+
+Un inventaire n'est en fait ni plus ni moins d'un ou plusieurs fichiers spécifiant des informations concernant le parc de machines que l'on souhaite piloter.
+En terme de structure vous rencontrerez énormément de façons de faire, celles-ci étant guider par le besoin métier bien éviemment on pourra citer comme contraintes par exemple:
+
+- La taille des infrastructures (le nombre de machines)
+- Leur localisation géographique (Pays, ville...)
+- Le besoin d'adresser finement un groupe de machines et pas un autre...
+
+Bref tout est imaginable à ce niveau.
+En ce qui nous concerne nous interviendrons sur un parc plutôt modeste puisque pour nos travaux nous utiliserons au maximum 4 machines.
+
+Nous allons donc commencer par créer un répertoire qui leur sera dédié appelé `inventories` nous déplacerons ensuite le fichier `hosts.yml` que nous avions créé [précédemment](http://localhost:8000/blog/cours/ansible/ansible-premiers-pas#communication-ansible-serveurs-distants).
+
+**Vous devriez donc disposer d'une arborence similaire à la suivante:** 
+
+```
+ansible/
+├── inventories
+│   └── hosts.yml
+└── Makefile
+```
+
+## La configuration d'un inventaire
+
+Pour rappel le contenu de votre fichier `hosts.yml` doit pour l'heure être le suivant:
+
+```yaml
+all:
+  hosts:
+    vm-web-prod-01:
+      ansible_host: XXX.XXX.XXX.XXX
+      ansible_user: debian
+```
+
+### Clés génériques
+
+La structure du fichier nous permet de mettre en évidence deux clés essentielles:
+
+- `ansible_host`: Le nom résolvable ou l'adresse IP de la machine distante;
+- `ansible_user`: L'utilisateur à utilisé pour ouvrire une session sur cette même machine.
+
+Il est toutefois possible d'utiliser d'autre clé de configuration pour enrichir la définition de notre machine, parmi les plus utiles:
+
+- `ansible_port`: Permet de spécifier le port de connexion SSH (si différent du port standard, pour rappel le port par défaut est 22)
+
+### Clés spécifiques à SSH
+
+- `ansible_ssh_pass`: 
+- `ansible_ssh_private_key_file`:
+- `ansible_ssh_extra_args`
+
+### Clés spécifiques à l'escalade de privilèges
+
+- `ansible_become`:
+- `ansible_become_method`:
+- `ansible_become_user`:
+- `ansible_become_pass`:
+
+## Enrichir son inventaire
+
+À présent que nous avons effectuer un petit tour rapide du propriétaire, nous allons « étoffer » notre inventaire initial en ajoutant une deuxième machine comme ci-dessous:
+
+```yaml
+# Fichier hosts.yml
+all:
+  hosts:
+    vm-web-prod-01:
+      ansible_host: XXX.XXX.XXX.XXX
+      ansible_user: debian
+    vm-web-staging-01:
+      ansible_host: XXX.XXX.XXX.XXX
+      ansible_user: debian
+```
+
+En ajoutant une machine et en jouant la commande `ansible -i inventories/hosts.yml all -m ping` nous devrions bien voir qu'ansible considère bien nos deux machines: 
+
+<figure>
+    <img src="content/images/blog/2023/ansible/ansible-inventaires/ping.gif">
+    <figcaption>
+      <span class="figure__legend">Utilisation du module ping sur deux machines.</span>
+    </figcaption>
+</figure>
+
+!!! info "Hôte local"
+    Il est bien évidemment possible d'interroger notre propre machine à l'aide d'Ansible, en modifiant relativement simplement notre fichier d'inventaire. Attention toutefois à ce que vous faites puisque vous pouvez du coup directement impacter la configuration et donc le fonctionnement de votre machine.
+
+**Exemple de fichier d'inventaire pour piloter une machine locale:**
+
+```yaml
+all:
+  hosts:
+    localhost:
+      ansible_host: 127.0.0.1
+      ansible_connection: local
+```
+
+### Définir des groupes de machines
+
+Pour l'exemple nous allons créer un fichier `groups.yml` (toujours dans `inventories`) contenant: 
+
+```yaml
+all:
+  children:
+    webservers:
+      hosts:
+        vm-web-prod-01: ~
+        vm-web-staging-01: ~
+```
+
+**ATTENTION**: `children` est une sous clé de `all` ;)
+
+### La commande « ansible-inventory »
+
+Ansible propose différentes commande parfois très spécifique, l'occasion de tester notre configuration d'inventaire !
+
+Testons: `ansible-inventory --list -i inventories`
+On notera que cette fois-ci nous donnons le répertoire `inventories` en paramètre.
+
+**Cette commande devrait vous afficher la sortie suivante (format json):**
+
+```json
+{
+    "_meta": {
+        "hostvars": {
+            "vm-web-prod-01": {
+                "ansible_host": "192.168.140.XXX",
+                "ansible_user": "debian"
+            },
+            "vm-web-staging-01": {
+                "ansible_host": "192.168.140.XXX",
+                "ansible_user": "debian"
+            }
+        }
+    },
+    "all": {
+        "children": [
+            "ungrouped",
+            "webservers"
+        ]
+    },
+    "webservers": {
+        "hosts": [
+            "vm-web-prod-01",
+            "vm-web-staging-01"
+        ]
+    }
+}
+```
+
+ou encore avec l'option `--graph` en lieu et place de `--list` qui est plus parlante visuellement `ansible-inventory --graph -i inventories`:
+
+```
+@all:
+  |--@ungrouped:
+  |--@webservers:
+  |  |--vm-web-prod-01
+  |  |--vm-web-staging-01
+```
+
+**À retenir:**
+Ansible utilise une arborescence ou figurera **toujours**:
+
+- Un groupe `all`: C'est le groupe racine auquel appartiendra toutes vos machines sans exception (On remarquera avec cette information que lorsque nous avons utilisé la commande `ansible -i inventories/hosts.yml all -m ping`, **all** indiquait donc le groupe cible).
+- Un groupe `ungrouped`: Groupe auquel sera affecté toute machine **n'appartenant à aucun groupe** (exception faites de **all** bien évidemment);
+
+Dans notre exemple ci-dessus on voit donc bien que nos deux machines font bien partie du groupe `webservers`.
+
+!!! info "Fichiers d'inventaire multiples"
+    Si l'option `-i` d'Ansible prend un fichier d'inventaire en paramètre elle peut également prendre un répertoire et dans ce cas Ansible considérera l'ensemble des fichiers présents dans le répertoire.
+    Ce fonctionnement offre la possibilité avec des infrastructures composées de nombreuses machines de pouvoir les séparer dans plusieurs fichiers en fonction de différents critères.
+
+### Ordre de chargement des inventaires
+
+Vous aurez compris que si l'on aborde le sujet c'est qu'il est d'importance... pour l'illustrer créons un nouveau fichier d'inventaire que l'on nommera `misc.yml` contenant:
+
+```yaml
+all:
+  hosts:
+    vm-web-prod-01:
+      ansible_host: XXX.XXX.XXX.XXX
+      ansible_user: debian
+      ansible_port: 22
+    vm-web-staging-01:
+      ansible_host: XXX.XXX.XXX.YYY
+```
+
+Complétons pour finir notre inventaire `groups.yml` afin d'obtenir le contenu suivant:
+
+```yaml
+all:
+  children:
+    webservers:
+      hosts:
+        vm-web-prod-01: ~
+        vm-web-staging-01: ~
+    staging:
+      hosts:
+        vm-web-staging-01: ~
+    production:
+      hosts:
+        vm-web-prod-01: ~
+```
+
+## Exercices
+
+Rapide mise en pratique des inventaires.
+
+### Exercice 1
+
+Reprendre les différents fichiers contenu dans notre répertoire `inventories` et les compiler en un seul et même fichier `hosts.yml`.
+
+Souvenez-vous vous pouvez tester un fichier d'inventaire en particulier en le passant en paramètre de la commande `ansible-inventory`: `ansible-inventory --list -i inventories/hosts.yml`.
+
+## Aller plus loins avec les sources
+
+- https://docs.ansible.com/ansible/latest/inventory_guide/intro_inventory.html#connecting-to-hosts-behavioral-inventory-parameters
+

content/blog/cours/ansible/ansible-premiers-pas.md

@@ -6,7 +6,7 @@ lastModified:       ~
 tableOfContent:     true
 description:        "Dans ce premier cours à destination des étudiants et/ou néophytes, nous verrons ce qu'est Ansible ainsi qu'un exemple très simple de son utilisation."
 
-thumbnail:          "content/images/blog/thumbnails/Get-started-with-Ansible.jpg"
+thumbnail:          "content/images/blog/thumbnails/ansible-intro.jpg"
 tags:               ["cours", "ansible", "automation"]
 categories:         ["cours"]
 authors:            ["gfaivre"]