RHEL-Administrationsaufgaben mit Ansible automatisieren

Einleitung

In diesem umfassenden Labor meistern Sie die Automatisierung kritischer Linux-Administrationsaufgaben mit Ansible. Aufbauend auf Ihren Grundlagen im Dateimanagement erkunden Sie nun, wie Sie den vollständigen Lebenszyklus der Systemadministration verwalten, von der Softwareinstallation bis zur Benutzerverwaltung, Dienstkonfiguration, Speicherbereitstellung und Netzwerkeinrichtung.

Sie beginnen mit der Automatisierung der Softwarepaketverwaltung und Repository-Konfiguration mithilfe von Modulen wie ansible.builtin.dnf, ansible.builtin.yum_repository und ansible.builtin.rpm_key. Als Nächstes erstellen und verwalten Sie Benutzerkonten, konfigurieren den SSH-Zugriff und richten Sudo-Berechtigungen ein. Das Labor schreitet zur Dienstverwaltung, geplanten Aufgaben mit Cron und Systemd fort, bevor es zur Speicherverwaltung mit LVM und Dateisystemoperationen übergeht. Abschließend konfigurieren Sie Netzwerkschnittstellen und sammeln Systeminformationen.

Dieses Labor betont reale Szenarien, die häufig in Unternehmens-Linux-Umgebungen anzutreffen sind, und bereitet Sie darauf vor, Infrastructure as Code (IaC) Praktiken effektiv zu implementieren.

Repository konfigurieren und Softwarepakete verwalten

In diesem Schritt lernen Sie, wie Sie die Softwarepaketverwaltung auf RHEL-Systemen mit Ansible automatisieren. Sie konfigurieren ein Yum-Repository, verwalten RPM-GPG-Schlüssel und sammeln Paketinformationen auf verwalteten Hosts. Dies ist unerlässlich, um konsistente Softwareinstallationen in Ihrer Infrastruktur aufrechtzuerhalten.

Sie werden mehrere Schlüsselmodule verwenden: ansible.builtin.yum_repository für die Repository-Verwaltung, ansible.builtin.rpm_key für die GPG-Schlüsselverwaltung, ansible.builtin.package_facts zum Sammeln von Paketinformationen und ansible.builtin.dnf für die Paketinstallation.

1. Richten Sie zunächst die Projektumgebung ein und installieren Sie Ansible.

   Installieren Sie das Paket ansible-core und navigieren Sie zum Projektverzeichnis.

   sudo dnf install -y ansible-core
   cd ~/project
   mkdir system-software
   cd system-software

2. Erstellen Sie eine Ansible-Inventardatei, um unsere verwalteten Hosts zu definieren. Für dieses Labor verwalten wir die lokale Maschine.

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

3. Erstellen Sie das Haupt-Playbook repo_playbook.yml, das die Repository-Konfiguration und die Paketinstallation verwaltet. Dieses Playbook demonstriert einen vollständigen Workflow zur Softwareverwaltung.

   nano repo_playbook.yml

   Fügen Sie den folgenden Inhalt hinzu, um ein umfassendes Playbook zur Softwareverwaltung zu erstellen:

   ---
   - name: Repository-Konfiguration und Softwareverwaltung
     hosts: all
     become: true
     vars:
       custom_pkg: httpd
     tasks:
       - name: Paketinformationen sammeln
         ansible.builtin.package_facts:
           manager: auto
   
       - name: Paketinformationen für das benutzerdefinierte Paket anzeigen (erste Prüfung)
         ansible.builtin.debug:
           var: ansible_facts['packages'][custom_pkg]
         when: custom_pkg in ansible_facts['packages']
   
       - name: Sicherstellen, dass das EPEL-Repository konfiguriert ist
         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: EPEL GPG-Schlüssel importieren
         ansible.builtin.rpm_key:
           state: present
           key: https://download.fedoraproject.org/pub/epel/RPM-GPG-KEY-EPEL-9
   
       - name: Das benutzerdefinierte Paket installieren
         ansible.builtin.dnf:
           name: "{{ custom_pkg }}"
           state: present
   
       - name: Paketinformationen sammeln (nach der Installation)
         ansible.builtin.package_facts:
           manager: auto
   
       - name: Paketinformationen für das benutzerdefinierte Paket anzeigen (nach der Installation)
         ansible.builtin.debug:
           var: ansible_facts['packages'][custom_pkg]
         when: custom_pkg in ansible_facts['packages']
   
       - name: Installierte Paketversion anzeigen
         ansible.builtin.debug:
           msg: "{{ custom_pkg }} Version {{ ansible_facts['packages'][custom_pkg][0]['version'] }} ist installiert"
         when: custom_pkg in ansible_facts['packages']

   Hinweis: Die Konfigurationsdatei in diesem Labor ist recht umfangreich, daher geben wir hier keine detaillierten Erklärungen, um die Dokumentation kurz zu halten. Wenn Sie Klärungsbedarf zu einem Teil haben, klicken Sie auf die Schaltfläche "Code erklären" in der unteren linken Ecke des Codeblocks, um detaillierte Erklärungen von Labby zu erhalten.

   Dieses Playbook demonstriert mehrere wichtige Konzepte:

   • Sammeln von Paketinformationen: Zeigt, wie Informationen über installierte Pakete gesammelt werden
   • Repository-Verwaltung: Konfiguriert das EPEL-Repository mit ordnungsgemäßer GPG-Validierung
   • GPG-Schlüsselverwaltung: Importiert den GPG-Schlüssel des Repositories zur Sicherheit
   • Paketinstallation: Installiert das angegebene Paket mit dem dnf-Modul
   • Verifizierung: Bestätigt die Paketinstallation mit aktualisierten Informationen

