Automatisation des tâches d'administration RHEL avec Ansible

Introduction

Dans ce laboratoire complet, vous maîtriserez l'automatisation des tâches critiques d'administration Linux à l'aide d'Ansible. En vous appuyant sur vos connaissances en gestion de fichiers, vous explorerez désormais comment gérer le cycle de vie complet de l'administration système, de l'installation de logiciels à la gestion des utilisateurs, en passant par la configuration des services, le provisionnement du stockage et la configuration réseau.

Vous commencerez par automatiser la gestion des paquets logiciels et la configuration des dépôts à l'aide de modules tels que ansible.builtin.dnf, ansible.builtin.yum_repository et ansible.builtin.rpm_key. Ensuite, vous créerez et gérerez des comptes utilisateurs, configurerez l'accès SSH et établirez les privilèges sudo. Le laboratoire progresse vers la gestion des services, les tâches planifiées avec cron et systemd, avant de passer à la gestion du stockage à l'aide de LVM et des opérations sur les systèmes de fichiers. Enfin, vous configurerez les interfaces réseau et collecterez des informations système.

Ce laboratoire met l'accent sur des scénarios réels couramment rencontrés dans les environnements Linux d'entreprise, vous préparant à mettre en œuvre efficacement les pratiques d'Infrastructure as Code (Infrastructure en tant que Code).

Configurer le dépôt et gérer les paquets logiciels

Dans cette étape, vous apprendrez à automatiser la gestion des paquets logiciels sur les systèmes RHEL à l'aide d'Ansible. Vous configurerez un dépôt Yum, gérerez les clés GPG RPM et collecterez des informations sur les paquets sur les hôtes gérés. Ceci est essentiel pour maintenir des installations logicielles cohérentes sur votre infrastructure.

Vous utiliserez plusieurs modules clés : ansible.builtin.yum_repository pour la gestion des dépôts, ansible.builtin.rpm_key pour la gestion des clés GPG, ansible.builtin.package_facts pour la collecte d'informations sur les paquets, et ansible.builtin.dnf pour l'installation des paquets.

Tout d'abord, configurez l'environnement du projet et installez Ansible.

Installez le paquet ansible-core et naviguez vers le répertoire du projet.
```
sudo dnf install -y ansible-core
cd ~/project
mkdir system-software
cd system-software
```
Créez un fichier d'inventaire Ansible pour définir nos hôtes gérés. Pour ce laboratoire, nous allons gérer la machine locale.
```
cat << EOF > inventory.ini
[webservers]
localhost ansible_connection=local

[all:children]
webservers
EOF
```

Créez le playbook principal repo_playbook.yml qui gérera la configuration du dépôt et l'installation des paquets. Ce playbook démontre un flux de travail complet de gestion logicielle.

nano repo_playbook.yml

Ajoutez le contenu suivant pour créer un playbook complet de gestion logicielle :

---
- name: Repository Configuration and Software Management
  hosts: all
  become: true
  vars:
    custom_pkg: httpd
  tasks:
    - name: Gather Package Facts
      ansible.builtin.package_facts:
        manager: auto

    - name: Show Package Facts for the custom package (initial check)
      ansible.builtin.debug:
        var: ansible_facts['packages'][custom_pkg]
      when: custom_pkg in ansible_facts['packages']

    - name: Ensure EPEL repository is configured
      ansible.builtin.yum_repository:
        name: epel
        description: Extra Packages for Enterprise Linux 9
        file: epel
        baseurl: https://download.fedoraproject.org/pub/epel/9/Everything/x86_64/
        gpgcheck: yes
        gpgkey: https://download.fedoraproject.org/pub/epel/RPM-GPG-KEY-EPEL-9
        enabled: yes
        state: present

    - name: Import EPEL GPG key
      ansible.builtin.rpm_key:
        state: present
        key: https://download.fedoraproject.org/pub/epel/RPM-GPG-KEY-EPEL-9

    - name: Install the custom package
      ansible.builtin.dnf:
        name: "{{ custom_pkg }}"
        state: present

    - name: Gather Package Facts (after installation)
      ansible.builtin.package_facts:
        manager: auto

    - name: Show Package Facts for the custom package (post-installation)
      ansible.builtin.debug:
        var: ansible_facts['packages'][custom_pkg]
      when: custom_pkg in ansible_facts['packages']

    - name: Display installed package version
      ansible.builtin.debug:
        msg: "{{ custom_pkg }} version {{ ansible_facts['packages'][custom_pkg][0]['version'] }} is installed"
      when: custom_pkg in ansible_facts['packages']

Ce playbook démontre plusieurs concepts importants :

Collecte de faits sur les paquets : Montre comment collecter des informations sur les paquets installés.
Gestion des dépôts : Configure le dépôt EPEL avec une validation GPG appropriée.
Gestion des clés GPG : Importe la clé GPG du dépôt pour la sécurité.
Installation des paquets : Installe le paquet spécifié à l'aide du module dnf.
Vérification : Confirme l'installation du paquet avec des faits mis à jour.

