Einführung
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.
Richten Sie zunächst die Projektumgebung ein und installieren Sie Ansible.
Installieren Sie das Paket
ansible-coreund navigieren Sie zum Projektverzeichnis.sudo dnf install -y ansible-core cd ~/project mkdir system-software cd system-softwareErstellen 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 EOFErstellen 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.ymlFü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
Führen Sie das Playbook aus, um den vollständigen Workflow zur Softwareverwaltung in Aktion zu sehen.
ansible-playbook -i inventory.ini repo_playbook.ymlSie 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
Überprüfen Sie die Repository-Konfiguration, indem Sie die erstellte Repository-Datei überprüfen.
cat /etc/yum.repos.d/epel.repoSie sollten die EPEL-Repository-Konfiguration mit den Einstellungen für baseurl, gpgcheck und gpgkey sehen.
Testen Sie die Idempotenz der Paketverwaltung, indem Sie das Playbook erneut ausführen.
ansible-playbook -i inventory.ini repo_playbook.ymlBeachten 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.
Navigieren Sie zu einem neuen Projektverzeichnis für die Benutzerverwaltungsaufgaben.
cd ~/project mkdir system-users cd system-usersInstallieren Sie die Sammlung
ansible.posix.ansible-galaxy collection install ansible.posixErstellen Sie die Inventardatei für diese Übung.
cat << EOF > inventory.ini [webservers] localhost ansible_connection=local EOFErstellen Sie eine Variablen-Datei, um die Benutzer und Gruppen zu definieren, die wir verwalten möchten.
mkdir vars nano vars/users_vars.ymlFü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: webadminGenerieren 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 "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"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.ymlFü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: restartedDieses 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
Führen Sie das Playbook zur Benutzerverwaltung aus.
ansible-playbook -i inventory.ini users.ymlDas Playbook erstellt Benutzer, richtet SSH-Schlüssel ein, konfiguriert den Sudo-Zugriff und härtet die SSH-Konfiguration ab.
Ü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 webadminTesten 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"Ü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"Ü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.
Navigieren Sie zu einem neuen Projektverzeichnis für die Dienst- und Prozessverwaltung.
cd ~/project mkdir system-process cd system-processErstellen Sie die Inventardatei für diese Übung.
cat << EOF > inventory.ini [webservers] localhost ansible_connection=local EOFErstellen Sie ein Playbook zur Verwaltung des Apache HTTP Server-Dienstes. Dies demonstriert die grundlegende Dienstverwaltung.
nano service_management.ymlFü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']Erstellen Sie ein Playbook zur Planung von Cron-Jobs. Dies demonstriert die automatisierte Aufgabenplanung.
nano create_crontab_file.ymlFü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: presentErstellen Sie ein Playbook zur einmaligen Aufgabenplanung mit
at.nano schedule_at_task.ymlFü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: presentErstellen Sie ein Playbook zur Verwaltung von System-Boot-Targets.
nano boot_target_management.ymlFü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 }}"Führen Sie das Playbook zur Dienstverwaltung aus.
ansible-playbook -i inventory.ini service_management.ymlDies startet den httpd-Dienst und erstellt eine Willkommensseite.
Führen Sie das Playbook zur Planung von Cron-Jobs aus.
ansible-playbook -i inventory.ini create_crontab_file.ymlDies erstellt mehrere geplante Aufgaben für die Systemüberwachung und -wartung.
Führen Sie das Playbook zur einmaligen Aufgabenplanung aus.
ansible-playbook -i inventory.ini schedule_at_task.ymlDies plant sofortige Aufgaben mit dem
at-Befehl.Führen Sie das Playbook zur Verwaltung von Boot-Targets aus.
ansible-playbook -i inventory.ini boot_target_management.ymlDies prüft und ändert möglicherweise das Standard-Boot-Target des Systems.
Ü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.logErstellen Sie ein Bereinigungs-Playbook, um geplante Aufgaben bei Bedarf zu entfernen.
nano remove_scheduled_tasks.ymlFü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.
Navigieren Sie zu einem neuen Projektverzeichnis für die Speicherverwaltung.
cd ~/project mkdir system-storage cd system-storageErstellen Sie die Inventardatei für diese Übung.
cat << EOF > inventory.ini [webservers] localhost ansible_connection=local EOFErstellen 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 loop0Erstellen Sie ein umfassendes Playbook zur Speicherverwaltung. Dies demonstriert LVM-Operationen und Dateisystemverwaltung.
nano storage.ymlFü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"Installieren Sie die erforderliche Ansible-Sammlung für die LVM-Verwaltung.
ansible-galaxy collection install community.generalFühren Sie das Playbook zur Speicherverwaltung aus.
ansible-playbook -i inventory.ini storage.ymlDies erstellt die LVM-Struktur, Dateisysteme und Mount-Points.
Erstellen Sie ein Playbook zum Sammeln und Anzeigen von Speicherinformationen.
nano get-storage.ymlFü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_linesFühren Sie das Playbook zur Sammlung von Speicherinformationen aus.
ansible-playbook -i inventory.ini get-storage.ymlDies zeigt detaillierte Informationen über die erstellte Speicherstruktur an.
Ü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.htmlErstellen Sie ein Playbook zur Speichererweiterung, um Skalierungsoperationen zu demonstrieren.
nano expand_storage.ymlFü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_linesTesten 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.
Navigieren Sie zu einem neuen Projektverzeichnis für die Netzwerkverwaltung.
cd ~/project mkdir system-network cd system-networkErstellen Sie die Inventardatei für diese Übung.
cat << EOF > inventory.ini [webservers] localhost ansible_connection=local EOFErstellen Sie ein umfassendes Playbook zur Sammlung von Netzwerk- und Systeminformationen.
nano network_info.ymlFü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'] }}Erstellen Sie Vorlagenverzeichnisse und -dateien für die Berichte.
mkdir templates nano templates/system_report.j2Fü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>Erstellen Sie die Netzwerkkonfigurationsvorlage.
nano templates/network_report.j2Fü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>Erstellen Sie ein Playbook zur Konfiguration von Netzwerkschnittstellen.
nano configure_network.ymlFü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: presentFühren Sie das Playbook zur Sammlung von Netzwerkinformationen aus.
ansible-playbook -i inventory.ini network_info.ymlDies generiert umfassende System- und Netzwerkberichte.
Führen Sie das Playbook zur Netzwerkkonfiguration aus.
ansible-playbook -i inventory.ini configure_network.ymlDies konfiguriert Netzwerkeinstellungen und die Überwachung.
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-monitoringErstellen Sie ein abschließendes umfassendes Playbook, das alle gelernten Konzepte kombiniert.
nano complete_system_setup.ymlFü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!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.
Vorschau der generierten Berichte in einem Webbrowser.
Navigieren Sie zum Berichtsverzeichnis:
cd /tmp/system_reportsStarten Sie einen temporären Webserver mit Python:
python -m http.server 8000Um die Berichte in Ihrem Browser anzuzeigen:
- Klicken Sie auf die Schaltfläche + in der oberen Menüleiste
- Wählen Sie Web Service
- Geben Sie die Portnummer 8000 ein
- 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.