4. Führen Sie das Playbook aus, um den vollständigen Workflow zur Softwareverwaltung in Aktion zu sehen.

   ansible-playbook -i inventory.ini repo_playbook.yml

   Sie sollten eine Ausgabe sehen, die Folgendes anzeigt:

   • Erste Paketprüfung (wahrscheinlich übersprungen, da httpd nicht installiert ist)
   • Repository-Konfiguration
   • GPG-Schlüsselimport
   • Paketinstallation
   • Endgültige Verifizierung, die das installierte Paket anzeigt

5. Überprüfen Sie die Repository-Konfiguration, indem Sie die erstellte Repository-Datei überprüfen.

   cat /etc/yum.repos.d/epel.repo

   Sie sollten die EPEL-Repository-Konfiguration mit den Einstellungen für baseurl, gpgcheck und gpgkey sehen.

6. Testen Sie die Idempotenz der Paketverwaltung, indem Sie das Playbook erneut ausführen.

   ansible-playbook -i inventory.ini repo_playbook.yml

   Beachten Sie, dass Ansible für Aufgaben, die keine Änderungen erfordern, "ok" meldet, was die Idempotenz demonstriert.

Sie haben die Softwarepaketverwaltung, einschließlich Repository-Konfiguration, GPG-Schlüsselverwaltung und Verifizierung der Paketinstallation, erfolgreich mit Ansible automatisiert.

Benutzerverwaltung und SSH-Konfiguration automatisieren

In diesem Schritt lernen Sie, wie Sie die Benutzerkontenverwaltung, die SSH-Konfiguration und Sudo-Berechtigungen mit Ansible automatisieren. Dies ist entscheidend für die Aufrechterhaltung konsistenter Benutzerzugriffs- und Sicherheitspraktiken in Ihrer Infrastruktur.

Sie werden Module wie ansible.builtin.user für die Benutzerverwaltung, ansible.builtin.group für die Gruppenerstellung, ansible.posix.authorized_key für die SSH-Schlüsselverwaltung und ansible.builtin.lineinfile für die Modifikation von Konfigurationsdateien verwenden.

1. Navigieren Sie zu einem neuen Projektverzeichnis für die Benutzerverwaltungsaufgaben.

   cd ~/project
   mkdir system-users
   cd system-users

   Installieren Sie die Sammlung ansible.posix.

   ansible-galaxy collection install ansible.posix

2. Erstellen Sie die Inventardatei für diese Übung.

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

3. Erstellen Sie eine Variablen-Datei, um die Benutzer und Gruppen zu definieren, die wir verwalten möchten.

   mkdir vars
   nano vars/users_vars.yml

   Fügen Sie den folgenden Inhalt hinzu, um Benutzerkonten und ihre Gruppenzugehörigkeiten zu definieren:

   ---
   users:
     - username: webuser1
       groups: webadmin
     - username: webuser2
       groups: webadmin
     - username: devuser1
       groups: webadmin

4. Generieren Sie SSH-Schlüsselpaare für unsere Benutzer. In einer realen Umgebung würden Benutzer ihre öffentlichen Schlüssel bereitstellen.

   mkdir files
   
   ## SSH-Schlüssel für jeden Benutzer generieren
   ssh-keygen -t rsa -b 2048 -f files/webuser1.key -N "" -C "[email protected]"
   ssh-keygen -t rsa -b 2048 -f files/webuser2.key -N "" -C "[email protected]"
   ssh-keygen -t rsa -b 2048 -f files/devuser1.key -N "" -C "[email protected]"

5. Erstellen Sie das Haupt-Playbook zur Benutzerverwaltung users.yml. Dieses Playbook erstellt Gruppen, Benutzer, verteilt SSH-Schlüssel und konfiguriert den Sudo-Zugriff.

   nano users.yml

   Fügen Sie das folgende umfassende Playbook zur Benutzerverwaltung hinzu:

   ---
   - name: Benutzerkonten erstellen und verwalten
     hosts: webservers
     become: true
     vars_files:
       - vars/users_vars.yml
     tasks:
       - name: webadmin-Gruppe erstellen
         ansible.builtin.group:
           name: webadmin
           state: present
   
       - name: Benutzerkonten erstellen
         ansible.builtin.user:
           name: "{{ item['username'] }}"
           groups: "{{ item['groups'] }}"
           shell: /bin/bash
           create_home: yes
           state: present
         loop: "{{ users }}"
   
       - name: SSH-autorisierte Schlüssel einrichten
         ansible.posix.authorized_key:
           user: "{{ item['username'] }}"
           key: "{{ lookup('file', 'files/' + item['username'] + '.key.pub') }}"
           state: present
         loop: "{{ users }}"
   
       - name: Sudo-Zugriff für die webadmin-Gruppe konfigurieren
         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: SSH so konfigurieren, dass Root-Login deaktiviert wird
         ansible.builtin.lineinfile:
           dest: /etc/ssh/sshd_config
           regexp: "^PermitRootLogin"
           line: "PermitRootLogin no"
           backup: yes
         notify: restart sshd
   
       - name: SSH so konfigurieren, dass die Passwortauthentifizierung deaktiviert wird
         ansible.builtin.lineinfile:
           dest: /etc/ssh/sshd_config
           regexp: "^PasswordAuthentication"
           line: "PasswordAuthentication no"
           backup: yes
         notify: restart sshd
   
     handlers:
       - name: sshd neu starten
         ansible.builtin.service:
           name: sshd
           state: restarted

   Dieses Playbook demonstriert mehrere Best Practices für die Benutzerverwaltung:

   • Gruppenverwaltung: Erstellt administrative Gruppen
   • Benutzererstellung: Richtet Benutzerkonten mit ordnungsgemäßen Home-Verzeichnissen ein
   • SSH-Schlüsselverwaltung: Verteilt öffentliche Schlüssel für die schlüsselbasierte Authentifizierung
   • Sudo-Konfiguration: Gewährt administrative Berechtigungen sicher
   • SSH-Härtung: Deaktiviert Root-Login und Passwortauthentifizierung
   • Dienstverwaltung: Startet den SSH-Dienst nach Konfigurationsänderungen neu