Exécutez le playbook pour observer le flux de travail complet de gestion logicielle en action.
```
ansible-playbook -i inventory.ini repo_playbook.yml
```
Vous devriez voir une sortie indiquant :
- La vérification initiale du paquet (probablement ignorée car httpd n'est pas installé).
- La configuration du dépôt.
- L'importation de la clé GPG.
- L'installation du paquet.
- La vérification finale montrant le paquet installé.
Vérifiez la configuration du dépôt en examinant le fichier de dépôt créé.
```
cat /etc/yum.repos.d/epel.repo
```
Vous devriez voir la configuration du dépôt EPEL avec les paramètres baseurl, gpgcheck et gpgkey.
Testez l'idempotence de la gestion des paquets en exécutant à nouveau le playbook.
```
ansible-playbook -i inventory.ini repo_playbook.yml
```
Remarquez qu'Ansible indique "ok" pour les tâches qui n'ont pas besoin de modifications, démontrant ainsi l'idempotence.

Vous avez automatisé avec succès la gestion des paquets logiciels, y compris la configuration des dépôts, la gestion des clés GPG et la vérification de l'installation des paquets à l'aide d'Ansible.

Automatiser la gestion des utilisateurs et la configuration SSH

Dans cette étape, vous apprendrez à automatiser la gestion des comptes utilisateurs, la configuration SSH et les privilèges sudo à l'aide d'Ansible. Ceci est crucial pour maintenir des politiques cohérentes d'accès utilisateur et de sécurité sur votre infrastructure.

Vous utiliserez des modules tels que ansible.builtin.user pour la gestion des utilisateurs, ansible.builtin.group pour la création de groupes, ansible.posix.authorized_key pour la gestion des clés SSH, et ansible.builtin.lineinfile pour la modification des fichiers de configuration.

Naviguez vers un nouveau répertoire de projet pour les tâches de gestion des utilisateurs.
```
cd ~/project
mkdir system-users
cd system-users
```
Installez la collection ansible.posix.
```
ansible-galaxy collection install ansible.posix
```

Créez le fichier d'inventaire pour cet exercice.

cat << EOF > inventory.ini
[webservers]
localhost ansible_connection=local
EOF

Créez un fichier de variables pour définir les utilisateurs et les groupes que nous voulons gérer.
```
mkdir vars
nano vars/users_vars.yml
```
Ajoutez le contenu suivant pour définir les comptes utilisateurs et leurs appartenances aux groupes :
```
---
users:
  - username: webuser1
    groups: webadmin
  - username: webuser2
    groups: webadmin
  - username: devuser1
    groups: webadmin
```

Générez des paires de clés SSH pour nos utilisateurs. Dans un environnement réel, les utilisateurs fourniraient leurs clés publiques.

mkdir files

## Generate SSH keys for each user
ssh-keygen -t rsa -b 2048 -f files/webuser1.key -N "" -C "webuser1@example.com"
ssh-keygen -t rsa -b 2048 -f files/webuser2.key -N "" -C "webuser2@example.com"
ssh-keygen -t rsa -b 2048 -f files/devuser1.key -N "" -C "devuser1@example.com"

Créez le playbook principal de gestion des utilisateurs users.yml. Ce playbook créera des groupes, des utilisateurs, distribuera des clés SSH et configurera l'accès sudo.

nano users.yml

Ajoutez le playbook complet de gestion des utilisateurs suivant :

---
- name: Create and manage user accounts
  hosts: webservers
  become: true
  vars_files:
    - vars/users_vars.yml
  tasks:
    - name: Create webadmin group
      ansible.builtin.group:
        name: webadmin
        state: present

    - name: Create user accounts
      ansible.builtin.user:
        name: "{{ item['username'] }}"
        groups: "{{ item['groups'] }}"
        shell: /bin/bash
        create_home: yes
        state: present
      loop: "{{ users }}"

    - name: Set up SSH authorized keys
      ansible.posix.authorized_key:
        user: "{{ item['username'] }}"
        key: "{{ lookup('file', 'files/' + item['username'] + '.key.pub') }}"
        state: present
      loop: "{{ users }}"

    - name: Configure sudo access for webadmin group
      ansible.builtin.lineinfile:
        path: /etc/sudoers.d/webadmin
        state: present
        create: yes
        mode: "0440"
        line: "%webadmin ALL=(ALL) NOPASSWD: ALL"
        validate: /usr/sbin/visudo -cf %s

    - name: Configure SSH to disable root login
      ansible.builtin.lineinfile:
        dest: /etc/ssh/sshd_config
        regexp: "^PermitRootLogin"
        line: "PermitRootLogin no"
        backup: yes
      notify: restart sshd

    - name: Configure SSH to disable password authentication
      ansible.builtin.lineinfile:
        dest: /etc/ssh/sshd_config
        regexp: "^PasswordAuthentication"
        line: "PasswordAuthentication no"
        backup: yes
      notify: restart sshd

  handlers:
    - name: restart sshd
      ansible.builtin.service:
        name: sshd
        state: restarted

Ce playbook démontre plusieurs bonnes pratiques de gestion des utilisateurs :

Gestion des groupes : Crée des groupes administratifs.
Création d'utilisateurs : Met en place des comptes utilisateurs avec des répertoires personnels appropriés.
Gestion des clés SSH : Distribue les clés publiques pour l'authentification par clé.
Configuration Sudo : Accorde des privilèges administratifs en toute sécurité.
Durcissement SSH : Désactive la connexion root et l'authentification par mot de passe.
Gestion des services : Redémarre le service SSH lors des changements de configuration.

Exécutez le playbook de gestion des utilisateurs.
```
ansible-playbook -i inventory.ini users.yml
```
Le playbook créera les utilisateurs, configurera les clés SSH, l'accès sudo et le durcissement de la configuration SSH.

Vérifiez la création des utilisateurs et l'appartenance aux groupes.

## Check if users were created
getent passwd webuser1 webuser2 devuser1

## Check group membership
groups webuser1
groups webuser2
groups devuser1

## Verify webadmin group exists
getent group webadmin

Testez l'authentification par clé SSH pour l'un des utilisateurs créés.

## Test SSH key authentication (this will connect to localhost)
ssh -i files/webuser1.key webuser1@localhost "whoami"

Vérifiez la configuration sudo en testant l'accès sudo sans mot de passe.

## Test sudo access for webuser1
ssh -i files/webuser1.key webuser1@localhost "sudo whoami"

Vérifiez les modifications de configuration SSH.

## Verify SSH configuration
sudo grep "PermitRootLogin\|PasswordAuthentication" /etc/ssh/sshd_config

## Check sudo configuration
sudo cat /etc/sudoers.d/webadmin

Vous avez automatisé avec succès la création de comptes utilisateurs, la distribution de clés SSH et la configuration de sécurité à l'aide d'Ansible, établissant ainsi une base pour une gestion sécurisée des utilisateurs sur votre infrastructure.

Automatiser la gestion des services et la planification des tâches

Dans cette étape, vous apprendrez à gérer les services systemd, à planifier des tâches cron et à configurer les cibles de démarrage du système à l'aide d'Ansible. Ceci est essentiel pour maintenir la disponibilité des services et automatiser les tâches routinières sur votre infrastructure.

Vous utiliserez des modules tels que ansible.builtin.service pour la gestion des services, ansible.builtin.cron pour la planification des tâches, ansible.posix.at pour les tâches ponctuelles, et ansible.builtin.systemd pour la gestion des cibles système.

Naviguez vers un nouveau répertoire de projet pour la gestion des services et des processus.
```
cd ~/project
mkdir system-process
cd system-process
```

Créez le fichier d'inventaire pour cet exercice.

cat << EOF > inventory.ini
[webservers]
localhost ansible_connection=local
EOF

Créez un playbook pour gérer le service du serveur HTTP Apache. Ceci démontrera la gestion de base des services.

nano service_management.yml

Ajoutez le contenu suivant :

---
- name: Manage Apache HTTP Server Service
  hosts: webservers
  become: true
  tasks:
    - name: Start and enable httpd service
      ansible.builtin.service:
        name: httpd
        state: started
        enabled: yes

    - name: Create a simple index.html
      ansible.builtin.copy:
        content: |
          <html>
          <head><title>Ansible Managed Server</title></head>
          <body>
          <h1>Welcome to Ansible Managed Apache Server</h1>
          <p>This server is configured and managed by Ansible.</p>
          <p>Service started at: $(date)</p>
          </body>
          </html>
        dest: /var/www/html/index.html
        owner: apache
        group: apache
        mode: "0644"

    - name: Verify httpd service is running
      ansible.builtin.service_facts:

    - name: Display httpd service status
      ansible.builtin.debug:
        var: ansible_facts.services['httpd.service']

Créez un playbook pour la planification des tâches cron. Ceci démontre la planification automatisée des tâches.

nano create_crontab_file.yml

Ajoutez le contenu suivant :

---
- name: Schedule recurring cron jobs
  hosts: webservers
  become: true
  tasks:
    - name: Create labex user for cron jobs
      ansible.builtin.user:
        name: labex
        state: present
        create_home: yes

    - name: Schedule system monitoring cron job
      ansible.builtin.cron:
        name: System monitoring log
        job: "date >> /home/labex/system_monitor.log && df -h >> /home/labex/system_monitor.log"
        minute: "*/5"
        hour: "*"
        user: labex
        cron_file: system-monitoring
        state: present

    - name: Schedule daily log rotation
      ansible.builtin.cron:
        name: Daily log cleanup
        job: "find /home/labex -name '*.log' -mtime +7 -delete"
        minute: "0"
        hour: "2"
        weekday: "*"
        user: labex
        cron_file: log-cleanup
        state: present

    - name: Schedule weekly system update check
      ansible.builtin.cron:
        name: Weekly update check
        job: "dnf check-update > /home/labex/update_check.log 2>&1"
        minute: "0"
        hour: "3"
        weekday: "0"
        user: labex
        cron_file: update-check
        state: present

Créez un playbook pour la planification de tâches ponctuelles à l'aide de at.

nano schedule_at_task.yml

Ajoutez le contenu suivant :

---
- name: Schedule one-time tasks with at
  hosts: webservers
  become: true
  become_user: labex
  tasks:
    - name: Schedule immediate system info collection
      ansible.posix.at:
        command: "uname -a > ~/system_info_$(date +%Y%m%d_%H%M%S).txt"
        count: 2
        units: minutes
        unique: yes
        state: present

    - name: Schedule delayed service status check
      ansible.posix.at:
        command: "systemctl status httpd > ~/httpd_status_$(date +%Y%m%d_%H%M%S).txt"
        count: 5
        units: minutes
        unique: yes
        state: present

Créez un playbook pour gérer les cibles de démarrage du système.

nano boot_target_management.yml

Ajoutez le contenu suivant :

---
- name: Manage system boot targets
  hosts: webservers
  become: true
  tasks:
    - name: Check current default target
      ansible.builtin.command:
        cmd: systemctl get-default
      register: current_target
      changed_when: false

    - name: Display current boot target
      ansible.builtin.debug:
        msg: "Current default boot target: {{ current_target.stdout }}"

    - name: Set default boot target to multi-user
      ansible.builtin.systemd:
        name: multi-user.target
        enabled: yes
      when: current_target.stdout != "multi-user.target"

    - name: Verify the boot target change
      ansible.builtin.command:
        cmd: systemctl get-default
      register: new_target
      changed_when: false

    - name: Display new boot target
      ansible.builtin.debug:
        msg: "New default boot target: {{ new_target.stdout }}"

Exécutez le playbook de gestion des services.
```
ansible-playbook -i inventory.ini service_management.yml
```
Ceci démarrera le service httpd et créera une page d'accueil.
Exécutez le playbook de planification des tâches cron.
```
ansible-playbook -i inventory.ini create_crontab_file.yml
```
Ceci créera plusieurs tâches planifiées pour la surveillance et la maintenance du système.
Exécutez le playbook de planification des tâches ponctuelles.
```
ansible-playbook -i inventory.ini schedule_at_task.yml
```
Ceci planifiera des tâches immédiates à l'aide de la commande at.
Exécutez le playbook de gestion des cibles de démarrage.
```
ansible-playbook -i inventory.ini boot_target_management.yml
```
Ceci vérifiera et potentiellement modifiera la cible de démarrage par défaut du système.

Vérifiez les tâches planifiées et les services.

## Check cron jobs
sudo cat /etc/cron.d/system-monitoring
sudo cat /etc/cron.d/log-cleanup
sudo cat /etc/cron.d/update-check

## Check at jobs
sudo atq

## Check httpd service status
sudo systemctl status httpd

## Test the web server
curl localhost

## Check system monitoring log (wait a few minutes for cron to run)
sudo cat /home/labex/system_monitor.log

Créez un playbook de nettoyage pour supprimer les tâches planifiées si nécessaire.

nano remove_scheduled_tasks.yml

Ajoutez le contenu suivant :

---
- name: Remove scheduled tasks
  hosts: webservers
  become: true
  tasks:
    - name: Remove system monitoring cron job
      ansible.builtin.cron:
        name: System monitoring log
        user: labex
        cron_file: system-monitoring
        state: absent

    - name: Remove log cleanup cron job
      ansible.builtin.cron:
        name: Daily log cleanup
        user: labex
        cron_file: log-cleanup
        state: absent

    - name: Remove update check cron job
      ansible.builtin.cron:
        name: Weekly update check
        user: labex
        cron_file: update-check
        state: absent

Vous avez automatisé avec succès la gestion des services, la planification des tâches et la configuration du système à l'aide d'Ansible, fournissant ainsi la base pour maintenir et surveiller automatiquement votre infrastructure.

Automatiser la gestion du stockage avec LVM et les systèmes de fichiers

Dans cette étape, vous apprendrez à automatiser la gestion du stockage à l'aide d'Ansible pour créer des volumes physiques LVM, des groupes de volumes, des volumes logiques et des systèmes de fichiers. Ceci est crucial pour gérer les ressources de stockage sur votre infrastructure de manière cohérente et évolutive.

Vous utiliserez des modules tels que ansible.builtin.lvg pour la gestion des groupes de volumes, ansible.builtin.lvol pour la création de volumes logiques, ansible.builtin.filesystem pour la création de systèmes de fichiers, et ansible.posix.mount pour la gestion des points de montage.

Naviguez vers un nouveau répertoire de projet pour la gestion du stockage.
```
cd ~/project
mkdir system-storage
cd system-storage
```

Créez le fichier d'inventaire pour cet exercice.

cat << EOF > inventory.ini
[webservers]
localhost ansible_connection=local
EOF

Créez un périphérique de boucle (loop device) pour simuler un stockage supplémentaire, car nous travaillons dans un environnement virtuel.

## Create a 1GB file to use as a virtual disk
sudo dd if=/dev/zero of=/tmp/virtual_disk bs=1M count=1024

## Set up loop device
sudo losetup /dev/loop0 /tmp/virtual_disk

## Verify the loop device
lsblk | grep loop0

Créez un playbook complet de gestion du stockage. Ceci démontrera les opérations LVM et la gestion des systèmes de fichiers.

nano storage.yml

Ajoutez le contenu suivant :

---
- name: Configure LVM storage and filesystems
  hosts: webservers
  become: true
  vars:
    storage_device: /dev/loop0
    volume_group: apache-vg
    content_lv: content-lv
    logs_lv: logs-lv
    backup_lv: backup-lv
  tasks:
    - name: Install LVM utilities
      ansible.builtin.dnf:
        name: lvm2
        state: present

    - name: Create physical volume
      community.general.lvg:
        vg: "{{ volume_group }}"
        pvs: "{{ storage_device }}"
        state: present

    - name: Create logical volume for web content
      community.general.lvol:
        vg: "{{ volume_group }}"
        lv: "{{ content_lv }}"
        size: 256m
        state: present

    - name: Create logical volume for logs
      community.general.lvol:
        vg: "{{ volume_group }}"
        lv: "{{ logs_lv }}"
        size: 256m
        state: present

    - name: Create logical volume for backup
      community.general.lvol:
        vg: "{{ volume_group }}"
        lv: "{{ backup_lv }}"
        size: 256m
        state: present

    - name: Create XFS filesystem on content volume
      community.general.filesystem:
        fstype: xfs
        dev: "/dev/{{ volume_group }}/{{ content_lv }}"
        force: no

    - name: Create XFS filesystem on logs volume
      community.general.filesystem:
        fstype: xfs
        dev: "/dev/{{ volume_group }}/{{ logs_lv }}"
        force: no

    - name: Create ext4 filesystem on backup volume
      community.general.filesystem:
        fstype: ext4
        dev: "/dev/{{ volume_group }}/{{ backup_lv }}"
        force: no

    - name: Create mount points
      ansible.builtin.file:
        path: "{{ item }}"
        state: directory
        mode: "0755"
      loop:
        - /var/www
        - /var/log/httpd
        - /backup

    - name: Mount web content volume
      ansible.posix.mount:
        path: /var/www
        src: "/dev/{{ volume_group }}/{{ content_lv }}"
        fstype: xfs
        opts: defaults
        state: mounted

    - name: Mount logs volume
      ansible.posix.mount:
        path: /var/log/httpd
        src: "/dev/{{ volume_group }}/{{ logs_lv }}"
        fstype: xfs
        opts: defaults
        state: mounted

    - name: Mount backup volume
      ansible.posix.mount:
        path: /backup
        src: "/dev/{{ volume_group }}/{{ backup_lv }}"
        fstype: ext4
        opts: defaults
        state: mounted

    - name: Set appropriate ownership for web content
      ansible.builtin.file:
        path: /var/www
        owner: apache
        group: apache
        recurse: yes

    - name: Set appropriate ownership for httpd logs
      ansible.builtin.file:
        path: /var/log/httpd
        owner: apache
        group: apache
        recurse: yes

    - name: Create html directory for web content
      ansible.builtin.file:
        path: /var/www/html
        state: directory
        owner: apache
        group: apache
        mode: "0755"

    - name: Create sample web content
      ansible.builtin.copy:
        content: |
          <html>
          <head><title>Storage Management Demo</title></head>
          <body>
          <h1>LVM Storage Configuration</h1>
          <p>This content is served from an LVM logical volume managed by Ansible.</p>
          <p>Volume Group: {{ volume_group }}</p>
          <p>Logical Volume: {{ content_lv }}</p>
          <p>Filesystem: XFS</p>
          </body>
          </html>
        dest: /var/www/html/storage.html
        owner: apache
        group: apache
        mode: "0644"

Installez la collection Ansible requise pour la gestion LVM.
```
ansible-galaxy collection install community.general
```
Exécutez le playbook de gestion du stockage.
```
ansible-playbook -i inventory.ini storage.yml
```
Ceci créera la structure LVM, les systèmes de fichiers et les points de montage.

Créez un playbook pour collecter et afficher les informations de stockage.

nano get-storage.yml

Ajoutez le contenu suivant :

---
- name: Gather storage information
  hosts: webservers
  become: true
  tasks:
    - name: Gather disk facts
      ansible.builtin.setup:
        gather_subset:
          - hardware

    - name: Display volume group information
      ansible.builtin.command:
        cmd: vgdisplay apache-vg
      register: vg_info
      changed_when: false

    - name: Display logical volume information
      ansible.builtin.command:
        cmd: lvdisplay apache-vg
      register: lv_info
      changed_when: false

    - name: Display filesystem information
      ansible.builtin.command:
        cmd: df -h /var/www /var/log/httpd /backup
      register: fs_info
      changed_when: false

    - name: Display mount information
      ansible.builtin.command:
        cmd: cat /proc/mounts
      register: mount_info
      changed_when: false

    - name: Show volume group details
      ansible.builtin.debug:
        var: vg_info.stdout_lines

    - name: Show logical volume details
      ansible.builtin.debug:
        var: lv_info.stdout_lines

    - name: Show filesystem usage
      ansible.builtin.debug:
        var: fs_info.stdout_lines

    - name: Show fstab entries
      ansible.builtin.command:
        cmd: grep apache-vg /etc/fstab
      register: fstab_entries
      changed_when: false
      failed_when: false

    - name: Display fstab entries
      ansible.builtin.debug:
        var: fstab_entries.stdout_lines

Exécutez le playbook de collecte d'informations de stockage.
```
ansible-playbook -i inventory.ini get-storage.yml
```
Ceci affichera des informations détaillées sur la structure de stockage créée.

Vérifiez la configuration du stockage manuellement.

## Check LVM structure
sudo vgs apache-vg
sudo lvs apache-vg
sudo pvs /dev/loop0

## Check filesystems
df -h /var/www /var/log/httpd /backup

## Check mount points
mount | grep apache-vg

## Check fstab entries
grep apache-vg /etc/fstab

## Test the web content
cat /var/www/html/storage.html

Créez un playbook d'extension de stockage pour démontrer les opérations de mise à l'échelle.

nano expand_storage.yml

Ajoutez le contenu suivant :

---
- name: Expand storage volumes
  hosts: webservers
  become: true
  vars:
    volume_group: apache-vg
    content_lv: content-lv
  tasks:
    - name: Extend content logical volume
      community.general.lvol:
        vg: "{{ volume_group }}"
        lv: "{{ content_lv }}"
        size: 400m
        state: present

    - name: Extend XFS filesystem
      community.general.filesystem:
        fstype: xfs
        dev: "/dev/{{ volume_group }}/{{ content_lv }}"
        resizefs: yes

    - name: Display updated filesystem size
      ansible.builtin.command:
        cmd: df -h /var/www
      register: new_size
      changed_when: false

    - name: Show new filesystem size
      ansible.builtin.debug:
        var: new_size.stdout_lines

Testez l'extension du stockage.

## Check current size before expansion
df -h /var/www

## Run the expansion playbook
ansible-playbook -i inventory.ini expand_storage.yml

## Verify the expansion
df -h /var/www
sudo lvs apache-vg/content-lv

Vous avez automatisé avec succès la gestion du stockage LVM, y compris la création de volumes physiques, la gestion des volumes logiques, la création de systèmes de fichiers et la configuration des points de montage à l'aide d'Ansible.

Automatiser la configuration réseau et la collecte d'informations

Dans cette dernière étape, vous apprendrez à automatiser la configuration des interfaces réseau et à collecter des informations système complètes à l'aide d'Ansible. Cela complète le spectre complet de l'automatisation de l'administration système, du logiciel au stockage en passant par le réseau.

Vous utiliserez des modules tels que ansible.builtin.template pour les fichiers de configuration réseau, la collecte des faits réseau et la création de rapports système complets.

Naviguez vers un nouveau répertoire de projet pour la gestion du réseau.
```
cd ~/project
mkdir system-network
cd system-network
```

Créez le fichier d'inventaire pour cet exercice.

cat << EOF > inventory.ini
[webservers]
localhost ansible_connection=local
EOF

Créez un playbook complet de collecte d'informations réseau et système.

nano network_info.yml

Ajoutez le contenu suivant :

---
- name: Gather comprehensive system information
  hosts: webservers
  become: true
  tasks:
    - name: Gather all system facts
      ansible.builtin.setup:

    - name: Create system report directory
      ansible.builtin.file:
        path: /tmp/system_reports
        state: directory
        mode: "0755"

    - name: Generate system information report
      ansible.builtin.template:
        src: system_report.j2
        dest: /tmp/system_reports/system_info_{{ ansible_facts['hostname'] }}.html
        mode: "0644"

    - name: Generate network configuration report
      ansible.builtin.template:
        src: network_report.j2
        dest: /tmp/system_reports/network_info_{{ ansible_facts['hostname'] }}.html
        mode: "0644"

    - name: Collect network interface information
      ansible.builtin.command:
        cmd: ip addr show
      register: ip_info
      changed_when: false

    - name: Collect routing information
      ansible.builtin.command:
        cmd: ip route show
      register: route_info
      changed_when: false

    - name: Collect DNS configuration
      ansible.builtin.command:
        cmd: cat /etc/resolv.conf
      register: dns_info
      changed_when: false

    - name: Display network summary
      ansible.builtin.debug:
        msg: |
          System: {{ ansible_facts['hostname'] }}
          OS: {{ ansible_facts['distribution'] }} {{ ansible_facts['distribution_version'] }}
          Kernel: {{ ansible_facts['kernel'] }}
          Default IPv4: {{ ansible_facts['default_ipv4']['address'] | default('N/A') }}
          Default Interface: {{ ansible_facts['default_ipv4']['interface'] | default('N/A') }}
          Total Memory: {{ ansible_facts['memtotal_mb'] }}MB
          CPU Cores: {{ ansible_facts['processor_vcpus'] }}

Créez les répertoires et fichiers de modèles pour les rapports.

mkdir templates
nano templates/system_report.j2

Ajoutez le contenu suivant pour le modèle de rapport système :

<!doctype html>
<html>
  <head>
    <title>System Report - {{ ansible_facts['hostname'] }}</title>
    <style>
      body {
        font-family: Arial, sans-serif;
        margin: 20px;
      }
      .section {
        margin-bottom: 20px;
        padding: 10px;
        border: 1px solid #ccc;
      }
      .header {
        background-color: #f5f5f5;
        padding: 10px;
      }
      table {
        border-collapse: collapse;
        width: 100%;
      }
      th,
      td {
        border: 1px solid #ddd;
        padding: 8px;
        text-align: left;
      }
      th {
        background-color: #f2f2f2;
      }
    </style>
  </head>
  <body>
    <div class="header">
      <h1>System Report for {{ ansible_facts['hostname'] }}</h1>
      <p>
        Generated on: {{ ansible_date_time.date }} {{ ansible_date_time.time
        }}
      </p>
    </div>

    <div class="section">
      <h2>System Information</h2>
      <table>
        <tr>
          <th>Property</th>
          <th>Value</th>
        </tr>
        <tr>
          <td>Hostname</td>
          <td>{{ ansible_facts['hostname'] }}</td>
        </tr>
        <tr>
          <td>FQDN</td>
          <td>{{ ansible_facts['fqdn'] }}</td>
        </tr>
        <tr>
          <td>Operating System</td>
          <td>
            {{ ansible_facts['distribution'] }} {{
            ansible_facts['distribution_version'] }}
          </td>
        </tr>
        <tr>
          <td>Kernel</td>
          <td>{{ ansible_facts['kernel'] }}</td>
        </tr>
        <tr>
          <td>Architecture</td>
          <td>{{ ansible_facts['architecture'] }}</td>
        </tr>
        <tr>
          <td>CPU Cores</td>
          <td>{{ ansible_facts['processor_vcpus'] }}</td>
        </tr>
        <tr>
          <td>Total Memory</td>
          <td>{{ ansible_facts['memtotal_mb'] }}MB</td>
        </tr>
        <tr>
          <td>Uptime</td>
          <td>{{ ansible_facts['uptime_seconds'] }} seconds</td>
        </tr>
      </table>
    </div>

    <div class="section">
      <h2>Storage Information</h2>
      <table>
        <tr>
          <th>Mount Point</th>
          <th>Filesystem</th>
          <th>Size</th>
          <th>Used</th>
          <th>Available</th>
        </tr>
        {% for mount in ansible_facts['mounts'] %}
        <tr>
          <td>{{ mount.mount }}</td>
          <td>{{ mount.fstype }}</td>
          <td>
            {{ (mount.size_total / 1024 / 1024 / 1024) | round(2) }}GB
          </td>
          <td>
            {{ ((mount.size_total - mount.size_available) / 1024 / 1024 /
            1024) | round(2) }}GB
          </td>
          <td>
            {{ (mount.size_available / 1024 / 1024 / 1024) | round(2) }}GB
          </td>
        </tr>
        {% endfor %}
      </table>
    </div>

    <div class="section">
      <h2>Services Status</h2>
      <table>
        <tr>
          <th>Service</th>
          <th>Status</th>
        </tr>
        <tr>
          <td>httpd</td>
          <td>
            {{ ansible_facts.services['httpd.service']['state'] |
            default('not installed') }}
          </td>
        </tr>
        <tr>
          <td>sshd</td>
          <td>
            {{ ansible_facts.services['sshd.service']['state'] |
            default('unknown') }}
          </td>
        </tr>
        <tr>
          <td>NetworkManager</td>
          <td>
            {{ ansible_facts.services['NetworkManager.service']['state'] |
            default('unknown') }}
          </td>
        </tr>
      </table>
    </div>
  </body>
</html>

Créez le modèle de rapport réseau.

nano templates/network_report.j2

Ajoutez le contenu suivant :

<!doctype html>
<html>
  <head>
    <title>Network Report - {{ ansible_facts['hostname'] }}</title>
    <style>
      body {
        font-family: Arial, sans-serif;
        margin: 20px;
      }
      .section {
        margin-bottom: 20px;
        padding: 10px;
        border: 1px solid #ccc;
      }
      .header {
        background-color: #f5f5f5;
        padding: 10px;
      }
      table {
        border-collapse: collapse;
        width: 100%;
      }
      th,
      td {
        border: 1px solid #ddd;
        padding: 8px;
        text-align: left;
      }
      th {
        background-color: #f2f2f2;
      }
      pre {
        background-color: #f9f9f9;
        padding: 10px;
        overflow-x: auto;
      }
    </style>
  </head>
  <body>
    <div class="header">
      <h1>Network Configuration Report</h1>
      <p>Host: {{ ansible_facts['hostname'] }}</p>
      <p>
        Generated on: {{ ansible_date_time.date }} {{ ansible_date_time.time
        }}
      </p>
    </div>

    <div class="section">
      <h2>Network Interfaces</h2>
      <table>
        <tr>
          <th>Interface</th>
          <th>IPv4 Address</th>
          <th>IPv6 Address</th>
          <th>MAC Address</th>
          <th>Status</th>
        </tr>
        {% for interface_name in ansible_facts['interfaces'] %} {% if
        interface_name != 'lo' %} {% set interface_facts =
        ansible_facts[interface_name] %}
        <tr>
          <td>{{ interface_name }}</td>
          <td>
            {{ interface_facts.get('ipv4', {}).get('address', 'N/A') }}
          </td>
          <td>
            {{ interface_facts.get('ipv6', [{}])[0].get('address', 'N/A') if
            interface_facts.get('ipv6') else 'N/A' }}
          </td>
          <td>{{ interface_facts.get('macaddress', 'N/A') }}</td>
          <td>
            {{ interface_facts.get('active', false) | ternary('Active',
            'Inactive') }}
          </td>
        </tr>
        {% endif %} {% endfor %}
      </table>
    </div>

    <div class="section">
      <h2>Default Gateway</h2>
      <table>
        <tr>
          <th>Property</th>
          <th>Value</th>
        </tr>
        <tr>
          <td>Default IPv4 Address</td>
          <td>
            {{ ansible_facts['default_ipv4']['address'] | default('N/A') }}
          </td>
        </tr>
        <tr>
          <td>Default Interface</td>
          <td>
            {{ ansible_facts['default_ipv4']['interface'] | default('N/A')
            }}
          </td>
        </tr>
        <tr>
          <td>Default Gateway</td>
          <td>
            {{ ansible_facts['default_ipv4']['gateway'] | default('N/A') }}
          </td>
        </tr>
      </table>
    </div>

    <div class="section">
      <h2>DNS Configuration</h2>
      <table>
        <tr>
          <th>DNS Servers</th>
        </tr>
        {% for dns in ansible_facts['dns']['nameservers'] %}
        <tr>
          <td>{{ dns }}</td>
        </tr>
        {% endfor %}
      </table>
    </div>
  </body>
</html>

Créez un playbook de configuration d'interface réseau.

nano configure_network.yml

Ajoutez le contenu suivant :

---
- name: Configure network settings
  hosts: webservers
  become: true
  tasks:
    - name: Install NetworkManager if not present
      ansible.builtin.dnf:
        name: NetworkManager
        state: present

    - name: Ensure NetworkManager is running
      ansible.builtin.service:
        name: NetworkManager
        state: started
        enabled: yes

    - name: Configure hosts file with system information
      ansible.builtin.lineinfile:
        path: /etc/hosts
        line: "{{ ansible_facts['default_ipv4']['address'] }} {{ ansible_facts['hostname'] }}.lab.example.com {{ ansible_facts['hostname'] }}"
        regexp: ".*{{ ansible_facts['hostname'] }}.*"
        backup: yes

    - name: Create network monitoring script
      ansible.builtin.copy:
        content: |
          #!/bin/bash
          ## Network monitoring script generated by Ansible
          echo "=== Network Status Report ==="
          echo "Generated at: $(date)"
          echo
          echo "=== Interface Status ==="
          ip addr show
          echo
          echo "=== Routing Table ==="
          ip route show
          echo
          echo "=== DNS Configuration ==="
          cat /etc/resolv.conf
          echo
          echo "=== Network Connectivity Test ==="
          ping -c 3 8.8.8.8
        dest: /usr/local/bin/network-status.sh
        mode: "0755"

    - name: Create network information gathering cron job
      ansible.builtin.cron:
        name: Network status monitoring
        job: "/usr/local/bin/network-status.sh >> /var/log/network-status.log 2>&1"
        minute: "*/15"
        user: root
        cron_file: network-monitoring
        state: present

Exécutez le playbook de collecte d'informations réseau.
```
ansible-playbook -i inventory.ini network_info.yml
```
Ceci générera des rapports système et réseau complets.
Exécutez le playbook de configuration réseau.
```
ansible-playbook -i inventory.ini configure_network.yml
```
Ceci configurera les paramètres réseau et la surveillance.

Visualisez les rapports générés.

## List generated reports
ls -la /tmp/system_reports/

## View the system report (you can also open in a browser)
cat /tmp/system_reports/system_info_*.html

## Check the network monitoring script
cat /usr/local/bin/network-status.sh

## Test the network monitoring script
sudo /usr/local/bin/network-status.sh

## Check the network monitoring cron job
sudo cat /etc/cron.d/network-monitoring

Créez un playbook complet final qui combine tous les concepts appris.

nano complete_system_setup.yml

Ajoutez le contenu suivant :

---
- name: Complete system setup and configuration
  hosts: webservers
  become: true
  vars:
    admin_users:
      - webuser1
      - webuser2
  tasks:
    - name: Ensure all required packages are installed
      ansible.builtin.dnf:
        name:
          - httpd
          - lvm2
          - NetworkManager
          - cronie
        state: present

    - name: Ensure all services are running
      ansible.builtin.service:
        name: "{{ item }}"
        state: started
        enabled: yes
      loop:
        - httpd
        - NetworkManager
        - crond

    - name: Generate final system status report
      ansible.builtin.template:
        src: system_report.j2
        dest: /tmp/final_system_report.html
        mode: "0644"

    - name: Display completion message
      ansible.builtin.debug:
        msg: |
          ============================================
          RHEL System Administration Automation Complete!
          ============================================

          Summary of configured components:
          - Software: EPEL repository and packages installed
          - Users: {{ admin_users | length }} administrative users created
          - Services: httpd, NetworkManager, and crond configured
          - Storage: LVM volumes and filesystems configured
          - Network: Interface configuration and monitoring set up
          - Scheduling: Cron jobs and at tasks configured

          Reports available at:
          - /tmp/system_reports/
          - /tmp/final_system_report.html

          Your RHEL system is now fully automated with Ansible!

Exécutez la configuration complète finale.

ansible-playbook -i inventory.ini complete_system_setup.yml

Vous avez automatisé avec succès les tâches d'administration système RHEL de manière complète à l'aide d'Ansible, couvrant la gestion des logiciels, l'administration des utilisateurs, la gestion des services, la configuration du stockage et la mise en place du réseau.

Prévisualisez les rapports générés dans un navigateur web.

Naviguez vers le répertoire des rapports :
```
cd /tmp/system_reports
```
Démarrez un serveur web temporaire à l'aide de Python :
```
python -m http.server 8000
```
Pour prévisualiser les rapports dans votre navigateur :
1. Cliquez sur le bouton + dans la barre de menu supérieure
2. Sélectionnez Web Service
3. Entrez le numéro de port 8000
4. Vous pouvez maintenant afficher les rapports HTML générés en ligne
Le serveur web affichera une liste de répertoires où vous pourrez cliquer sur les fichiers HTML pour visualiser les rapports système et réseau complets générés par vos playbooks Ansible.

Note: Appuyez sur Ctrl+C pour arrêter le serveur web une fois que vous avez terminé de visualiser les rapports.

Résumé

Dans ce laboratoire complet, vous avez maîtrisé l'automatisation des tâches d'administration essentielles de Red Hat Enterprise Linux (RHEL) à l'aide d'Ansible. Vous avez commencé par la gestion des paquets logiciels, en apprenant à configurer les dépôts, à gérer les clés GPG et à installer des paquets tout en collectant des informations système via les faits des paquets. Cela a fourni la base pour un déploiement logiciel cohérent sur votre infrastructure.

Vous avez ensuite abordé la gestion des utilisateurs et l'authentification, où vous avez automatisé la création de comptes utilisateurs, configuré l'authentification par clé SSH, mis en place des privilèges sudo et renforcé les configurations SSH. Cela a établi des politiques d'accès utilisateur sécurisées et standardisées, cruciales pour les environnements d'entreprise.

Le laboratoire s'est poursuivi avec la gestion des services et la planification des tâches, où vous avez appris à gérer les services systemd, à créer des tâches cron récurrentes, à planifier des tâches uniques avec at et à configurer les cibles de démarrage du système. Ces compétences sont essentielles pour maintenir la disponibilité des services et automatiser les tâches de maintenance de routine.

La gestion du stockage a été abordée par une automatisation LVM complète, comprenant la création de volumes physiques, la gestion des groupes de volumes, le provisionnement de volumes logiques, la création de systèmes de fichiers et la configuration des points de montage. Vous avez également appris à étendre dynamiquement les volumes de stockage, ce qui est essentiel pour la gestion d'une infrastructure évolutive.

Enfin, vous avez terminé l'automatisation de la configuration réseau et la surveillance complète du système. Vous avez appris à collecter les faits réseau, à configurer les interfaces, à créer des rapports système détaillés à l'aide de modèles Jinja2 et à mettre en place des scripts de surveillance automatisés. Cela a fourni une vue complète de la gestion de l'état du système et de la génération de rapports.

Tout au long de ce laboratoire, vous avez appliqué les principes de l'Infrastructure as Code (IaC), garantissant que toutes les configurations système sont reproductibles, contrôlées par version et déployables de manière cohérente. Vous possédez désormais les compétences nécessaires pour automatiser le cycle de vie complet de l'administration système RHEL, du déploiement initial à la maintenance et à la surveillance continues.

Automatiser les tâches d'administration RHEL avec Ansible

Introduction

Configurer le dépôt et gérer les paquets logiciels

Automatiser la gestion des utilisateurs et la configuration SSH

Automatiser la gestion des services et la planification des tâches

Automatiser la gestion du stockage avec LVM et les systèmes de fichiers

Automatiser la configuration réseau et la collecte d'informations

Résumé