├── images
├── adhoc.JPG
├── ans.png
├── image.png
├── navig.png
├── roles.png
├── Capture.JPG
├── ansible.png
├── ansible1.png
└── playbook.png
├── 12-cronjob.md
├── 13-Yum-repos&ansible-navigator.md
├── 07-jinja2-et-template.md
├── README.md
├── 05-ansible-vault.md
├── 09-ansible-galaxy.md
├── 04-variables-et-facts.md
├── 01-introduction-ansible-et-setup-environnement.md
├── 08-task-handlers-et-error-handlers.md
├── 10-roles-et-rhel-system-roles.md
├── 03-les-playbooks.md
├── 02-les-commandes-adhocs.md
├── 11-gestion-de-stockage-avec-ansible.md
└── 06-conditions-et-loops.md
/images/adhoc.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halekammoun/RHCE-Training/HEAD/images/adhoc.JPG
--------------------------------------------------------------------------------
/images/ans.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halekammoun/RHCE-Training/HEAD/images/ans.png
--------------------------------------------------------------------------------
/images/image.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halekammoun/RHCE-Training/HEAD/images/image.png
--------------------------------------------------------------------------------
/images/navig.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halekammoun/RHCE-Training/HEAD/images/navig.png
--------------------------------------------------------------------------------
/images/roles.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halekammoun/RHCE-Training/HEAD/images/roles.png
--------------------------------------------------------------------------------
/images/Capture.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halekammoun/RHCE-Training/HEAD/images/Capture.JPG
--------------------------------------------------------------------------------
/images/ansible.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halekammoun/RHCE-Training/HEAD/images/ansible.png
--------------------------------------------------------------------------------
/images/ansible1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halekammoun/RHCE-Training/HEAD/images/ansible1.png
--------------------------------------------------------------------------------
/images/playbook.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/halekammoun/RHCE-Training/HEAD/images/playbook.png
--------------------------------------------------------------------------------
/12-cronjob.md:
--------------------------------------------------------------------------------
1 | Gestion des Cron Jobs avec Ansible
2 |
3 | ### Introduction
4 | 👋 Dans cette section, nous allons explorer comment gérer des tâches planifiées (cron jobs) en utilisant Ansible.
5 | ### Utilisation du module cron
6 | Ansible fournit le module cron qui permet d'ajouter, de modifier ou de supprimer des tâches planifiées dans le fichier crontab d'un utilisateur.
7 | #### Exemple de création d'un cron job
8 |
9 | Le playbook suivant crée un cron job qui exécute la commande logger "EX294 in progress" toutes les 2 minutes sous l'utilisateur student.
10 | Utilisez le module `ansible.builtin.cron` pour créer le cronjob.
11 | Écrire une tâche Ansible qui crée un cronjob pour un utilisateur nommé student. Ce cronjob doit s'exécuter toutes les 2 minutes et exécuter la commande logger "EX294 in progress" pour ajouter le message "EX294 in progress" dans les logs du système.
12 | ``` bash
13 | vim crontab.yml
14 | ```
15 | ``` bash
16 | - name: Create a cronjob
17 | hosts: all
18 | tasks:
19 | - name: Cronjob for logger
20 | ansible.builtin.cron:
21 | name: Create logger
22 | user: student
23 | minute: "*/2"
24 | job: logger "EX294 in progress"
25 | state: present
26 | ```
27 |
--------------------------------------------------------------------------------
/13-Yum-repos&ansible-navigator.md:
--------------------------------------------------------------------------------
1 | Configuration de Yum Repositories et Utilisation d'Ansible Navigator
2 |
3 | ## Introduction
4 |
5 | 👋 Dans cette section, l'objectif est de configurer des Yum Repositories sur plusieurs nœuds en utilisant Ansible, et d'expliquer comment utiliser Ansible Navigator pour gérer et exécuter les playbooks. Nous allons créer deux dépôts Yum : `baseos` et `appstream`, et démontrer comment exécuter des playbooks avec Ansible Navigator.
6 |
7 |
8 | ## Utilisation d'Ansible Navigator
9 | 0. **installer ansible navigator pou tester**:
10 |
11 | 
12 |
13 | 2. **Installer Ansible Navigator dans l'exam** :
14 | Pour installer Ansible Navigator, utilisez la commande suivante :
15 | ```bash
16 | sudo yum install ansible-navigator
17 | ```
18 |
19 | 3. **Connecter Podman (si nécessaire)** :
20 | Connectez-vous à votre registre Docker ou Podman si cela est requis pour la configuration:
21 | ```bash
22 | podman login registry.redhat.io
23 | username: ...
24 | password: ...
25 | ```
26 | 4. **tapez cette commande pour la configuartion auto de navigator** :
27 | ``` bash
28 | ansible-navigator
29 | ```
30 | 4. **utilisez ansible-navigator pour l'éxecution de playbook** :
31 | ``` bash
32 | ansible-navigator run NomPlaybook.yml -m stdout
33 | ```
34 |
35 |
36 | ## Configuration des Repositories Yum
37 |
38 | Nous allons créer un playbook Ansible pour configurer deux dépôts Yum : **BaseOS** et **AppStream**.
39 |
40 | ### Création du playbook
41 |
42 | faire un playbook qui crée et configure les deux dépôts Yum sur tous les nœuds définis dans l'inventaire d'Ansible.
43 | Le playbook se compose de deux tâches principales :
44 |
45 | 1. **Créer le dépôt BaseOS** :
46 | - Nom : `baseos`
47 | - Description : `Baseos Description`
48 | - URL : `http://content/rhel9.0/x86_64/dvd/BaseOS`
49 | - GPG : Activé
50 | - Clé GPG : `http://content.example.com/rhel9.0/x86_64/dvd/RPM-GPG-KEY-redhatrelease`
51 | - Le dépôt est activé.
52 |
53 | 2. **Créer le dépôt AppStream** :
54 | - Nom : `appstream`
55 | - Description : `App Description`
56 | - URL : `http://content/rhel9.0/x86_64/dvd/AppStream`
57 | - GPG : Activé
58 | - Clé GPG : `http://content.example.com/rhel9.0/x86_64/dvd/RPM-GPG-KEY-redhatrelease`
59 | - Le dépôt est activé.
60 |
61 | ```yaml
62 | vim yumrepo.yml
63 |
64 | - name: Creating yum repository
65 | hosts: all
66 | tasks:
67 | - name: Create BaseOS Repository
68 | ansible.builtin.yum_repository:
69 | name: "baseos"
70 | description: "Baseos Description"
71 | baseurl: http://content/rhel9.0/x86_64/dvd/BaseOS
72 | gpgcheck: yes
73 | gpgkey: http://content.example.com/rhel9.0/x86_64/dvd/RPM-GPG-KEY-redhatrelease
74 | enabled: yes
75 |
76 | - name: Create Appstream Repository
77 | ansible.builtin.yum_repository:
78 | name: "appstream"
79 | description: "App Description"
80 | baseurl: http://content/rhel9.0/x86_64/dvd/AppStream
81 | gpgcheck: yes
82 | gpgkey: http://content.example.com/rhel9.0/x86_64/dvd/RPM-GPG-KEY-redhatrelease
83 | enabled: yes
84 | ```
85 |
--------------------------------------------------------------------------------
/07-jinja2-et-template.md:
--------------------------------------------------------------------------------
1 | Jinja2 et Template
2 |
3 | ### Introduction
4 | 👋 Dans cette section, nous allons explorer comment utiliser la syntaxe `jinja2` et le module `template`.
5 |
6 | ### Syntaxe Jinja2 et Module template
7 | Jinja2 est un moteur de template utilisé dans Ansible pour générer des fichiers de manière dynamique. Il permet d'incorporer des variables, des boucles et des conditions dans des fichiers de configuration en utilisant des fichiers ayant l'extension `.j2`.
8 |
9 | #### Syntaxe Jinja2 de base :
10 | - `Variables` : Utilisées pour insérer des valeurs dynamiques.
11 | ```bash
12 | {{ variable_name }}
13 |
14 | ```
15 | - `Boucles` : Utilisées pour répéter une section de code.
16 |
17 | ```bash
18 | {% for item in list %}
19 | {{ item }}
20 | {% endfor %}
21 |
22 | ```
23 | - `Conditions` : Utilisées pour insérer des sections de code conditionnelles.
24 |
25 | ```bash
26 | {% if condition %}
27 | Some content
28 | {% endif %}
29 |
30 | ```
31 | #### Module template :
32 | Le module `template` d'Ansible utilise Jinja2 pour créer des fichiers basés sur des templates. Il permet de copier un fichier template vers un emplacement sur l'hôte distant, en remplaçant les variables par leurs valeurs actuelles.
33 | Exemple de module template :
34 |
35 |
36 | ```bash
37 | - name: Render a configuration file from template
38 | template:
39 | src: /path/to/template.j2
40 | dest: /path/to/destination/file
41 |
42 | ```
43 | ## QUESTION:
44 | 0. create this file called /root/myhosts.j2 in the control node
45 | ```bash
46 | 127.0.0.1 localhost localhost.localdomain localhost4 localhost4.localdomain4
47 | ::1 localhost localhost.localdomain localhost6 localhost6.localdomain6
48 | ```
49 | 1. you should create the jinja template in this file, Then you should create a playbook in /home/ansible called hosts.yml on dev node so that /root/myhosts content will be like below.
50 | The order of the nodes doesn’t matter.
51 | ```bash
52 | 127.0.0.1 localhost localhost.localdomain localhost4 localhost4.localdomain4
53 | ::1 localhost localhost.localdomain localhost6 localhost6.localdomain6
54 | 10.0.2.1 node1.example.com node1
55 | 10.0.2.2 node2.example.com node2
56 | 10.0.2.3 node3.example.com node3
57 | 10.0.2.4 node4.example.com node4
58 | 10.0.2.5 node5.example.com node5
59 | ```
60 | NB: `hostvars` est une variable spéciale dans Ansible qui contient des informations sur tous les hôtes de l'inventaire. C'est un dictionnaire qui vous permet d'accéder aux variables d'un hôte spécifique en utilisant son nom (ou son alias) comme clé.
61 | ## ANSWER:
62 |
63 |
64 | ```bash
65 | vim /home/ansible/myhosts.j2
66 | ```
67 |
68 | ```bash
69 | 127.0.0.1 localhost localhost.localdomain localhost4 localhost4.localdomain4
70 | ::1 localhost localhost.localdomain localhost6 localhost6.localdomain6
71 | {% for host in groups.all %}
72 | {{ hostvars[host].ansible_default_ipv4.address }} {{ hostvars[host].ansible_fqdn }} {{ hostvars[host].ansible_hostname }}
73 | {% endfor %}
74 |
75 | ```
76 |
77 | ```bash
78 | vim hosts.yml
79 | ```
80 |
81 | ```bash
82 | ---
83 | - name: Use hosts.j2 template
84 | hosts: all
85 | tasks:
86 | - name: Template a file to dev hosts
87 | template:
88 | src: /home/ansible/hosts.j2
89 | dest: /root/myhosts
90 | when: "'dev' in group_names"
91 |
92 | ```
93 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | Formation RHCE
2 |
3 | 
4 |
5 | Automatisation Système avec Ansible sous Red Hat Enterprise Linux
6 |
7 | ## Introduction
8 | 👋 Bienvenue dans ce cours sur l'automatisation système avec Ansible sous Red Hat Enterprise Linux.
9 | Ce cours est conçu pour vous préparer à l'examen RHCE (Red Hat Certified Engineer)!
10 |
11 | 🔧 **Pourquoi ce cours ?**
12 | - **Compétences Pratiques** : Apprenez à utiliser Ansible pour automatiser la gestion de systèmes Red Hat Enterprise Linux.
13 | - **Certification Reconnue** : Obtenez la certification RHCE, reconnue mondialement et très recherchée par les employeurs.
14 | - **Opportunités de Carrière** : Augmentez vos chances de décrocher des postes d'ingénieur DevOps, administrateur système, et bien d'autres.
15 |
16 | 📚 **Ce que vous allez apprendre :**
17 | - **Installation et Configuration d'Ansible** : Déployez et configurez Ansible pour divers environnements.
18 | - **Commandes Ad-Hoc et Playbooks** : Apprenez à utiliser les commandes ad-hoc et à créer des playbooks pour automatiser les tâches.
19 | - **Gestion des Variables et des Facts** : Utilisez les variables, les facts et les variables magiques pour rendre vos playbooks plus dynamiques.
20 | - **Gestion Avancée des Tâches** : Implémentez des conditions, des boucles, des handlers de tâches et des handlers d'erreurs.
21 | - **Utilisation d'Ansible Galaxy et des Rôles** : Téléchargez des rôles à partir d'Ansible Galaxy et créez vos propres rôles pour organiser vos playbooks.
22 | - **Gestion du Stockage avec Ansible** : Configurez et gérez le stockage avec Ansible.
23 |
24 | 🎯 **Objectifs du cours :**
25 | 1. Vous fournir les connaissances et les compétences nécessaires pour réussir l'examen RHCE.
26 | 2. Vous préparer à automatiser efficacement la gestion des systèmes Red Hat Enterprise Linux dans un environnement professionnel.
27 | 3. Développer votre expertise en automatisation système à travers des exercices pratiques et des labs interactifs.
28 |
29 | 🎓 **À qui s'adresse ce cours ?**
30 | - **Administrateurs Système** : Ceux qui souhaitent automatiser leurs tâches et augmenter leur efficacité.
31 | - **Professionnels IT** : Ceux qui cherchent à certifier leurs compétences et à progresser dans leur carrière.
32 | - **Étudiants** : Ceux qui poursuivent des études en informatique et souhaitent acquérir des compétences pratiques en automatisation.
33 |
34 | Rejoignez-nous dans cette aventure et devenez un ingénieur certifié Red Hat ! 🚀
35 |
36 | ## Table des Matières
37 |
38 | - Introduction à Ansible et Setup de l'Environnement
39 | - Les Commandes Ad-Hoc
40 | - Les Playbooks et les Modules
41 | - Variables, Facts et Variables Magiques
42 | - Ansible Vault
43 | - Conditions et Boucles
44 | - Task Handlers et Error Handlers
45 | - Ansible Galaxy
46 | - Rôles et RHEL System Roles
47 | - Gestion du Stockage avec Ansible
48 |
49 |
--------------------------------------------------------------------------------
/05-ansible-vault.md:
--------------------------------------------------------------------------------
1 | Ansible-Vault
2 |
3 | ### Introduction
4 | 👋 Dans cette section, nous allons explorer comment utiliser l'outil Ansible-vault.
5 | ### Ansible-vault
6 | `Ansible Vault` est un outil utilisé pour chiffrer des fichiers sensibles, comme des fichiers contenant des mots de passe ou des clés API. Cela permet de sécuriser les informations sensibles dans les playbooks et autres fichiers de configuration. Voici une explication détaillée de l'utilisation d'Ansible Vault et des commandes associées.
7 | ### Commandes Ansible Vault
8 | ```bash
9 | ansible-vault --help
10 | ```
11 | `ansible-vault create`
12 | créer un nouveau fichier chiffré avec Ansible Vault:
13 | ```bash
14 | ansible-vault create protected_file.yml
15 | ```
16 | Après avoir exécuté cette commande, vous serez invité à entrer un mot de passe. Ce mot de passe sera utilisé pour chiffrer le fichier. Une fois le fichier créé, vous pouvez le consulter pour vérifier qu'il est bien chiffré.
17 | ```bash
18 | cat protected_file.yml
19 | ```
20 | `ansible-vault view`
21 | Cette commande permet de visualiser le contenu d'un fichier chiffré sans le modifier.
22 | ```bash
23 | ansible-vault view protected_file.yml
24 | ```
25 | Vous serez invité à entrer le mot de passe pour déchiffrer et afficher le contenu du fichier.
26 | `ansible-vault edit`
27 | Cette commande permet d'éditer un fichier chiffré.
28 | ```bash
29 | ansible-vault edit protected_file.yml
30 | ```
31 | Vous serez invité à entrer le mot de passe, puis le fichier s'ouvrira dans votre éditeur de texte par défaut.
32 | `ansible-vault rekey`
33 | Cette commande change le mot de passe d'un fichier chiffré.
34 | ```bash
35 | ansible-vault rekey protected_file.yml
36 | ```
37 | Vous serez invité à entrer l'ancien mot de passe, puis un nouveau mot de passe.
38 | ### Exécution d'un playbook avec des fichiers chiffrés
39 | Pour exécuter un playbook contenant des fichiers chiffrés, vous pouvez utiliser les options `--ask-vault-password` ou `--vault-password-file`.
40 | #### Option `--ask-vault-password`
41 | Cette option vous invite à entrer le mot de passe pour déchiffrer le fichier.
42 | ```bash
43 | ansible-playbook playbook.yml --ask-vault-password
44 | ```
45 | #### Option `--vault-password-file`
46 | Cette option utilise un fichier contenant le mot de passe pour déchiffrer le fichier.
47 | ```bash
48 | ansible-playbook playbook.yml --vault-password-file vault_password
49 | ```
50 | Exemple:
51 | 1. Utilisez Ansible Vault pour créer un fichier de mots de passe chiffré contenant la variable `password` et sa valeur.
52 | 2. Créez un fichier non chiffré contenant la variable `username` et sa valeur.
53 | 3. Écrivez un playbook Ansible qui utilise ces deux fichiers pour créer un utilisateur avec le nom d'utilisateur et le mot de passe spécifiés.
54 |
55 | ```bash
56 | ansible-vault create password.yml
57 |
58 | ```
59 |
60 | ```bash
61 | password: "Password"
62 |
63 | ```
64 | ```bash
65 | vim user.yml
66 | ```
67 | ```bash
68 | username: "alice"
69 |
70 | ```
71 | ```bash
72 | vim playbook.yml
73 | ```
74 |
75 | ```bash
76 | - name: Créer un utilisateur avec un mot de passe chiffré
77 | hosts: all
78 | become: true
79 | vars_files:
80 | - user.yml
81 | - password.yml
82 | tasks:
83 | - name: Créer l'utilisateur
84 | user:
85 | name: "{{ username }}"
86 | password: "{{ password | password_hash('sha512') }}"
87 | state: present
88 |
89 | ```
90 | ```bash
91 | ansible-playbook create_user.yml --ask-vault-password
92 |
93 | ```
94 | RQ: `{{ password | password_hash('sha512') }}` permet de s'assurer que le mot de passe stocké et utilisé dans le système est sécurisé et haché, plutôt que de stocker et utiliser le mot de passe en clair.
95 | Vérifier avec `/etc/shadow`
96 |
--------------------------------------------------------------------------------
/09-ansible-galaxy.md:
--------------------------------------------------------------------------------
1 | Ansible Galaxy
2 |
3 | ### Introduction
4 | 👋 Dans cette section, nous allons explorer comment utiliser ansible-galaxy et utiliser les rôles préconfigurés.
5 |
6 |
7 | `ansible-galaxy` est un outil en ligne de commande pour gérer les rôles et les collections Ansible. Il permet de télécharger, installer et gérer des rôles depuis des dépôts publics ou privés.
8 |
9 | #### installation de Rôle
10 | ``` bash
11 | ansible-config dump | grep -i galaxy_server
12 | ```
13 |
14 | Pour installer un rôle depuis Ansible Galaxy, utilisez la commande ansible-galaxy install.
15 | Par exemple, pour installer le rôle geerlingguy.apache, vous pouvez exécuter :
16 | ``` bash
17 | ansible-galaxy install geerlingguy.apache
18 | ```
19 | NB:
20 | Par défaut, les rôles installés avec ansible-galaxy sont stockés dans le répertoire .ansible/roles. (ansible --version)
21 | #### Changer l'Emplacement par Défaut des Rôles
22 | ``` bash
23 | ansible-config dump | grep -i roles
24 | ```
25 |
26 | Vous pouvez changer l'emplacement par défaut où ansible-galaxy installe les rôles en utilisant le fichier de configuration `ansible.cfg`.
27 | Ajoutez cette ligne dans le fichier ansible.cfg :
28 | ``` bash
29 | roles_path = /path/to/your/custom/roles
30 | ```
31 | Dans cet exemple, les rôles seront installés dans /path/to/your/custom/roles au lieu du répertoire roles par défaut.
32 | ``` bash
33 | ansible-config dump | grep -i roles
34 | ```
35 | #### Appeler un Rôle dans un Playbook
36 | ``` bash
37 | - name: Configure web server
38 | hosts: all
39 | roles:
40 | - geerlingguy.apache
41 | ```
42 | Dans ce cas, le rôle geerlingguy.apache est utilisé pour configurer un serveur web Apache.
43 | #### Utilisation de requirements.yml pour Installer Plusieurs Rôles
44 | `requirements.yml` est un fichier utilisé pour définir une liste de rôles et de collections à installer via ansible-galaxy. Ce fichier permet de gérer plusieurs rôles de manière centralisée et cohérente.
45 | Exemple de requirements.yml :
46 |
47 |
48 | ``` bash
49 | ---
50 | - name: geerlingguy.apache
51 | src: geerlingguy.apache
52 |
53 | - name: geerlingguy.mysql
54 | src: geerlingguy.mysql
55 |
56 | ```
57 | #### Installer les Rôles à partir de requirements.yml
58 |
59 | ``` bash
60 | ansible-galaxy install -r requirements.yml
61 | ```
62 | Cette commande télécharge et installe tous les rôles listés dans le fichier requirements.yml et les place dans le répertoire roles par défaut ou dans le répertoire spécifié dans ansible.cfg.
63 | #### Exemple de Playbook Utilisant Plusieurs Rôles
64 | ``` bash
65 | ---
66 | - name: Configure web and database servers
67 | hosts: all
68 | become: true
69 | roles:
70 | - geerlingguy.apache
71 | - geerlingguy.mysql
72 | ```
73 | ## QUESTION
74 | 1. Create a file called requirements.yml in /home/ansible/roles to install two roles. The source for the first role is geerlingguy.haproxy and geerlingguy.php. Name the first haproxy-role and the second php-role. The roles should be installed in /home/ansible/roles1.
75 |
76 | ``` bash
77 | echo "roles_path= /home/ansible/roles1" >> ansible.cfg
78 | ```
79 | ``` bash
80 | vim requirements.yml
81 | ```
82 | ``` bash
83 | - name: haproxy-role
84 | src: geerlingguy.haproxy
85 | - name: php-role
86 | src: geerlingguy.php
87 | ```
88 | ``` bash
89 | ansible-galaxy install -r requirements.yml
90 | ```
91 | 2. Use the roles in a file called role.yml in /home/ansible/.
92 | The haproxy-role should be used on the proxy host and The php-role should be used on the prod host.
93 | ``` bash
94 |
95 | - hosts: proxy
96 | become: true
97 | roles:
98 | - haproxy-role
99 | - hosts: prod
100 | become: true
101 | roles:
102 | - php-role
103 | ```
104 |
--------------------------------------------------------------------------------
/04-variables-et-facts.md:
--------------------------------------------------------------------------------
1 | Les variables et ansible Facts
2 |
3 | ### Introduction
4 | 👋 Dans cette section, nous allons explorer comment utiliser les variables suivant deux méthodes et comment utiliser les 'Facts'.
5 |
6 |
7 | ### Les variables
8 | #### Utilisation de `vars`
9 | Dans cette méthode, nous définissons les variables directement dans le playbook sous la section `vars`
10 | Exemple 1 :
11 | ```bash
12 | - name: Ajouter utilisateur avec des variables définies
13 | hosts: all
14 | become: true
15 | vars:
16 | username: "alice"
17 | home_directory: "/home/alice"
18 | user_shell: "/bin/bash"
19 | tasks:
20 | - name: Ajouter utilisateur
21 | user:
22 | name: "{{ username }}"
23 | home: "{{ home_directory }}"
24 | shell: "{{ user_shell }}"
25 | state: present
26 |
27 | ```
28 | #### Utilisation de `vars_files`
29 | Dans cette méthode, nous stockons les variables dans un fichier séparé puis on fait l'appel de fichier dans la section `vars_files`
30 | ```bash
31 | vim variables.yml
32 | ```
33 | ```bash
34 | username: "alice"
35 | home_directory: "/home/alice"
36 | user_shell: "/bin/bash"
37 |
38 | ```
39 |
40 | ```bash
41 | vim playbook.yml
42 | ```
43 | ```bash
44 | - name: Ajouter utilisateur avec un fichier de variables
45 | hosts: all
46 | become: true
47 | vars_files:
48 | - variables.yml
49 | tasks:
50 | - name: Ajouter utilisateur
51 | user:
52 | name: "{{ username }}"
53 | home: "{{ home_directory }}"
54 | shell: "{{ user_shell }}"
55 | state: present
56 | ```
57 | ### Facts
58 | pour afficher les facts
59 | ```bash
60 |
61 | ansible node1 -m setup | less
62 | ```
63 | pour filtrer les facts en utilisant les variables
64 | ```bash
65 |
66 | ansible node1 -m setup -a "filter=ansible_default_ipv4"
67 | ```
68 | Exemple1: de playbook pour affichage de facts.
69 | ```bash
70 | - name: Ansible Facts Playbook
71 | hosts: all
72 | tasks:
73 | - name: Display ansible fact
74 | debug:
75 | var: ansible_hostname
76 | ```
77 | Exemple2: de playbook pour affichage de facts.
78 |
79 | ```bash
80 | - name: Ansible Facts Playbook
81 | hosts: all
82 | tasks:
83 | - name: Display Facts method1
84 | debug:
85 | var: ansible_default_ipv4.address
86 | - name: Display Facts method2
87 | debug:
88 | var: ansible_facts['default_ipv4']['address']
89 | ```
90 | ### QUESTION:
91 | Create a file in /home/ansible called report.yml. Using this playbook, touch a file called report.txt in node1 and node 2 .
92 | The file content of report.txt is
93 |
94 | HOST= inventory hostname
95 | MEMORY=total memory in mb
96 | BIOS=bios version
97 | SDA_DISK_SIZE=disk size
98 | SDB_DISK_SIZE=disk size
99 | Then edit the lines in the file to provide the real information of the hosts.
100 |
101 | ``` bash
102 | - name: QUESTION CORRECTION
103 | hosts: all
104 | become: true
105 | tasks:
106 | - name: get file to nodes
107 | get_url:
108 | url: lien
109 | dest: /home/ansible/report.txt
110 | - name: change hostname
111 | lineinfile:
112 | path: /root/report.txt
113 | line: HOST={{ ansible_hostname }}
114 | regexp: ^HOST
115 | state: present
116 | - name: chahge memory
117 | lineinfile:
118 | path: /root/report.txt
119 | line: MEMORY={{ ansible_memtotal_mb }}
120 | regexp: ^MEMORY
121 | state: present
122 | - name: change bios version
123 | lineinfile:
124 | path: /root/report.txt
125 | line: BIOS={{ ansible_bios_version }}
126 | regexp: ^BIOS
127 | state: present
128 | - name: change sda
129 | lineinfile:
130 | path: /root/report.txt
131 | line: SDA_DISK_SIZE={{ ansible_devices.sda.size }}
132 | regexp: ^SDA_DISK_SIZE
133 | state: present
134 | - name: change sdb
135 | lineinfile:
136 | path: /root/report.txt
137 | line: SDA_DISK_SIZE={{ ansible_devices.sdb.size }}
138 | regexp: ^SDB_DISK_SIZE
139 | state: present
140 | ```
141 |
142 |
--------------------------------------------------------------------------------
/01-introduction-ansible-et-setup-environnement.md:
--------------------------------------------------------------------------------
1 | Introduction à Ansible et Setup de l'Environnement
2 |
3 | ## Introduction
4 | 👋 Dans cette section, nous allons vous guider à travers les étapes nécessaires pour installer Ansible et configurer votre environnement.
5 |
6 | ## Qu'est-ce qu'Ansible ?
7 | Ansible est un outil d'automatisation qui facilite la gestion des serveurs et des applications. Il est "sans agent", ce qui signifie qu'il n'a pas besoin d'un logiciel spécial installé sur les machines que vous gérez. Il est populaire parce qu'il est simple à utiliser, efficace, et utilise des fichiers YAML faciles à comprendre.
8 |
9 | 
10 |
11 |
12 | ## Architecture d'Ansible
13 | - `Serveur Ansible` :
14 | C'est l'ordinateur (un laptop, un PC ou un serveur) où Ansible est installé. Il contient :
15 | - `Playbooks` :
16 | Ce sont des fichiers qui définissent ce que vous voulez faire (comme installer des logiciels ou configurer des paramètres).
17 | - `Inventaire` :
18 | Une liste des serveurs que vous gérez, appelée "hôtes",Il sert aussi à organiser ces serveurs en groupes afin de faciliter la gestion et l'exécution des tâches.
19 | - `ansible.cfg` : Contient la configuration par défaut pour Ansible,
20 |
21 | ## Playbooks :
22 |
23 | - `Rôles` :
24 | Groupes de tâches organisées pour une fonction spécifique (par exemple, installer un serveur web).
25 | - `Tâches` :
26 | Ce sont les commandes individuelles que vous voulez exécuter (comme "installer nginx").
27 |
28 | ## SSH sans mot de passe :
29 | Ansible communique avec les serveurs cibles en utilisant SSH, sans nécessiter de mot de passe à chaque fois.
30 |
31 | ## Comment ça fonctionne ?
32 | - Vous créez des playbooks et un inventaire sur votre machine locale.
33 | - Vous établissez une connexion SSH sans mot de passe aux serveurs cibles.
34 | - Ansible recueille des informations (gather facts) sur les serveurs cibles pour connaître leur état.
35 | - Ansible envoie les instructions (playbooks) aux serveurs.
36 | - Les serveurs exécutent les tâches définies dans les playbooks.
37 |
38 | ## Étapes de Configuration
39 |
40 | 
41 |
42 |
43 | ### 1. Prérequis
44 | Avant de commencer, assurez-vous d'avoir :
45 | - 3 machines virtuels (1 control node & 2 target nodes) ayant les système Red Hat Enterprise Linux ou CentOS installé.
46 | https://www.mediafire.com/file/vckh650ljsd9vjd/RHEL9.zip/file
47 | - le paquet python3 est installé sur les 3 machines.
48 | ```bash
49 | yum install python3
50 | ```
51 |
52 | ### 2. Installer Ansible sous le control node.
53 | ```bash
54 | yum install ansible-core
55 | ```
56 | ### 3. ajouter et configurer le 'remote user' sous les 3 machines.
57 | ```bash
58 | useradd ansible
59 | passwd ansible
60 | ```
61 | ```bash
62 | vim /etc/sudoers.d/ansible
63 | ansible ALL=(ALL) NOPASSWD: ALL
64 | ```
65 |
66 | NB: avant de commencer, vous pouvez nommer les machines comme suit.
67 |
68 | ```bash
69 | vim /etc/hosts
70 | son@ip control-node1
71 | son@ip target-node1
72 | son@ip target-node2
73 |
74 | ```
75 | ### 4. configurer la connexion ssh sans mot de passe depuis le control node en tant que remote user vers les 2 machines.
76 | ```bash
77 | ssh ansible@localhost
78 | ssh-keygen
79 | ls .ssh
80 | ssh-copy-id ansible@target-node1
81 | ssh-copy-id ansible@target-node2
82 | ```
83 | ### 5. ajouter le fichier inventaire sous le control node
84 | ```bash
85 | [group1]
86 | target-node1
87 |
88 | [group2]
89 | target-node2
90 | ```
91 | ### 6. ajouter le fichier ansible.cfg sous le control node
92 | ```bash
93 | [defaults]
94 | remote_user=ansible
95 | inventory=/home/ansible/inventory
96 | [privilege_escalation]
97 | become=true
98 | ```
99 |
100 | ### 7. tester la connexion ssh sans mot de passe en restant en tant que remote user
101 | ```bash
102 | ssh ansible@target-node1
103 | ```
104 |
105 | ### 5. tester la connexion ansible
106 | ```bash
107 | ansible target-node1 -m ping
108 | ```
109 |
110 |
111 |
--------------------------------------------------------------------------------
/08-task-handlers-et-error-handlers.md:
--------------------------------------------------------------------------------
1 | Task handlers et Error handlers
2 |
3 | ### Introduction
4 | 👋 Dans cette section, nous allons explorer comment utiliser les variables ignore_errors, ignore_unreachable aussi l'utilisation de block, rescue et always.
5 |
6 | ### ignore_errors et ignore_unreachable dans Ansible
7 | `ignore_errors` est utilisé pour ignorer les erreurs sur une tâche spécifique et continuer l'exécution des tâches suivantes.
8 | ```bash
9 | - hosts: all
10 | tasks:
11 | - name: This task will fail but continue
12 | command: /bin/false
13 | ignore_errors: yes
14 |
15 | - name: This task will still run
16 | command: /bin/echo "Hello, World!"
17 |
18 | ```
19 | Dans cet exemple, même si la première tâche échoue, Ansible continue et exécute la deuxième tâche.
20 | `ignore_unreachable` est utilisé pour ignorer les hôtes inaccessibles et continuer à exécuter des tâches sur les autres hôtes. Vous l'utilisez généralement au niveau du bloc de lecture ou du bloc de tâches.
21 |
22 | ```bash
23 | - hosts: all
24 | ignore_unreachable: yes
25 | tasks:
26 | - name: This task will run even if some hosts are unreachable
27 | command: /bin/echo "Running on reachable hosts"
28 |
29 | ```
30 | Dans cet exemple, si certains hôtes sont inaccessibles, Ansible continue à exécuter les tâches sur les hôtes accessibles.
31 | ### Utilisation des blocs (block)
32 | Les blocs (`block`) sont utilisés pour regrouper plusieurs tâches et leur appliquer des directives ou des conditions communes.
33 | Exemple de bloc avec une condition :
34 | ```bash
35 | - hosts: all
36 | tasks:
37 | - block:
38 | - name: Install package
39 | yum:
40 | name: httpd
41 | state: present
42 |
43 | - name: Start service
44 | service:
45 | name: httpd
46 | state: started
47 | when: ansible_os_family == "RedHat"
48 |
49 | ```
50 | NB: on peut utiliser block pour une condition contenant plusieurs tâches.
51 | ### Utilisation de block et rescue
52 | Les blocs peuvent être utilisés pour gérer les erreurs en utilisant `rescue`, qui définit les tâches à exécuter en cas d'erreur dans le `block`.
53 |
54 | Exemple simple avec block et rescue :
55 |
56 |
57 | ```bash
58 | - hosts: localhost
59 | tasks:
60 | - block:
61 | - name: Run a command that may fail
62 | command: /bin/false
63 |
64 | - name: This task will be skipped if the above fails
65 | command: /bin/echo "This won't run"
66 | rescue:
67 | - name: Handle the error
68 | debug:
69 | msg: "There was an error, handling it now"
70 |
71 | ```
72 | Dans cet exemple :
73 |
74 | Les tâches à l'intérieur du block sont exécutées en premier.
75 | Si une tâche dans le block échoue, les tâches dans le rescue sont exécutées pour gérer l'erreur.
76 | ### Utilisation de block et always
77 | Les blocs peuvent également être utilisés pour exécuter des tâches finales, indépendamment de la réussite ou de l'échec des tâches précédentes, en utilisant `always`.
78 |
79 | Exemple simple avec block et always :
80 |
81 |
82 | ```bash
83 | - hosts: localhost
84 | tasks:
85 | - block:
86 | - name: Run a command that may fail
87 | command: /bin/false
88 |
89 | - name: This task will be skipped if the above fails
90 | command: /bin/echo "This won't run"
91 | always:
92 | - name: Always run this task
93 | debug:
94 | msg: "This task always runs, regardless of the previous results"
95 |
96 | ```
97 | Dans cet exemple :
98 |
99 | Les tâches à l'intérieur du `block` sont exécutées en premier.
100 | Les tâches à l'intérieur du `always` sont exécutées quelles que soient les erreurs dans le block.
101 | ### Utilisation de block, rescue et always
102 | Les blocs peuvent également être utilisés pour gérer les erreurs avec `rescue` et pour exécuter des tâches finales avec `always`.
103 | Exemple simple avec rescue et always :
104 |
105 |
106 | ```bash
107 | - hosts: localhost
108 | tasks:
109 | - block:
110 | - name: Run a command that may fail
111 | command: /bin/false
112 |
113 | - name: This task will be skipped if the above fails
114 | command: /bin/echo "This won't run"
115 | rescue:
116 | - name: Handle the error
117 | debug:
118 | msg: "There was an error"
119 | always:
120 | - name: Always run this task
121 | debug:
122 | msg: "This always runs"
123 |
124 | ```
125 | Dans cet exemple :
126 |
127 | - Les tâches à l'intérieur du block sont exécutées en premier.
128 | - Si une tâche dans le block échoue, les tâches dans le rescue sont exécutées pour gérer l'erreur.
129 | - Les tâches dans le always sont exécutées, que les tâches du block ou du rescue aient échoué ou réussi.
130 |
--------------------------------------------------------------------------------
/10-roles-et-rhel-system-roles.md:
--------------------------------------------------------------------------------
1 | Roles & Rhel-system-roles
2 |
3 | ### Introduction
4 | 👋 Dans cette section, nous allons explorer comment créer un rôle et utiliser quelques rôles de système.
5 | ### Création de rôle Apache
6 | ``` bash
7 | ansible-galaxy --help
8 | ```
9 | Pour créer un rôle Ansible, vous utilisez la commande ansible-galaxy init. Cela génère une structure de répertoires pour le rôle avec des fichiers de configuration de base.
10 | #### initialiser le rôle
11 | ``` bash
12 | cd /path/to/your/custom/roles
13 | ansible-galaxy init apache
14 | ```
15 | or you can specify the path
16 | ``` bash
17 | ansible-galaxy init --init-path= /path/to/your/custom/roles apache
18 | ```
19 | ``` bash
20 | cd apache
21 | tree
22 | ```
23 | - `handlers/` : Contient des handlers, qui sont des tâches déclenchées par d'autres tâches (par exemple, pour redémarrer un service).
24 | - `tasks/` : Contient les tâches principales du rôle.
25 | - `templates/` : Contient les fichiers de template Jinja2 pour la génération dynamique de fichiers.
26 | - `vars/` : Contient les variables spécifiques au rôle.
27 | #### Définir les Tâches dans tasks/main.yml
28 | ``` bash
29 |
30 |
31 | - name: install packages
32 | yum:
33 | name: "{{item}}"
34 | state: present
35 | loop: "{{packages}}"
36 |
37 | - name: Enable services
38 | service:
39 | name: "{{item}}"
40 | state: started
41 | enabled: yes
42 | loop: "{{packages}}"
43 | - name: Allow webserver service
44 | firewalld:
45 | service: http
46 | state: enabled
47 | permanent: yes
48 | immediate: yes
49 |
50 | - name: Create index file from index.html.j2
51 | template:
52 | src: index.html.j2
53 | dest: /var/www/html/index.html
54 | notify:
55 | - restart_service
56 | ```
57 | NB: `notify` notifie le handler restart_webservers lorsque le fichier de template change.
58 | #### Créer le Template Jinja2 dans templates/index.html.j2
59 | ``` bash
60 | Welcome to {{ ansible_fqdn }} on {{ ansible_default_ipv4.address }}
61 | ```
62 | #### Définir le Handler pour Redémarrer le Service
63 | ``` bash
64 | - name: restart_service
65 | service:
66 | name: httpd
67 | state: restarted
68 | ```
69 | #### Créer variable packages dans vars/main.yml
70 | ``` bash
71 | packages:
72 | - firewalld
73 | - httpd
74 | ```
75 |
76 | #### Créer un Playbook Utilisant le Rôle
77 | ``` bash
78 | vim apache.yml
79 | ```
80 | ``` bash
81 | - name: Install apache from apache-role
82 | hosts: all
83 | become: true
84 | roles:
85 | - sample-apache
86 | ```
87 | ### Rhel-system-roles
88 | `rhel-system-roles` est un ensemble de rôles Ansible fournis par Red Hat pour simplifier la gestion des systèmes RHEL (Red Hat Enterprise Linux). Voici un guide simple pour installer et utiliser ces rôles, et comprendre leur documentation.
89 | #### Installation des Rôles rhel-system-roles
90 | ``` bash
91 | yum install rhel-system-roles
92 | ```
93 | you can whether
94 | ``` bash
95 |
96 | sudo cp -r /usr/share/ansible/roles/* /home/ansible/roles1
97 | ```
98 | or add the path directly in the ansible.cfg
99 | ``` bash
100 | [defaults]
101 | remote_user=ansible
102 | inventory=/home/ansible/inventory
103 | roles_path=/home/ansible/roles1:/home/ansible/.ansible/roles:/usr/share/ansible/roles:/etc/ansible/roles
104 | [privilege_escalation]
105 | become=true
106 | ```
107 | Cette commande télécharge et installe les rôles dans le répertoire des rôles d'Ansible (souvent ~/.ansible/roles ou un répertoire défini dans votre configuration).
108 | #### Documentation des Rôles
109 | La documentation des rôles rhel-system-roles se trouve généralement dans `/usr/share/doc/rhel-system-roles`. Vous pouvez explorer cette documentation pour obtenir des informations sur les `variables disponibles ` et les `configurations possibles` dans le fichier`README.md`.
110 | ``` bash
111 | ls /usr/share/doc/rhel-system-roles
112 | ```
113 | #### Rôle timesync
114 | Ce rôle configure le service de synchronisation de l'heure (NTP ou chrony).
115 | Exemple de Playbook utilisant timesync :
116 | ``` bash
117 | cd /usr/share/doc/rhel-system-roles/timesync
118 | ```
119 | ``` bash
120 | cat example-timesync-playbook
121 | ```
122 |
123 | ``` bash
124 | - hosts: all
125 | vars:
126 | timesync_ntp_servers:
127 | - hostname: @server
128 | iburst: yes
129 | roles:
130 | - rhel-system-roles.timesync
131 | ```
132 | #### Rôle selinux
133 | Ce rôle configure les paramètres de SELinux.
134 | Exemple de Playbook utilisant selinux :
135 | ``` bash
136 | cat example-selinux-playbook.yml
137 | ```
138 | ``` bash
139 | - name: Manage SELinux Booleans
140 | hosts: all
141 | become: yes
142 | vars:
143 | selinux_booleans:
144 | - name: httpd_can_network_connect
145 | state: true
146 | roles:
147 | - rhel-system-roles.selinux
148 | ```
149 | un autre exemple:
150 | ``` bash
151 | - name: Manage SELinux policy example
152 | hosts: all
153 | vars:
154 | selinux_policy: targeted
155 | selinux_state: enforcing
156 | roles:
157 | - rhel-system-roles.selinux
158 | ```
159 |
--------------------------------------------------------------------------------
/03-les-playbooks.md:
--------------------------------------------------------------------------------
1 | Les Playbooks
2 |
3 | ### Introduction
4 | 👋 Dans cette section, nous allons explorer comment écrire et exécuter les playbooks.
5 |
6 |
7 | 
8 |
9 |
10 | - l'extention de playbook peut être .yml ou .yaml.
11 | - Pour vérifier la syntaxe on fait
12 | ``` bash
13 | ansible-playbook --syntax-check
14 | ```
15 | - Pour exécuter le playbook on fait
16 | ``` bash
17 | ansible-playbook playbook.yml
18 | ```
19 |
20 |
21 | ## Syntaxe
22 | ```bash
23 | - name: Description du playbook
24 | hosts: [hôtes]
25 | become: [true/false]
26 | tasks:
27 | - name: Description de la tâche 1
28 | [module]:
29 | [arguments]
30 | - name: Description de la tâche 2
31 | [module]:
32 | [arguments]
33 | ```
34 |
35 |
36 | ### LAB 02
37 | #### Q0. Utilisez un playbook Ansible pour ajouter un utilisateur nommé « alice » avec un shell /sbin/nologin et un home directory /host/alice sur toutes les machines hôtes, aussi pour modifier l'utilisateur « bob » afin que son shell soit /bin/bsh, son UID soit 2006, et son home directory soit /home/bob.
38 |
39 | ``` bash
40 | - name: ajouter alice te modifier bob
41 | hosts: all
42 | become: true
43 | tasks:
44 | - name: ajouter alice
45 | user:
46 | name: alice
47 | home: /home/alice
48 | shell: /bin/bash
49 | state: present
50 | - name: modifier bob
51 | user:
52 | name: bob
53 | uid: 2006
54 | home: /home/bob
55 | shell: /bin/sh
56 | state: present
57 |
58 | ```
59 |
60 | #### Q1. Utilisez un playbook Ansible pour supprimer l'utilisateur « charlie » de toutes les machines hôtes.
61 |
62 | ``` bash
63 |
64 | - name: supprimer charlie
65 | hosts: all
66 | become: true
67 | tasks:
68 | - name: delete
69 | user:
70 | name: charlie
71 | state: absent
72 | ```
73 |
74 | #### Q2. Utilisez un playbook Ansible pour installer le package httpd sur la machine hôte web-server, vérifier l'installation du package httpd sur toutes les machines hôtes en utilisant le module command et démarrer et activer ce service sur la machine hôte target-node1.
75 |
76 |
77 | ``` bash
78 | - hosts: web-server
79 | become: true
80 | tasks:
81 | - name: istaller httpd
82 | yum:
83 | name: httpd
84 | state: present
85 | - hosts: all
86 | become: true
87 | tasks:
88 | - name: verif httpd
89 | command: rpm -q httpd
90 | - hosts: target-node1
91 | become: true
92 | tasks:
93 | - name: enable and start httpd
94 | service:
95 | name: httpd
96 | enabled: yes
97 | state: started
98 |
99 |
100 | ```
101 |
102 | #### Q3. Utilisez un playbook Ansible pour ajouter une ligne au fichier /etc/hosts sur toutes les machines hôtes. La ligne à ajouter est '10.0.0.1 myserver'.
103 |
104 |
105 | ``` bash
106 | hosts: all
107 | become: true
108 | tasks:
109 | - name: modifier ligne
110 | lineinfile:
111 | path: /etc/hosts
112 | line: 10.0.0.1 myserver
113 | ```
114 |
115 | #### Q4. Utilisez un playbook Ansible pour copier un fichier nommé config.json depuis la machine de contrôle vers le répertoire /etc/myapp/ sur la machine app-server.
116 |
117 |
118 | ``` bash
119 | - hosts: all
120 | become: true
121 | tasks:
122 | - name: créer répertoire /etc/myapp
123 | file:
124 | path: /etc/myapp
125 | state: directory
126 | - name: copier fichier
127 | copy:
128 | src: config.json
129 | dest: /etc/myapp
130 | ```
131 |
132 | #### Q5. Utilisez un playbook Ansible pour créer un répertoire nommé /backup sur toutes les machines hôtes avec les permissions 0755, appartenant à l'utilisateur root et au groupe root.
133 |
134 |
135 | ``` bash
136 | - hosts: all
137 | become: true
138 | tasks:
139 | - name: création répertoire
140 | file:
141 | path: /backup
142 | state: directory
143 | mode: 755
144 | owner: root
145 | group: root
146 | ```
147 | ### playbook avec plusieurs plays
148 | Un playbook Ansible peut contenir plusieurs "plays". Chaque "play" applique un ensemble de tâches à un groupe d'hôtes. Cela permet de structurer le playbook pour réaliser différentes phases d'une configuration ou d'un déploiement.
149 | Exemple 1:
150 | - play1: ajouter un utilisateur
151 | - play2: le modifier
152 | NB: on utilise plusieurs plays pour qu'on puisse exécuter les plays dans différentes hotes `hosts`
153 | ```bash
154 | - name: play1 to add group and its user
155 | hosts: all
156 | become: true
157 | tasks:
158 | - name: add the group
159 | group:
160 | name: group1
161 | gid: 4900
162 | - name: add the user
163 | user:
164 | name: user1
165 | uid: 4008
166 | group: group1
167 | - name: play2 to modify the user1
168 | hosts: all
169 | become: true
170 | tasks:
171 | - name: modify
172 | user:
173 | name: user1
174 | uid: 4007
175 | ```
176 | Exemple 2:
177 | 1. Premier play : Créer un site web.
178 | - installation firewalld et httpd
179 | - 'enable' les services httpd et firewalld
180 | - création index.html
181 | - 'allow' service httpd dans le firewall
182 | 2. Deuxième play : Tester le site web.
183 | - afficher la page web
184 | RQ: Pour installer le module firewalld on doit installer la collection ansible.posix
185 | ```bash
186 | ansible-galaxy collection install ansible.posix
187 | ```
188 |
189 | Lire service httpd de cours RHCSA
190 |
191 |
192 | ```bash
193 | - hosts: all
194 | become: true
195 | tasks:
196 | - name: install packages
197 | yum:
198 | name:
199 | - firewalld
200 | - httpd
201 | state: present
202 | - name: enable httpd service
203 | service:
204 | name: httpd
205 | state: started
206 | enabled: yes
207 | - name: enable firewalld service
208 | service:
209 | name: firewalld
210 | state: started
211 | enabled: yes
212 | - name: create index
213 | copy:
214 | content: "hello"
215 | dest: /var/www/html/index.html
216 | setype: httpd_sys_content_t
217 | - name: allow httpd service
218 | firewalld:
219 | service: http
220 | permanent: yes
221 | state: enabled
222 | immediate: yes
223 | - hosts: all
224 | become: false
225 | tasks:
226 | - name: webpage test
227 | uri:
228 | url: http://node1
229 |
230 | ```
231 |
--------------------------------------------------------------------------------
/02-les-commandes-adhocs.md:
--------------------------------------------------------------------------------
1 | Les commandes AD-HOC à Ansible
2 |
3 | ### Introduction
4 | 👋 Dans cette section, nous allons explorer comment utiliser la commande AD-HOC ansible.
5 | ## Syntaxe
6 | `ansible -m -a -i [options]`
7 | - `` : Les hôtes sur lesquels la commande doit être exécutée. Cela peut être all ou un groupe d'hôtes défini dans votre fichier d'inventaire ou une adresse IP/un nom d'hôte spécifique.
8 |
9 | - `-m ` : Le module Ansible à utiliser pour exécuter la tâche. Par exemple, le module ping, shell, command, copy, etc.
10 | NB: Pour lister tous les modules
11 | ``` bash
12 | ansible-doc -l
13 | ```
14 | NB: Pour obtenir la documentation du module on fait
15 | ``` bash
16 | ansible-doc module_name
17 | ```
18 | ansible-doc -l | grep user
19 |
20 | - `-a ` : Les arguments à passer au module spécifié. La manière dont les arguments sont spécifiés dépend du module utilisé.
21 |
22 | - `-i ` : Le fichier d'inventaire qui contient la liste des hôtes et leurs groupes. Si vous n'utilisez pas cette option, Ansible utilisera le fichier d'inventaire par défaut situé dans /etc/ansible/hosts.
23 |
24 | [options] : D'autres options supplémentaires peuvent être spécifiées, comme -u pour définir l'utilisateur SSH à utiliser, -b pour élever les privilèges (sudo), etc.
25 |
26 |
27 | 
28 |
29 |
30 | ### LAB 00
31 | 1. Module `ping`
32 | Ce module est utilisé pour tester la connexion entre Ansible et les hôtes cibles.
33 | ``` bash
34 | ansible all -m ping
35 | ```
36 | 2. Module `command`
37 | Ce module exécute des commandes sur les hôtes cibles. Contrairement au module shell, il n'interprète pas les caractères spéciaux comme les redirections (>, |, etc.).
38 | ``` bash
39 | ansible all -m command -a "ls -l /etc"
40 | ```
41 | 3. Module `shell`
42 | Ce module exécute des commandes dans le shell de l'hôte cible, permettant l'utilisation de caractères spéciaux et de redirections
43 | ``` bash
44 | ansible all -m shell -a "echo $HOME > homes_directory"
45 | ```
46 | 4. Module `copy`
47 | Ce module copie des fichiers de la machine de contrôle Ansible vers les hôtes cibles.
48 | ``` bash
49 | ansible all -m copy -a "src=/path/to/local/file dest=/path/to/remote/destination"
50 | ```
51 | 5. Module `file`
52 | Ce module gère les fichiers et répertoires sur les hôtes cibles, permettant la création, la suppression et la modification des permissions.
53 | exemple: ajouter un répertoire.
54 | ``` bash
55 | ansible all -m file -a "path=/path/to/directory state=directory"
56 | ```
57 | 6. Module `lineinfile`
58 | ajouter, supprimer ou modifier des lignes sans affecter le reste du contenu.
59 | exemple: ajouter une ligne.
60 | ``` bash
61 | ansible all -i inventory -m lineinfile -a "path=/etc/fstab line='/dev/sdb1 /mnt/data ext4 defaults 0 0'"
62 | ```
63 | 7. Module `yum`
64 | Ce module gère les packages sur les systèmes basés sur Red Hat (utilisant yum).
65 | exemple: installer un package
66 | ``` bash
67 | ansible all -m yum -a "name=httpd state=present"
68 | ```
69 | 8. Module `service`
70 | Ce module gère les services sur les hôtes cibles.
71 | example: restart le service
72 | ``` bash
73 | ansible all -m service -a "name=httpd state=restarted"
74 | ```
75 | 9. Module `group`
76 | Le module group permet de gérer les groupes sur les hôtes cibles.
77 | exemple: ajouter un groupe
78 | ``` bash
79 | ansible all -m group -a "name=developers gid=2002 state=present"
80 | ```
81 | 10. Module `user`
82 | exemple: ajouter un utilisateur
83 | ``` bash
84 | ansible all -m user -a "name=developer uid=2001 state=present"
85 | ```
86 | ### LAB 01
87 |
88 | #### Q0. Exécutez une commande ad hoc pour ajouter un utilisateur nommé « lisa » puis observez la sortie de la commande en utilisant la commande ad-hoc
89 |
90 |
91 | ```bash
92 | ansible all -m user -a "name=lisa"
93 | ansible all -m command -a "tail -1 /etc/passwd"
94 | ```
95 |
96 |
97 | #### Q1. Modifiez l'utilisateur « lisa » pour que son shell soit /sbin/nologin, que son UID soit 2005 et que son home directory soit /home/lisa.
98 |
99 |
100 | ```bash
101 | ansible all -m user -a "name=lisa shell=/sbin/nologin uid=2005 home=/home/lisa"
102 |
103 | ```
104 |
105 | #### Q2. Supprimez maintenant l’utilisateur lisa de toutes les machines hôtes
106 |
107 |
108 | ```bash
109 | ansible all -m user -a "name=lisa state=absent"
110 |
111 | ```
112 |
113 | #### Q3. Installez le package httpd dans la machine hôte target-node1.
114 |
115 |
116 | ```bash
117 | ansible target-node1 -m yum -a "name=httpd state=present"
118 |
119 | ```
120 |
121 | #### Q4. Vérifiez l’installation du package httpd dans toutes les machines en utilisant le module command
122 |
123 |
124 | ```bash
125 | ansible all -m command -a "rpm -q httpd"
126 |
127 | ```
128 |
129 | #### Q5. Démarrez et activez maintenant le service httpd dans la machine hôte
130 |
131 |
132 | ```bash
133 | ansible target-node1 -m service -a "name=httpd state=started enabled=yes"
134 |
135 | ```
136 |
137 | #### Q6. Utilisez le module service pour vérifier l’état de httpd sur tous les machines
138 |
139 |
140 | ```bash
141 | ansible all -m service -a "name=httpd state=started"
142 | ```
143 |
144 |
145 | #### Q7. Utilisez le module lineinfile pour ajouter une ligne au fichier /etc/hosts sur toutes les machines hôtes. La ligne à ajouter est 192.168.1.100 newhost.
146 |
147 |
148 |
149 | ```bash
150 | ansible all -m lineinfile -a "path=/etc/hosts line='192.168.1.100 newhost' state=present"
151 |
152 |
153 | ```
154 |
155 | #### Q8. Utilisez le module copy pour copier un fichier nommé index.html depuis la machine de contrôle vers le répertoire /var/www/html/ sur la machine target-node2.
156 |
157 |
158 | ```bash
159 | ansible target-node2 -m copy -a "src=/index.html dest=/var/www/html/"
160 |
161 |
162 | ```
163 |
164 |
165 |
166 | #### Q10. Utilisez le module file pour créer un répertoire nommé /backup sur toutes les machines hôtes avec les permissions 0755, appartenant à l'utilisateur root et au groupe root.
167 |
168 |
169 | ```bash
170 | ansible all -m file -a "path=/backup state=directory mode=0755 owner=root group=root"
171 |
172 |
173 | ```
174 |
175 |
176 | #### Q11. Ajoutez une ligne pour configurer le serveur SSH afin d'autoriser l'authentification par mot de passe dans le fichier /etc/ssh/sshd_config.
177 |
178 |
179 |
180 | ```bash
181 | ansible all -m lineinfile -a "path=/etc/ssh/sshd_config line='PasswordAuthentication yes' state=present"
182 |
183 | ```
184 |
185 |
186 | #### Q12. Supprimez la ligne contenant l'adresse 192.168.1.100 dans /etc/hosts.
187 |
188 |
189 |
190 | ```bash
191 | ansible all -m lineinfile -a "path=/etc/hosts regexp='^192.168.1.100' state=absent"
192 |
193 | ```
194 |
195 |
196 |
197 |
198 |
199 |
--------------------------------------------------------------------------------
/11-gestion-de-stockage-avec-ansible.md:
--------------------------------------------------------------------------------
1 | Gestion de stockage
2 |
3 | ### Introduction
4 | 👋 Dans cette section, nous allons explorer comment gérer les partitions et les volumes logiques.
5 |
6 | ### Création de partition
7 | On a besoin de la collection community.general pour les modules lvm
8 | ``` bash
9 | ansible-galaxy collection install community.general
10 | ```
11 |
12 | Pour créer une partition, nous utilisons le module `parted`.
13 | ``` bash
14 | ansible-doc parted
15 | ```
16 |
17 | ``` bash
18 | ---
19 | - name: Create a new partition
20 | hosts: all
21 | become: yes
22 | tasks:
23 | - name: Create partition
24 | parted:
25 | device: /dev/sda
26 | number: 1
27 | state: present
28 | part_end: 1GiB
29 |
30 | ```
31 | ### Créer plus qu'une partition
32 | créer 2 partitions chacune a la taille 2G
33 | ``` bash
34 |
35 | - hosts: all
36 | become: true
37 | tasks:
38 | - name: Create a new primary partition with a size of 1g
39 | parted:
40 | device: /dev/sdb
41 | number: 1
42 | #part_start: 1MiB
43 | state: present
44 | part_end: 2GiB
45 | - name: Create a new primary partition with a size of 1g
46 | parted:
47 | device: /dev/sdb
48 | number: 2
49 | part_start: 2GiB
50 | state: present
51 | part_end: 4GiB
52 | ```
53 | ### Formater la Partition
54 | Ensuite, nous formatons cette partition nouvellement créée en ext4 en utilisant le module `filesystem`.
55 | ``` bash
56 | ansible-doc filesystem
57 | ```
58 | ``` bash
59 | ---
60 | - name: Format the new partition
61 | hosts: all
62 | become: yes
63 | tasks:
64 | - name: Format partition to ext4
65 | filesystem:
66 | fstype: ext4
67 | dev: /dev/sda1
68 |
69 | ```
70 | ### Monter la Partition et l'Ajouter à fstab
71 | ``` bash
72 | ansible-doc mount
73 | ```
74 | ``` bash
75 | - name: Mount the new partition
76 | hosts: all
77 | become: yes
78 | tasks:
79 | - name: Create mount point directory
80 | file:
81 | path: /mnt/data
82 | state: directory
83 |
84 | - name: Mount partition
85 | mount:
86 | path: /mnt/data
87 | src: /dev/sda1
88 | fstype: ext4
89 | state: mounted
90 |
91 | ```
92 | ## QUESTION
93 |
94 | Create /home/ansible/partition.yml, which will create partitions on all the managed nodes:
95 | a) After sdb creating a 1200M primary partition, partition number 1, and format it into ext4 filesystem and mount it under /srv
96 | c) If there is not enough disk space, give prompt information "Could not create partition of that size" and create a 800M partition.
97 | d) If sdb does not exist, a prompt message will be given "this disk does not exist."
98 | e) format the partition with the ext4 filesystem if it is created
99 |
100 | ``` bash
101 | - name: Partition Playbook
102 | hosts: all
103 | tasks:
104 | - name: check block stroage availablity.
105 | block:
106 | - name: If sdb does not exist
107 | debug:
108 | msg: "this disk does not exist."
109 | when: "'sdb' not in ansible_devices"
110 | - name: Creating the 1200m partition
111 | parted:
112 | device: /dev/sdb
113 | number: 1
114 | part_end: 1200MiB
115 | state: present
116 | when: "'sdb' in ansible_devices"
117 | rescue:
118 | - name: If there is not enough disk space
119 | debug:
120 | msg: "Could not create partition of that size"
121 | - name: Creating the smaller partition
122 | parted:
123 | device: /dev/sdb
124 | number: 1
125 | part_end: 800MiB
126 | state: present
127 | always:
128 | - name: Creating the ext4 filesystem
129 | filesystem:
130 | fstype: ext4
131 | dev: /dev/sdb1
132 | when: "'sdb' in ansible _devices"
133 | - name: Create mount point directory
134 | file:
135 | path: /srv
136 | state: directory
137 | when: "'sdb' in ansible_devices"
138 | - name: Mount partition
139 | mount:
140 | path: /srv
141 | src: /dev/sdb1
142 | fstype: ext4
143 | state: mounted
144 | when: "'sdb' in ansible_devices"
145 | ```
146 |
147 | ### Création d'un Groupe de Volumes avec lvg
148 | ``` bash
149 | ansible-doc lvg
150 | ```
151 | ``` bash
152 | ---
153 | - name: Create a Volume Group
154 | hosts: all
155 | become: yes
156 | tasks:
157 | - name: Create volume group
158 | lvg:
159 | vg: vg_data # Nom du groupe de volumes
160 | pvs: /dev/sdb1 # La partition physique à inclure dans le groupe de volumes
161 |
162 | ```
163 | ### Créer un Volume Logique avec lvol
164 | ``` bash
165 | ansible-doc lvol
166 | ```
167 | ``` bash
168 | ---
169 | - name: Create a Logical Volume
170 | hosts: all
171 | become: yes
172 | tasks:
173 | - name: Create logical volume
174 | lvol:
175 | vg: vg_data # Le groupe de volumes auquel appartient le LV
176 | lv: lv_data # Nom du volume logique
177 | size: 500m # Taille du volume logique
178 |
179 | ```
180 | ### Formater le Volume Logique avec filesystem
181 | ``` bash
182 | ansible-doc filesystem
183 | ```
184 | ``` bash
185 | ---
186 | - name: Format the Logical Volume
187 | hosts: all
188 | become: yes
189 | tasks:
190 | - name: Format logical volume
191 | filesystem:
192 | fstype: ext4 # Type de système de fichiers (ex: ext4, xfs)
193 | dev: /dev/vg_data/lv_data # Dispositif à formater
194 | ```
195 | ### Monter le Volume en Utilisant le Module mount
196 | ``` bash
197 | ansible-doc mount
198 | ```
199 | ``` bash
200 | ---
201 | - name: Mount the Logical Volume
202 | hosts: all
203 | become: yes
204 | tasks:
205 | - name: Create mount point directory
206 | file:
207 | path: /mnt/data1 # Chemin du point de montage
208 | state: directory # État souhaité (directory pour créer un répertoire)
209 | - name: Mount logical volume
210 | mount:
211 | path: /mnt/data1 # Chemin du point de montage
212 | src: /dev/vg_data/lv_data # Source du dispositif à monter
213 | fstype: ext4 # Type de système de fichiers
214 | state: mounted # État souhaité (mounted pour monter le volume)
215 | ```
216 | ## QUESTION
217 | Create a playbook called /home/ansible/lvm.yml that runs on all the managed nodes and does the following:
218 | a) Creates a logical volume with the following requirements:
219 | i.The logical volume is created in the volume group.
220 | ii.The logical volume name is data.
221 | ili.The logical volume size is 1200 Mib.
222 | iv. Format the logical volume with the ext4 file-system.
223 | v. if the requested logical volume size cannot be created, the error message "could not create logical volume of that size" should be displayed and size 800 MiB should be used instead.
224 | vi. if the volume research does not exist, the error message "volume group does not exist"
225 | should be displayed.
226 | vii. Don't mount the logical volume in any way.
227 |
228 | ``` bash
229 | - name: lvm playbook
230 | hosts: all
231 | become: true
232 | tasks:
233 | - name: checking details
234 | block:
235 | - name: if the volume research does not exist
236 | debug:
237 | msg: "volume group does not exist"
238 | when: "'research' not in ansible_lvm.vgs"
239 | - name: creating the 1200m lvm
240 | lvol:
241 | vg: research
242 | Lv: data
243 | size: 1200m
244 | when: "'research' in ansible_lvm.vgs"
245 | rescue:
246 | - name: if the requested logical volume size cannot be cretaed
247 | debug:
248 | msg: "Could not create logical volume of that size"
249 | - name: creating the logical volume of 800m
250 | lvol:
251 | vg : research
252 | lv: data
253 | size: 800m
254 | always:
255 | - name: format filesystem
256 | filesystem:
257 | fstype: ext4
258 | dev: /dev/research/data
259 | when: "'data' in ansible_lvm.lvs"
260 | ```
261 |
--------------------------------------------------------------------------------
/06-conditions-et-loops.md:
--------------------------------------------------------------------------------
1 | Les conditions & les boucles
2 |
3 | ### Introduction
4 | 👋 Dans cette section, nous allons explorer comment utiliser les Loops et les Conditions en Ansible.
5 |
6 | ### Loop en Ansible
7 | Ansible permet d'itérer sur une liste d'éléments en utilisant des boucles. Cela simplifie les tâches répétitives. Voici une explication avec des exemples concrets.
8 | - `Loop simple avec liste intégrée` : Itère directement sur une liste définie dans le playbook.
9 | - `Loop simple avec fichier de variables` : Itère sur une liste définie dans un fichier de variables externe.
10 | - `Loop avec dictionnaire` : Itère sur une liste de dictionnaires, permettant d'accéder à plusieurs valeurs associées à chaque élément.
11 | #### Exemple 1 : Boucle simple avec une liste intégrée
12 | ```bash
13 | - hosts: all
14 | tasks:
15 | - name: afficher la liste
16 | shell: echo "{{ item }}"
17 | loop:
18 | - "one"
19 | - "two"
20 | - "three"
21 |
22 | ```
23 | NB:
24 | `item` : C'est une variable spéciale utilisée à l'intérieur de la boucle pour représenter l'élément actuel de la liste.
25 | `loop`: Contient la liste des éléments sur lesquels itérer.
26 | #### Exemple 2 : Boucle simple avec un fichier de variables
27 |
28 | ```bash
29 | vim simple_loop.yml
30 | ```
31 |
32 | ```bash
33 | numbers:
34 | - "one"
35 | - "two"
36 | - "three"
37 |
38 | ```
39 |
40 | ```bash
41 | vim playbook.yml
42 |
43 | ```
44 |
45 | ```bash
46 | - hosts: all
47 | vars_files:
48 | - simple_loop.yml
49 | tasks:
50 | - name: afficher la liste
51 | shell: echo "{{ item }}"
52 | loop: "{{ numbers }}"
53 |
54 | ```
55 | NB: le playbook utilise la liste numbers définie dans `simple_loop.yml`.
56 | #### Exemple 3 : Boucle avec un dictionnaire
57 |
58 | ```bash
59 | vim dict_loop.yml
60 | ```
61 | ```bash
62 | users:
63 | - username: user1
64 | his_group: group1
65 | - username: user2
66 | his_group: group2
67 | - username: user3
68 | his_group: group3
69 |
70 | ```
71 | ```bash
72 | vim playbook.yml
73 | ```
74 | ```bash
75 | - hosts: all
76 | vars_files:
77 | - dict_loop.yml
78 | tasks:
79 | - name: afficher la liste
80 | debug:
81 | msg: this is the user "{{ item.username }}" and his group is "{{ item.his_group }}"
82 | loop: "{{ users }}"
83 |
84 | ```
85 | NB:
86 | - `users`: Contient une liste de dictionnaires, chaque dictionnaire ayant les clés `username` et `his_group`.
87 | - loop: "{{ users }}" : Utilise la liste `users` définie dans `dict_loop.yml`.
88 | - `item.username` et `item.his_group` : Accède aux valeurs du dictionnaire actuel dans la boucle.
89 | On peut maintenant utiliser les loops pour l'exercice de httpd
90 |
91 | dans la fin de cette section
92 |
93 |
94 | comme suivant:
95 | ```bash
96 | vim services.yml
97 | ```
98 | ```bash
99 | services:
100 | - httpd
101 | - firewalld
102 | ```
103 | ```bash
104 | vim httpd.yml
105 | ```
106 | ```bash
107 | - hosts: all
108 | become: true
109 | vars_files:
110 | - services.yml
111 | tasks:
112 | - name: install packages
113 | yum:
114 | name: "{{item}}"
115 | state: present
116 | loop: "{{services}}"
117 | - name: enable httpd service
118 | service:
119 | name: "{{item}}"
120 | state: started
121 | enabled: yes
122 | loop: "{{services}}"
123 | - name: create index
124 | copy:
125 | content: "hello"
126 | dest: /var/www/html/index.html
127 | setype: httpd_sys_content_t
128 | - name: allow httpd service
129 | firewalld:
130 | service: http
131 | permanent: yes
132 | state: enabled
133 | immediate: yes
134 |
135 | ```
136 | ### When en Ansible
137 | La condition when en Ansible permet d'exécuter des tâches uniquement si certaines conditions sont remplies. Si la condition n'est pas remplie, la tâche est ignorée, et Ansible indique cette action dans la sortie `skipping`
138 | #### Exemple de Playbook avec when:
139 | ```bash
140 | - name: Install vim in CentOS and Ubuntu nodes
141 | hosts: web
142 | tasks:
143 | - name: Install vim on Centos
144 | yum:
145 | name: vim
146 | state: present
147 | when: ansible_facts['distribution'] == "CentOS"
148 |
149 | - name: Install vim on Ubuntu
150 | apt:
151 | name: vim
152 | state: present
153 | when: ansible_facts['distribution'] == "Ubuntu"
154 |
155 | ```
156 | On peut maintenant utiliser les conditions pour la question
157 |
158 | dans la fin de cette section
159 |
160 |
161 | tel que "If a disk does not exist then write NONE" comme suivant:
162 | ``` bash
163 |
164 | - name: QUESTION CORRECTION
165 | hosts: all
166 | become: true
167 | tasks:
168 | - name: change hostname
169 | lineinfile:
170 | path: /root/report.txt
171 | line: HOST={{ ansible_hostname }}
172 | regexp: ^HOST
173 | state: present
174 | - name: chahge memory
175 | lineinfile:
176 | path: /root/report.txt
177 | line: MEMORY={{ ansible_memtotal_mb }}
178 | regexp: ^MEMORY
179 | state: present
180 | - name: change bios version
181 | lineinfile:
182 | path: /root/report.txt
183 | line: BIOS={{ ansible_bios_version }}
184 | regexp: ^BIOS
185 | state: present
186 | - name: change sda if there is sda
187 | lineinfile:
188 | path: /root/report.txt
189 | line: SDA_DISK_SIZE={{ ansible_devices.sda.size }}
190 | regexp: ^SDA_DISK_SIZE
191 | state: present
192 | when: "'sda' in ansible_devices "
193 | - name: change sda if there is no sda
194 | lineinfile:
195 | path: /root/report.txt
196 | line: SDA_DISK_SIZE= NONE
197 | regexp: ^SDA_DISK_SIZE
198 | state: present
199 | when: "'sda' not in ansible_devices "
200 | - name: change sdb if there is sdb
201 | lineinfile:
202 | path: /root/report.txt
203 | line: SDA_DISK_SIZE={{ ansible_devices.sdb.size }}
204 | regexp: ^SDB_DISK_SIZE
205 | state: present
206 | when: "'sdb' in ansible_devices "
207 | - name: change sda if there is no sdb
208 | lineinfile:
209 | path: /root/report.txt
210 | line: SDB_DISK_SIZE= NONE
211 | regexp: ^SDB_DISK_SIZE
212 | state: present
213 | when: "'sdb' not in ansible_devices "
214 |
215 | ```
216 | ### QUESTION:
217 | 0. your inventory is
218 | ```bash
219 | [dev]
220 | node1
221 | [proxy]
222 | node2
223 | ```
224 | 1. Create an ansible vault password file called lock.yml with the password reallysafepw in the /home/ansible directory. In the lock.yml file define two variables. One is pw_dev and the password is ‘dev’ and the other is pw_mgr and the password is ‘mgr’. Create a regular file called secret.txt which contains the password for lock.yml.
225 |
226 | 2. Create the users in the file users_list.yml file provided. Do this in a playbook called users.yml located at /home/ansible. The passwords for these users should be set using the lock.yml file. When running the playbook, the lock.yml file should be unlocked with secret.txt file.
227 | users_list.yml
228 | ```bash
229 | users:
230 | - username: bill
231 | job: developer
232 | - username: chris
233 | job: manager
234 | - username: dave
235 | job: test
236 | - username: ethan
237 | job: developer
238 | ```
239 | 3. All users with the job of ‘developer’ should be created on the dev hosts, add them to the group devops, their password should be set using the pw_dev variable. Likewise create users with the job of ‘manager’ on the proxy host and add the users to the group ‘managers’, their password should be set using the pw_mgr variable.
240 |
241 | NB: inventory_hostname est le nom que vous donnez à l'hôte dans votre fichier d'inventaire(/etc/hosts+inventory), tandis que ansible_hostname est le nom que l'hôte distant utilise pour se référencer lui-même(facts -> hostname).
242 |
243 | ```bash
244 | ansible-vault create lock.yml
245 | ```
246 | ```bash
247 | vim secret.txt
248 | ```
249 | ```bash
250 | - hosts: all
251 | become: true
252 | vars_files:
253 | - lock.yml
254 | - users_list.yml
255 | tasks:
256 | - name: create groups
257 | group:
258 | name: "{{item}}"
259 | state: present
260 | loop:
261 | - managers
262 | - devops
263 | - name: create developers on dev hosts
264 | user:
265 | name: "{{item.username}}"
266 | group: devops
267 | password: "{{pw_dev | password_hash('sha512')}}"
268 | loop: "{{users}}"
269 | when: "item.job == 'developer' and inventory_hostname in groups['dev']"
270 | - name: create managers on proxy hosts
271 | user:
272 | name: "{{item.username}}"
273 | group: managers
274 | password: "{{pw_mgr | password_hash('sha512')}}"
275 | loop: "{{users}}"
276 | when: "item.job == 'manager' and inventory_hostname in groups['proxy']"
277 |
278 | ```
279 | ## QUESTION
280 | Create a playbook called webdev.yml in /home/ansible. The playbook will create a directory /webdev on dev host. The permission of the directory is u=rwx,g=rw, other has no permission.
281 | Set group id for the folder and owner is webdev.
282 | Create a symbolic link from /webdev to /var/www/html/webdev.
283 | Serve a file from /webdev/index.html which displays the text “Development”.
284 | Curl http://node1.example.com/webdev/index.html to test
285 | ```bash
286 | ansible-galaxy collection install community.general
287 | ```
288 | ```bash
289 | - name: web development
290 | hosts: dev
291 | become: true
292 | tasks:
293 | - name: create webdev user
294 | user:
295 | name: webdev
296 | state: present
297 | - name: create directory
298 | file:
299 | path: /webdev
300 | state: directory
301 | owner: webdev
302 | mode: 2760
303 | - name: create symbolic link
304 | file:
305 | src: /webdev
306 | path: /var/www/html/webdev
307 | state: link
308 | - name: create index.html
309 | copy:
310 | content: Development
311 | dest: /var/www/html/webdev/index.html
312 | - name: allow httpd from custom directory
313 | sefcontext:
314 | target: '/webdev(/.*)?'
315 | setype: httpd_sys_content_t
316 | state: present
317 | - name: restore the context
318 | shell: restorecon -vR /webdev
319 | - name: test
320 | uri:
321 | url: http://node1/webdev/ #do not forget the last / to avoid the 301 Moved permanently error
322 | ```
323 |
324 | to see the content you should do
325 | ```bash
326 | ansible node1 -m command -a "curl http://node1/webdev/ "
327 | ```
328 |
--------------------------------------------------------------------------------