6. Führen Sie das Playbook zur Benutzerverwaltung aus.

   ansible-playbook -i inventory.ini users.yml

   Das Playbook erstellt Benutzer, richtet SSH-Schlüssel ein, konfiguriert den Sudo-Zugriff und härtet die SSH-Konfiguration ab.

7. Überprüfen Sie die Benutzererstellung und die Gruppenzugehörigkeit.

   ## Prüfen, ob Benutzer erstellt wurden
   getent passwd webuser1 webuser2 devuser1
   
   ## Gruppenzugehörigkeit prüfen
   groups webuser1
   groups webuser2
   groups devuser1
   
   ## Prüfen, ob die webadmin-Gruppe existiert
   getent group webadmin

8. Testen Sie die SSH-Schlüsselauthentifizierung für einen der erstellten Benutzer.

   ## Testen der SSH-Schlüsselauthentifizierung (dies verbindet sich mit localhost)
   ssh -i files/webuser1.key webuser1@localhost "whoami"

9. Überprüfen Sie die Sudo-Konfiguration, indem Sie den passwortlosen Sudo-Zugriff testen.

   ## Testen des Sudo-Zugriffs für webuser1
   ssh -i files/webuser1.key webuser1@localhost "sudo whoami"

10. Überprüfen Sie die Änderungen an der SSH-Konfiguration.

    ## SSH-Konfiguration überprüfen
    sudo grep "PermitRootLogin\|PasswordAuthentication" /etc/ssh/sshd_config
    
    ## Sudo-Konfiguration überprüfen
    sudo cat /etc/sudoers.d/webadmin

Sie haben die Erstellung von Benutzerkonten, die Verteilung von SSH-Schlüsseln und die Sicherheitskonfiguration erfolgreich mit Ansible automatisiert und damit eine Grundlage für eine sichere Benutzerverwaltung in Ihrer Infrastruktur geschaffen.

Dienstverwaltung und Aufgabenplanung automatisieren

In diesem Schritt lernen Sie, wie Sie systemd-Dienste verwalten, Cron-Jobs planen und System-Boot-Targets konfigurieren mit Ansible. Dies ist unerlässlich, um die Verfügbarkeit von Diensten aufrechtzuerhalten und Routineaufgaben in Ihrer Infrastruktur zu automatisieren.

Sie werden Module wie ansible.builtin.service für die Dienstverwaltung, ansible.builtin.cron für die Aufgabenplanung, ansible.posix.at für einmalige Aufgaben und ansible.builtin.systemd für die Verwaltung von System-Targets verwenden.

1. Navigieren Sie zu einem neuen Projektverzeichnis für die Dienst- und Prozessverwaltung.

   cd ~/project
   mkdir system-process
   cd system-process

2. Erstellen Sie die Inventardatei für diese Übung.

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

3. Erstellen Sie ein Playbook zur Verwaltung des Apache HTTP Server-Dienstes. Dies demonstriert die grundlegende Dienstverwaltung.

   nano service_management.yml

   Fügen Sie den folgenden Inhalt hinzu:

   ---
   - name: Apache HTTP Server Dienst verwalten
     hosts: webservers
     become: true
     tasks:
       - name: httpd Dienst starten und aktivieren
         ansible.builtin.service:
           name: httpd
           state: started
           enabled: yes
   
       - name: Eine einfache index.html erstellen
         ansible.builtin.copy:
           content: |
             <html>
             <head><title>Ansible Managed Server</title></head>
             <body>
             <h1>Willkommen auf dem von Ansible verwalteten Apache Server</h1>
             <p>Dieser Server wird von Ansible konfiguriert und verwaltet.</p>
             <p>Dienst gestartet um: $(date)</p>
             </body>
             </html>
           dest: /var/www/html/index.html
           owner: apache
           group: apache
           mode: "0644"
   
       - name: Überprüfen, ob der httpd Dienst läuft
         ansible.builtin.service_facts:
   
       - name: httpd Dienststatus anzeigen
         ansible.builtin.debug:
           var: ansible_facts.services['httpd.service']

4. Erstellen Sie ein Playbook zur Planung von Cron-Jobs. Dies demonstriert die automatisierte Aufgabenplanung.

   nano create_crontab_file.yml

   Fügen Sie den folgenden Inhalt hinzu:

   ---
   - name: Wiederkehrende Cron-Jobs planen
     hosts: webservers
     become: true
     tasks:
       - name: labex Benutzer für Cron-Jobs erstellen
         ansible.builtin.user:
           name: labex
           state: present
           create_home: yes
   
       - name: Systemüberwachungs-Cron-Job planen
         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: Tägliche Log-Bereinigung planen
         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: Wöchentliche Systemupdate-Prüfung planen
         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

5. Erstellen Sie ein Playbook zur einmaligen Aufgabenplanung mit at.

   nano schedule_at_task.yml

   Fügen Sie den folgenden Inhalt hinzu:

   ---
   - name: Einmalige Aufgaben mit at planen
     hosts: webservers
     become: true
     become_user: labex
     tasks:
       - name: Sofortige Sammlung von Systeminformationen planen
         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: Verzögerte Prüfung des Dienststatus planen
         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

6. Erstellen Sie ein Playbook zur Verwaltung von System-Boot-Targets.

   nano boot_target_management.yml

   Fügen Sie den folgenden Inhalt hinzu:

   ---
   - name: System-Boot-Targets verwalten
     hosts: webservers
     become: true
     tasks:
       - name: Aktuelles Standard-Target prüfen
         ansible.builtin.command:
           cmd: systemctl get-default
         register: current_target
         changed_when: false
   
       - name: Aktuelles Boot-Target anzeigen
         ansible.builtin.debug:
           msg: "Aktuelles Standard-Boot-Target: {{ current_target.stdout }}"
   
       - name: Standard-Boot-Target auf Multi-User setzen
         ansible.builtin.systemd:
           name: multi-user.target
           enabled: yes
         when: current_target.stdout != "multi-user.target"
   
       - name: Die Änderung des Boot-Targets überprüfen
         ansible.builtin.command:
           cmd: systemctl get-default
         register: new_target
         changed_when: false
   
       - name: Neues Boot-Target anzeigen
         ansible.builtin.debug:
           msg: "Neues Standard-Boot-Target: {{ new_target.stdout }}"

7. Führen Sie das Playbook zur Dienstverwaltung aus.

   ansible-playbook -i inventory.ini service_management.yml

   Dies startet den httpd-Dienst und erstellt eine Willkommensseite.

8. Führen Sie das Playbook zur Planung von Cron-Jobs aus.

   ansible-playbook -i inventory.ini create_crontab_file.yml

   Dies erstellt mehrere geplante Aufgaben für die Systemüberwachung und -wartung.

9. Führen Sie das Playbook zur einmaligen Aufgabenplanung aus.

   ansible-playbook -i inventory.ini schedule_at_task.yml

   Dies plant sofortige Aufgaben mit dem at-Befehl.

10. Führen Sie das Playbook zur Verwaltung von Boot-Targets aus.

    ansible-playbook -i inventory.ini boot_target_management.yml

    Dies prüft und ändert möglicherweise das Standard-Boot-Target des Systems.

11. Überprüfen Sie die geplanten Aufgaben und Dienste.

    ## Cron-Jobs prüfen
    sudo cat /etc/cron.d/system-monitoring
    sudo cat /etc/cron.d/log-cleanup
    sudo cat /etc/cron.d/update-check
    
    ## At-Jobs prüfen
    sudo atq
    
    ## httpd Dienststatus prüfen
    sudo systemctl status httpd
    
    ## Webserver testen
    curl localhost
    
    ## Systemüberwachungsprotokoll prüfen (einige Minuten warten, damit Cron ausgeführt wird)
    sudo cat /home/labex/system_monitor.log

12. Erstellen Sie ein Bereinigungs-Playbook, um geplante Aufgaben bei Bedarf zu entfernen.

    nano remove_scheduled_tasks.yml

    Fügen Sie den folgenden Inhalt hinzu:

    ---
    - name: Geplante Aufgaben entfernen
      hosts: webservers
      become: true
      tasks:
        - name: Systemüberwachungs-Cron-Job entfernen
          ansible.builtin.cron:
            name: System monitoring log
            user: labex
            cron_file: system-monitoring
            state: absent
    
        - name: Log-Bereinigungs-Cron-Job entfernen
          ansible.builtin.cron:
            name: Daily log cleanup
            user: labex
            cron_file: log-cleanup
            state: absent
    
        - name: Update-Prüfungs-Cron-Job entfernen
          ansible.builtin.cron:
            name: Weekly update check
            user: labex
            cron_file: update-check
            state: absent

Sie haben die Dienstverwaltung, Aufgabenplanung und Systemkonfiguration erfolgreich mit Ansible automatisiert und damit die Grundlage für die automatische Wartung und Überwachung Ihrer Infrastruktur geschaffen.

Speicherverwaltung mit LVM und Dateisystemen automatisieren

In diesem Schritt lernen Sie, wie Sie die Speicherverwaltung mit Ansible automatisieren, um LVM-Physische Volumes, Volume Groups, Logische Volumes und Dateisysteme zu erstellen. Dies ist entscheidend für die konsistente und skalierbare Verwaltung von Speicherressourcen in Ihrer Infrastruktur.

Sie werden Module wie ansible.builtin.lvg für die Verwaltung von Volume Groups, ansible.builtin.lvol für die Erstellung von Logischen Volumes, ansible.builtin.filesystem für die Erstellung von Dateisystemen und ansible.posix.mount für die Verwaltung von Mount-Points verwenden.

1. Navigieren Sie zu einem neuen Projektverzeichnis für die Speicherverwaltung.

   cd ~/project
   mkdir system-storage
   cd system-storage

2. Erstellen Sie die Inventardatei für diese Übung.

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

3. Erstellen Sie ein Loop-Device, um zusätzlichen Speicher zu simulieren, da wir in einer virtuellen Umgebung arbeiten.

   ## Erstellen einer 1GB-Datei zur Verwendung als virtuelles Laufwerk
   sudo dd if=/dev/zero of=/tmp/virtual_disk bs=1M count=1024
   
   ## Loop-Device einrichten
   sudo losetup /dev/loop0 /tmp/virtual_disk
   
   ## Loop-Device überprüfen
   lsblk | grep loop0

4. Erstellen Sie ein umfassendes Playbook zur Speicherverwaltung. Dies demonstriert LVM-Operationen und Dateisystemverwaltung.

   nano storage.yml

   Fügen Sie den folgenden Inhalt hinzu:

   ---
   - name: LVM-Speicher und Dateisysteme konfigurieren
     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: LVM-Dienstprogramme installieren
         ansible.builtin.dnf:
           name: lvm2
           state: present
   
       - name: Physisches Volume erstellen
         community.general.lvg:
           vg: "{{ volume_group }}"
           pvs: "{{ storage_device }}"
           state: present
   
       - name: Logisches Volume für Web-Inhalte erstellen
         community.general.lvol:
           vg: "{{ volume_group }}"
           lv: "{{ content_lv }}"
           size: 256m
           state: present
   
       - name: Logisches Volume für Logs erstellen
         community.general.lvol:
           vg: "{{ volume_group }}"
           lv: "{{ logs_lv }}"
           size: 256m
           state: present
   
       - name: Logisches Volume für Backups erstellen
         community.general.lvol:
           vg: "{{ volume_group }}"
           lv: "{{ backup_lv }}"
           size: 256m
           state: present
   
       - name: XFS-Dateisystem auf dem Content-Volume erstellen
         community.general.filesystem:
           fstype: xfs
           dev: "/dev/{{ volume_group }}/{{ content_lv }}"
           force: no
   
       - name: XFS-Dateisystem auf dem Logs-Volume erstellen
         community.general.filesystem:
           fstype: xfs
           dev: "/dev/{{ volume_group }}/{{ logs_lv }}"
           force: no
   
       - name: ext4-Dateisystem auf dem Backup-Volume erstellen
         community.general.filesystem:
           fstype: ext4
           dev: "/dev/{{ volume_group }}/{{ backup_lv }}"
           force: no
   
       - name: Mount-Points erstellen
         ansible.builtin.file:
           path: "{{ item }}"
           state: directory
           mode: "0755"
         loop:
           - /var/www
           - /var/log/httpd
           - /backup
   
       - name: Web-Content-Volume mounten
         ansible.posix.mount:
           path: /var/www
           src: "/dev/{{ volume_group }}/{{ content_lv }}"
           fstype: xfs
           opts: defaults
           state: mounted
   
       - name: Logs-Volume mounten
         ansible.posix.mount:
           path: /var/log/httpd
           src: "/dev/{{ volume_group }}/{{ logs_lv }}"
           fstype: xfs
           opts: defaults
           state: mounted
   
       - name: Backup-Volume mounten
         ansible.posix.mount:
           path: /backup
           src: "/dev/{{ volume_group }}/{{ backup_lv }}"
           fstype: ext4
           opts: defaults
           state: mounted
   
       - name: Entsprechende Berechtigungen für Web-Inhalte setzen
         ansible.builtin.file:
           path: /var/www
           owner: apache
           group: apache
           recurse: yes
   
       - name: Entsprechende Berechtigungen für httpd-Logs setzen
         ansible.builtin.file:
           path: /var/log/httpd
           owner: apache
           group: apache
           recurse: yes
   
       - name: html-Verzeichnis für Web-Inhalte erstellen
         ansible.builtin.file:
           path: /var/www/html
           state: directory
           owner: apache
           group: apache
           mode: "0755"
   
       - name: Beispiel-Web-Inhalte erstellen
         ansible.builtin.copy:
           content: |
             <html>
             <head><title>Storage Management Demo</title></head>
             <body>
             <h1>LVM Storage Configuration</h1>
             <p>Diese Inhalte werden von einem von Ansible verwalteten LVM Logical Volume bereitgestellt.</p>
             <p>Volume Group: {{ volume_group }}</p>
             <p>Logical Volume: {{ content_lv }}</p>
             <p>Dateisystem: XFS</p>
             </body>
             </html>
           dest: /var/www/html/storage.html
           owner: apache
           group: apache
           mode: "0644"

5. Installieren Sie die erforderliche Ansible-Sammlung für die LVM-Verwaltung.

   ansible-galaxy collection install community.general

6. Führen Sie das Playbook zur Speicherverwaltung aus.

   ansible-playbook -i inventory.ini storage.yml

   Dies erstellt die LVM-Struktur, Dateisysteme und Mount-Points.

7. Erstellen Sie ein Playbook zum Sammeln und Anzeigen von Speicherinformationen.

   nano get-storage.yml

   Fügen Sie den folgenden Inhalt hinzu:

   ---
   - name: Speicherinformationen sammeln
     hosts: webservers
     become: true
     tasks:
       - name: Festplatten-Fakten sammeln
         ansible.builtin.setup:
           gather_subset:
             - hardware
   
       - name: Volume Group-Informationen anzeigen
         ansible.builtin.command:
           cmd: vgdisplay apache-vg
         register: vg_info
         changed_when: false
   
       - name: Logische Volume-Informationen anzeigen
         ansible.builtin.command:
           cmd: lvdisplay apache-vg
         register: lv_info
         changed_when: false
   
       - name: Dateisysteminformationen anzeigen
         ansible.builtin.command:
           cmd: df -h /var/www /var/log/httpd /backup
         register: fs_info
         changed_when: false
   
       - name: Mount-Informationen anzeigen
         ansible.builtin.command:
           cmd: cat /proc/mounts
         register: mount_info
         changed_when: false
   
       - name: Volume Group-Details anzeigen
         ansible.builtin.debug:
           var: vg_info.stdout_lines
   
       - name: Logische Volume-Details anzeigen
         ansible.builtin.debug:
           var: lv_info.stdout_lines
   
       - name: Dateisystemnutzung anzeigen
         ansible.builtin.debug:
           var: fs_info.stdout_lines
   
       - name: fstab-Einträge anzeigen
         ansible.builtin.command:
           cmd: grep apache-vg /etc/fstab
         register: fstab_entries
         changed_when: false
         failed_when: false
   
       - name: fstab-Einträge anzeigen
         ansible.builtin.debug:
           var: fstab_entries.stdout_lines

8. Führen Sie das Playbook zur Sammlung von Speicherinformationen aus.

   ansible-playbook -i inventory.ini get-storage.yml

   Dies zeigt detaillierte Informationen über die erstellte Speicherstruktur an.

9. Überprüfen Sie die Speicher-Konfiguration manuell.

   ## LVM-Struktur prüfen
   sudo vgs apache-vg
   sudo lvs apache-vg
   sudo pvs /dev/loop0
   
   ## Dateisysteme prüfen
   df -h /var/www /var/log/httpd /backup
   
   ## Mount-Points prüfen
   mount | grep apache-vg
   
   ## fstab-Einträge prüfen
   grep apache-vg /etc/fstab
   
   ## Web-Inhalte testen
   cat /var/www/html/storage.html

10. Erstellen Sie ein Playbook zur Speichererweiterung, um Skalierungsoperationen zu demonstrieren.

    nano expand_storage.yml

    Fügen Sie den folgenden Inhalt hinzu:

    ---
    - name: Speicher-Volumes erweitern
      hosts: webservers
      become: true
      vars:
        volume_group: apache-vg
        content_lv: content-lv
      tasks:
        - name: Content Logical Volume erweitern
          community.general.lvol:
            vg: "{{ volume_group }}"
            lv: "{{ content_lv }}"
            size: 400m
            state: present
    
        - name: XFS-Dateisystem erweitern
          community.general.filesystem:
            fstype: xfs
            dev: "/dev/{{ volume_group }}/{{ content_lv }}"
            resizefs: yes
    
        - name: Aktualisierte Dateisystemgröße anzeigen
          ansible.builtin.command:
            cmd: df -h /var/www
          register: new_size
          changed_when: false
    
        - name: Neue Dateisystemgröße anzeigen
          ansible.builtin.debug:
            var: new_size.stdout_lines

11. Testen Sie die Speichererweiterung.

    ## Aktuelle Größe vor der Erweiterung prüfen
    df -h /var/www
    
    ## Das Erweiterungs-Playbook ausführen
    ansible-playbook -i inventory.ini expand_storage.yml
    
    ## Die Erweiterung überprüfen
    df -h /var/www
    sudo lvs apache-vg/content-lv

Sie haben die LVM-Speicherverwaltung erfolgreich automatisiert, einschließlich der Erstellung von physischen Volumes, der Verwaltung logischer Volumes, der Erstellung von Dateisystemen und der Konfiguration von Mount-Points mit Ansible.

Netzwerkkonfiguration und Informationssammlung automatisieren

In diesem letzten Schritt lernen Sie, wie Sie die Netzwerkschnittstellenkonfiguration mit Ansible automatisieren und umfassende Systeminformationen sammeln. Dies vervollständigt das gesamte Spektrum der Systemadministrationsautomatisierung, von Software über Speicher bis hin zu Netzwerken.

Sie werden Module wie ansible.builtin.template für Netzwerkkonfigurationsdateien verwenden, Netzwerk-Fakten sammeln und umfassende Systemberichte erstellen.

1. Navigieren Sie zu einem neuen Projektverzeichnis für die Netzwerkverwaltung.

   cd ~/project
   mkdir system-network
   cd system-network

2. Erstellen Sie die Inventardatei für diese Übung.

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

3. Erstellen Sie ein umfassendes Playbook zur Sammlung von Netzwerk- und Systeminformationen.

   nano network_info.yml

   Fügen Sie den folgenden Inhalt hinzu:

   ---
   - name: Umfassende Systeminformationen sammeln
     hosts: webservers
     become: true
     tasks:
       - name: Alle System-Fakten sammeln
         ansible.builtin.setup:
   
       - name: Verzeichnis für Systemberichte erstellen
         ansible.builtin.file:
           path: /tmp/system_reports
           state: directory
           mode: "0755"
   
       - name: Systeminformationsbericht generieren
         ansible.builtin.template:
           src: system_report.j2
           dest: /tmp/system_reports/system_info_{{ ansible_facts['hostname'] }}.html
           mode: "0644"
   
       - name: Netzwerkkonfigurationsbericht generieren
         ansible.builtin.template:
           src: network_report.j2
           dest: /tmp/system_reports/network_info_{{ ansible_facts['hostname'] }}.html
           mode: "0644"
   
       - name: Informationen zu Netzwerkschnittstellen sammeln
         ansible.builtin.command:
           cmd: ip addr show
         register: ip_info
         changed_when: false
   
       - name: Routing-Informationen sammeln
         ansible.builtin.command:
           cmd: ip route show
         register: route_info
         changed_when: false
   
       - name: DNS-Konfiguration sammeln
         ansible.builtin.command:
           cmd: cat /etc/resolv.conf
         register: dns_info
         changed_when: false
   
       - name: Netzwerkübersicht anzeigen
         ansible.builtin.debug:
           msg: |
             System: {{ ansible_facts['hostname'] }}
             OS: {{ ansible_facts['distribution'] }} {{ ansible_facts['distribution_version'] }}
             Kernel: {{ ansible_facts['kernel'] }}
             Standard IPv4: {{ ansible_facts['default_ipv4']['address'] | default('N/A') }}
             Standard-Schnittstelle: {{ ansible_facts['default_ipv4']['interface'] | default('N/A') }}
             Gesamtspeicher: {{ ansible_facts['memtotal_mb'] }}MB
             CPU-Kerne: {{ ansible_facts['processor_vcpus'] }}

4. Erstellen Sie Vorlagenverzeichnisse und -dateien für die Berichte.

   mkdir templates
   nano templates/system_report.j2

   Fügen Sie den folgenden Inhalt für die Systemberichtsvorlage hinzu:

   <!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>
           Generiert am: {{ ansible_date_time.date }} {{ ansible_date_time.time
           }}
         </p>
       </div>
   
       <div class="section">
         <h2>Systeminformationen</h2>
         <table>
           <tr>
             <th>Eigenschaft</th>
             <th>Wert</th>
           </tr>
           <tr>
             <td>Hostname</td>
             <td>{{ ansible_facts['hostname'] }}</td>
           </tr>
           <tr>
             <td>FQDN</td>
             <td>{{ ansible_facts['fqdn'] }}</td>
           </tr>
           <tr>
             <td>Betriebssystem</td>
             <td>
               {{ ansible_facts['distribution'] }} {{
               ansible_facts['distribution_version'] }}
             </td>
           </tr>
           <tr>
             <td>Kernel</td>
             <td>{{ ansible_facts['kernel'] }}</td>
           </tr>
           <tr>
             <td>Architektur</td>
             <td>{{ ansible_facts['architecture'] }}</td>
           </tr>
           <tr>
             <td>CPU-Kerne</td>
             <td>{{ ansible_facts['processor_vcpus'] }}</td>
           </tr>
           <tr>
             <td>Gesamtspeicher</td>
             <td>{{ ansible_facts['memtotal_mb'] }}MB</td>
           </tr>
           <tr>
             <td>Uptime</td>
             <td>{{ ansible_facts['uptime_seconds'] }} Sekunden</td>
           </tr>
         </table>
       </div>
   
       <div class="section">
         <h2>Speicherinformationen</h2>
         <table>
           <tr>
             <th>Mount Point</th>
             <th>Dateisystem</th>
             <th>Größe</th>
             <th>Genutzt</th>
             <th>Verfügbar</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>Dienststatus</h2>
         <table>
           <tr>
             <th>Dienst</th>
             <th>Status</th>
           </tr>
           <tr>
             <td>httpd</td>
             <td>
               {{ ansible_facts.services['httpd.service']['state'] |
               default('nicht installiert') }}
             </td>
           </tr>
           <tr>
             <td>sshd</td>
             <td>
               {{ ansible_facts.services['sshd.service']['state'] |
               default('unbekannt') }}
             </td>
           </tr>
           <tr>
             <td>NetworkManager</td>
             <td>
               {{ ansible_facts.services['NetworkManager.service']['state'] |
               default('unbekannt') }}
             </td>
           </tr>
         </table>
       </div>
     </body>
   </html>

5. Erstellen Sie die Netzwerkkonfigurationsvorlage.

   nano templates/network_report.j2

   Fügen Sie den folgenden Inhalt hinzu:

   <!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>
           Generiert am: {{ ansible_date_time.date }} {{ ansible_date_time.time
           }}
         </p>
       </div>
   
       <div class="section">
         <h2>Netzwerkschnittstellen</h2>
         <table>
           <tr>
             <th>Schnittstelle</th>
             <th>IPv4-Adresse</th>
             <th>IPv6-Adresse</th>
             <th>MAC-Adresse</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('Aktiv',
               'Inaktiv') }}
             </td>
           </tr>
           {% endif %} {% endfor %}
         </table>
       </div>
   
       <div class="section">
         <h2>Standard-Gateway</h2>
         <table>
           <tr>
             <th>Eigenschaft</th>
             <th>Wert</th>
           </tr>
           <tr>
             <td>Standard IPv4-Adresse</td>
             <td>
               {{ ansible_facts['default_ipv4']['address'] | default('N/A') }}
             </td>
           </tr>
           <tr>
             <td>Standard-Schnittstelle</td>
             <td>
               {{ ansible_facts['default_ipv4']['interface'] | default('N/A')
               }}
             </td>
           </tr>
           <tr>
             <td>Standard-Gateway</td>
             <td>
               {{ ansible_facts['default_ipv4']['gateway'] | default('N/A') }}
             </td>
           </tr>
         </table>
       </div>
   
       <div class="section">
         <h2>DNS-Konfiguration</h2>
         <table>
           <tr>
             <th>DNS-Server</th>
           </tr>
           {% for dns in ansible_facts['dns']['nameservers'] %}
           <tr>
             <td>{{ dns }}</td>
           </tr>
           {% endfor %}
         </table>
       </div>
     </body>
   </html>

6. Erstellen Sie ein Playbook zur Konfiguration von Netzwerkschnittstellen.

   nano configure_network.yml

   Fügen Sie den folgenden Inhalt hinzu:

   ---
   - name: Netzwerkeinstellungen konfigurieren
     hosts: webservers
     become: true
     tasks:
       - name: NetworkManager installieren, falls nicht vorhanden
         ansible.builtin.dnf:
           name: NetworkManager
           state: present
   
       - name: Sicherstellen, dass NetworkManager läuft
         ansible.builtin.service:
           name: NetworkManager
           state: started
           enabled: yes
   
       - name: Hosts-Datei mit Systeminformationen konfigurieren
         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: Skript zur Netzwerküberwachung erstellen
         ansible.builtin.copy:
           content: |
             #!/bin/bash
             ## Von Ansible generiertes Skript zur Netzwerküberwachung
             echo "=== Netzwerkstatusbericht ==="
             echo "Generiert am: $(date)"
             echo
             echo "=== Schnittstellenstatus ==="
             ip addr show
             echo
             echo "=== Routing-Tabelle ==="
             ip route show
             echo
             echo "=== DNS-Konfiguration ==="
             cat /etc/resolv.conf
             echo
             echo "=== Netzwerk-Konnektivitätstest ==="
             ping -c 3 8.8.8.8
           dest: /usr/local/bin/network-status.sh
           mode: "0755"
   
       - name: Cron-Job zur Erfassung von Netzwerkinformationen erstellen
         ansible.builtin.cron:
           name: Netzwerkstatusüberwachung
           job: "/usr/local/bin/network-status.sh >> /var/log/network-status.log 2>&1"
           minute: "*/15"
           user: root
           cron_file: network-monitoring
           state: present

7. Führen Sie das Playbook zur Sammlung von Netzwerkinformationen aus.

   ansible-playbook -i inventory.ini network_info.yml

   Dies generiert umfassende System- und Netzwerkberichte.

8. Führen Sie das Playbook zur Netzwerkkonfiguration aus.

   ansible-playbook -i inventory.ini configure_network.yml

   Dies konfiguriert Netzwerkeinstellungen und die Überwachung.

9. Zeigen Sie die generierten Berichte an.

   ## Generierte Berichte auflisten
   ls -la /tmp/system_reports/
   
   ## Systembericht anzeigen (kann auch im Browser geöffnet werden)
   cat /tmp/system_reports/system_info_*.html
   
   ## Netzwerküberwachungsskript überprüfen
   cat /usr/local/bin/network-status.sh
   
   ## Netzwerküberwachungsskript testen
   sudo /usr/local/bin/network-status.sh
   
   ## Netzwerküberwachungs-Cron-Job überprüfen
   sudo cat /etc/cron.d/network-monitoring

10. Erstellen Sie ein abschließendes umfassendes Playbook, das alle gelernten Konzepte kombiniert.

    nano complete_system_setup.yml

    Fügen Sie den folgenden Inhalt hinzu:

    ---
    - name: Vollständige Systemeinrichtung und Konfiguration
      hosts: webservers
      become: true
      vars:
        admin_users:
          - webuser1
          - webuser2
      tasks:
        - name: Sicherstellen, dass alle erforderlichen Pakete installiert sind
          ansible.builtin.dnf:
            name:
              - httpd
              - lvm2
              - NetworkManager
              - cronie
            state: present
    
        - name: Sicherstellen, dass alle Dienste laufen
          ansible.builtin.service:
            name: "{{ item }}"
            state: started
            enabled: yes
          loop:
            - httpd
            - NetworkManager
            - crond
    
        - name: Abschließenden Systemstatusbericht generieren
          ansible.builtin.template:
            src: system_report.j2
            dest: /tmp/final_system_report.html
            mode: "0644"
    
        - name: Abschlussmeldung anzeigen
          ansible.builtin.debug:
            msg: |
              ============================================
              RHEL Systemadministrationsautomatisierung Abgeschlossen!
              ============================================
    
              Zusammenfassung der konfigurierten Komponenten:
              - Software: EPEL-Repository und Pakete installiert
              - Benutzer: {{ admin_users | length }} administrative Benutzer erstellt
              - Dienste: httpd, NetworkManager und crond konfiguriert
              - Speicher: LVM-Volumes und Dateisysteme konfiguriert
              - Netzwerk: Schnittstellenkonfiguration und Überwachung eingerichtet
              - Planung: Cron-Jobs und at-Aufgaben konfiguriert
    
              Berichte verfügbar unter:
              - /tmp/system_reports/
              - /tmp/final_system_report.html
    
              Ihr RHEL-System ist jetzt vollständig mit Ansible automatisiert!

11. Führen Sie die abschließende umfassende Einrichtung aus.

    ansible-playbook -i inventory.ini complete_system_setup.yml

Sie haben eine umfassende Automatisierung von RHEL-Systemadministrationsaufgaben mit Ansible erfolgreich abgeschlossen, die Softwareverwaltung, Benutzerverwaltung, Dienstverwaltung, Speicher- und Netzwerkkonfiguration abdeckt.

12. Vorschau der generierten Berichte in einem Webbrowser.

    Navigieren Sie zum Berichtsverzeichnis:

    cd /tmp/system_reports

    Starten Sie einen temporären Webserver mit Python:

    python -m http.server 8000

    Um die Berichte in Ihrem Browser anzuzeigen:

    1. Klicken Sie auf die Schaltfläche + in der oberen Menüleiste
    2. Wählen Sie Web Service
    3. Geben Sie die Portnummer 8000 ein
    4. Sie können die generierten HTML-Berichte jetzt online anzeigen

    

    Der Webserver zeigt eine Verzeichnisliste an, in der Sie auf die HTML-Dateien klicken können, um die umfassenden System- und Netzwerkberichte anzuzeigen, die von Ihren Ansible-Playbooks generiert wurden.

    Hinweis: Drücken Sie Strg+C, um den Webserver zu stoppen, wenn Sie mit der Anzeige der Berichte fertig sind.

Zusammenfassung

In diesem umfassenden Labor haben Sie die Automatisierung wesentlicher Red Hat Enterprise Linux (RHEL)-Administrationsaufgaben mit Ansible gemeistert. Sie begannen mit der Verwaltung von Softwarepaketen, lernten die Konfiguration von Repositories, die Verwaltung von GPG-Schlüsseln und die Installation von Paketen, während Sie Systeminformationen über Paket-Fakten sammelten. Dies bildete die Grundlage für eine konsistente Softwarebereitstellung in Ihrer Infrastruktur.

Anschließend widmeten Sie sich der Benutzerverwaltung und Authentifizierung, wo Sie die Erstellung von Benutzerkonten automatisierten, die SSH-Schlüssel-basierte Authentifizierung konfigurierten, sudo-Berechtigungen einrichteten und SSH-Konfigurationen härten. Dies etablierte sichere und standardisierte Benutzerzugriffsrichtlinien, die für Unternehmensumgebungen entscheidend sind.

Das Labor wurde mit der Dienstverwaltung und Aufgabenplanung fortgesetzt, wo Sie lernten, systemd-Dienste zu verwalten, wiederkehrende Cron-Jobs zu erstellen, einmalige Aufgaben mit at zu planen und System-Boot-Targets zu konfigurieren. Diese Fähigkeiten sind unerlässlich für die Aufrechterhaltung der Dienstverfügbarkeit und die Automatisierung routinemäßiger Wartungsaufgaben.

Die Speicherverwaltung wurde durch umfassende LVM-Automatisierung abgedeckt, einschließlich der Erstellung physischer Volumes, der Verwaltung von Volume Groups, der Bereitstellung logischer Volumes, der Erstellung von Dateisystemen und der Konfiguration von Mount-Points. Sie lernten auch, Speicher-Volumes dynamisch zu erweitern, was für ein skalierbares Infrastrukturmanagement entscheidend ist.

Schließlich haben Sie die Automatisierung der Netzwerkkonfiguration und die umfassende Systemüberwachung abgeschlossen. Sie lernten, Netzwerk-Fakten zu sammeln, Schnittstellen zu konfigurieren, detaillierte Systemberichte mit Jinja2-Vorlagen zu erstellen und automatisierte Überwachungsskripte einzurichten. Dies lieferte das vollständige Bild des Systemzustandsmanagements und der Berichterstattung.

Während dieses Labors haben Sie Prinzipien der Infrastructure as Code (IaC) angewendet und sichergestellt, dass alle Systemkonfigurationen reproduzierbar, versionskontrolliert und konsistent bereitstellbar sind. Sie verfügen nun über die Fähigkeiten, den gesamten Lebenszyklus der RHEL-Systemadministration zu automatisieren, von der anfänglichen Bereitstellung bis zur laufenden Wartung und Überwachung.