Ansible 'Permission denied' beheben: Anleitung & Tipps

Einführung

Ansible ist ein leistungsstarkes Automatisierungswerkzeug, das die Infrastrukturverwaltung und -konfiguration vereinfacht. Das Ansible-Script-Modul ermöglicht die Ausführung benutzerdefinierter Skripte innerhalb Ihrer Playbooks und erweitert so die Funktionalität von Ansible über seine integrierten Module hinaus. Benutzer stoßen jedoch häufig auf den Fehler 'Permission denied' (Zugriff verweigert), wenn sie dieses Modul verwenden, was Automatisierungs-Workflows behindern kann.

Dieses Lab führt Sie durch das Verständnis und die Behebung von Berechtigungsproblemen im Script-Modul von Ansible. Sie lernen, die Ursachen von Berechtigungsfehlern zu identifizieren und verschiedene Lösungen zu implementieren, um sicherzustellen, dass Ihre Ansible-Skripte erfolgreich ausgeführt werden.

Installation von Ansible und Einrichtung der Umgebung

Bevor wir uns mit Berechtigungsproblemen bei Ansible-Skripten befassen können, müssen wir unsere Umgebung einrichten. Installieren wir Ansible und erstellen wir eine grundlegende Struktur für unsere Testumgebung.

Installation von Ansible

Zuerst aktualisieren wir den Paketindex und installieren Ansible:

sudo apt update
sudo apt install -y ansible

Sobald die Installation abgeschlossen ist, überprüfen Sie, ob Ansible korrekt installiert wurde:

ansible --version

Sie sollten eine Ausgabe ähnlich dieser sehen, die die Ansible-Version und Konfigurationsdetails anzeigt:

ansible [core 2.12.x]
  config file = /etc/ansible/ansible.cfg
  configured module search path = ['/home/labex/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /usr/lib/python3/dist-packages/ansible
  ansible collection location = /home/labex/.ansible/collections:/usr/share/ansible/collections
  executable location = /usr/bin/ansible
  python version = 3.10.x (default, Mar 01 2023, 12:34:56) [GCC 11.2.0]
  jinja version = 3.0.3
  libyaml = True

Einrichten der Projektstruktur

Erstellen wir nun eine Projektverzeichnisstruktur für unser Ansible-Playbook und unsere Skripte:

mkdir -p ~/project/ansible-lab/{playbooks,scripts}
cd ~/project/ansible-lab

In dieser Struktur:

playbooks/ enthält unsere Ansible-Playbooks
scripts/ enthält unsere Shell-Skripte, die von Ansible ausgeführt werden sollen

Erstellen eines einfachen Skripts

Erstellen wir ein einfaches Shell-Skript, das wir mit Ansible verwenden werden. Erstellen Sie eine Datei namens hello.sh im Skriptverzeichnis:

cd ~/project/ansible-lab/scripts
touch hello.sh

Öffnen Sie die Datei hello.sh im Editor und fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash
echo "Hello from $(hostname)!"
echo "Current time: $(date)"
echo "Current user: $(whoami)"

Dieses Skript gibt den Hostnamen, die aktuelle Uhrzeit und den Benutzer aus, der das Skript ausgeführt hat.

Erstellen einer Inventory-Datei

Als Nächstes erstellen wir eine einfache Inventory-Datei für Ansible. In Ansible definiert eine Inventory-Datei die Hosts und Gruppen, die Ansible verwalten wird:

cd ~/project/ansible-lab
touch inventory.ini

Öffnen Sie die Datei inventory.ini und fügen Sie Folgendes hinzu:

[local]
localhost ansible_connection=local

Diese Inventory-Datei weist Ansible an, Befehle auf dem lokalen Rechner auszuführen.

Erstellen eines grundlegenden Playbooks

Erstellen wir nun ein grundlegendes Ansible-Playbook, das das Script-Modul verwendet:

cd ~/project/ansible-lab/playbooks
touch run_script.yml

Öffnen Sie die Datei run_script.yml und fügen Sie den folgenden Inhalt hinzu:

---
- name: Run a script
  hosts: local
  tasks:
    - name: Execute the hello script
      script: ../scripts/hello.sh

Dieses Playbook versucht, unser Skript hello.sh auf dem lokalen Rechner auszuführen.

Mit dieser grundlegenden Einrichtung sind wir bereit, uns in den nächsten Schritten mit Berechtigungsproblemen bei Ansible-Skripten zu befassen.

Auftreten des Fehlers 'Permission Denied' (Zugriff verweigert)

Nachdem wir unsere Umgebung eingerichtet haben, versuchen wir nun, unser Ansible-Playbook auszuführen und zu verstehen, was passiert, wenn wir auf einen 'Permission denied'-Fehler stoßen.

Ausführen des Playbooks

Versuchen wir, unser Playbook auszuführen:

cd ~/project/ansible-lab
ansible-playbook -i inventory.ini playbooks/run_script.yml

Sie werden wahrscheinlich eine Fehlermeldung ähnlich dieser erhalten:

TASK [Execute the hello script] *******************************
fatal: [localhost]: FAILED! => {"changed": false, "msg": "failed to execute the script: /bin/sh: 1: /home/labex/.ansible/tmp/ansible-tmp-1234567890.12-123456789012345/AnsiballZ_script.py: Permission denied"}

Dies ist ein häufiger 'Permission denied'-Fehler bei der Verwendung des Ansible-Script-Moduls. Der Fehler tritt auf, weil unser Skript nicht über die Ausführungsberechtigung verfügt, die für die Ausführung erforderlich ist.

Verstehen von Dateiberechtigungen in Linux

In Linux hat jede Datei Berechtigungen, die bestimmen, wer sie lesen, schreiben oder ausführen kann. Es gibt drei Arten von Berechtigungen:

Read (r): Ermöglicht das Lesen des Dateiinhaltes
Write (w): Ermöglicht das Ändern der Datei
Execute (x): Ermöglicht das Ausführen der Datei als Programm

Diese Berechtigungen werden drei verschiedenen Benutzerkategorien zugewiesen:

User (owner): Der Eigentümer der Datei
Group: Benutzer, die Mitglieder der Gruppe der Datei sind
Others: Alle anderen Benutzer

Sie können die Berechtigungen einer Datei mit dem Befehl ls -l anzeigen:

ls -l ~/project/ansible-lab/scripts/hello.sh

Sie könnten eine Ausgabe wie diese sehen:

-rw-rw-r-- 1 labex labex 95 Jun 10 12:34 /home/labex/project/ansible-lab/scripts/hello.sh

In dieser Ausgabe stellt der erste Satz von Zeichen (-rw-rw-r--) die Berechtigungen der Datei dar:

Das erste Zeichen (-) gibt an, dass es sich um eine reguläre Datei handelt
Die nächsten drei Zeichen (rw-) sind die Berechtigungen des Eigentümers (Lesen, Schreiben, kein Ausführen)
Die nächsten drei (rw-) sind die Berechtigungen der Gruppe
Die letzten drei (r--) sind Berechtigungen für andere

Beachten Sie, dass die Ausführungsberechtigung (x) für alle Benutzerkategorien fehlt, weshalb wir den 'Permission denied'-Fehler erhalten.

Überprüfen der aktuellen Berechtigungen

Untersuchen wir die aktuellen Berechtigungen unseres Skripts:

ls -l ~/project/ansible-lab/scripts/hello.sh

Sie werden sehen, dass dem Skript die Ausführungsberechtigung fehlt, die für die Ausführung durch Ansible benötigt wird.

Im nächsten Schritt erfahren wir, wie wir dieses Berechtigungsproblem beheben und unser Ansible-Playbook erfolgreich ausführen können.

Beheben von Berechtigungsproblemen mit chmod

Der häufigste Weg, den Fehler "Permission denied" zu beheben, besteht darin, der Skriptdatei Ausführungsberechtigungen hinzuzufügen. Dies können wir mit dem Befehl chmod tun.

Verstehen des chmod-Befehls

Der Befehl chmod wird verwendet, um die Berechtigungen von Dateien oder Verzeichnissen in Linux zu ändern. Der Befehl hat mehrere Möglichkeiten, Berechtigungen anzugeben:

Symbolic mode (Symbolischer Modus): Verwendet Buchstaben (r, w, x), um Berechtigungen darzustellen
Numeric mode (Numerischer Modus): Verwendet Zahlen (4, 2, 1), um Berechtigungen darzustellen

Für unseren Zweck verwenden wir den symbolischen Modus, um Ausführungsberechtigungen hinzuzufügen.

Hinzufügen von Ausführungsberechtigungen zum Skript

Fügen wir unserem Skript Ausführungsberechtigungen hinzu:

chmod +x ~/project/ansible-lab/scripts/hello.sh

Die Option +x fügt die Ausführungsberechtigung für alle Benutzerkategorien (Benutzer, Gruppe und Andere) hinzu.

Überprüfen wir, ob die Berechtigungen aktualisiert wurden:

ls -l ~/project/ansible-lab/scripts/hello.sh

Sie sollten jetzt eine Ausgabe ähnlich dieser sehen:

-rwxrwxr-x 1 labex labex 95 Jun 10 12:34 /home/labex/project/ansible-lab/scripts/hello.sh

Beachten Sie das x in der Berechtigungszeichenfolge, das anzeigt, dass die Ausführungsberechtigung hinzugefügt wurde.

Erneutes Ausführen des Playbooks

Nachdem wir unserem Skript Ausführungsberechtigungen hinzugefügt haben, führen wir das Ansible-Playbook erneut aus:

cd ~/project/ansible-lab
ansible-playbook -i inventory.ini playbooks/run_script.yml

Diesmal sollte das Playbook erfolgreich ausgeführt werden:

PLAY [Run a script] ******************************************

TASK [Gathering Facts] ***************************************
ok: [localhost]

TASK [Execute the hello script] *****************************
changed: [localhost]

PLAY RECAP *************************************************
localhost                  : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Anzeigen der Skriptausgabe

Überprüfen wir die Ausgabe unseres Skripts. Ansible erfasst die Ausgabe des Skripts und fügt sie in die Task-Ergebnisse ein. Um die detaillierte Ausgabe zu sehen, ändern wir unser Playbook, um die Ausgabe zu registrieren und anzuzeigen:

cd ~/project/ansible-lab/playbooks

Bearbeiten Sie die Datei run_script.yml, um die Register- und Debug-Tasks einzufügen:

---
- name: Run a script
  hosts: local
  tasks:
    - name: Execute the hello script
      script: ../scripts/hello.sh
      register: script_output

    - name: Display script output
      debug:
        var: script_output.stdout_lines

Führen wir nun das Playbook erneut aus:

cd ~/project/ansible-lab
ansible-playbook -i inventory.ini playbooks/run_script.yml

Sie sollten eine Ausgabe wie diese sehen:

PLAY [Run a script] ******************************************

TASK [Gathering Facts] ***************************************
ok: [localhost]

TASK [Execute the hello script] *****************************
changed: [localhost]

TASK [Display script output] ********************************
ok: [localhost] => {
    "script_output.stdout_lines": [
        "Hello from localhost!",
        "Current time: Wed Jun 10 12:34:56 UTC 2023",
        "Current user: labex"
    ]
}

PLAY RECAP *************************************************
localhost                  : ok=3    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Jetzt können Sie die vollständige Ausgabe unseres Skripts sehen. Das Skript wurde als Benutzer labex ausgeführt, was unser aktueller Benutzer ist.

Durch das Hinzufügen von Ausführungsberechtigungen mit chmod +x haben wir den Fehler "Permission denied" erfolgreich behoben und können unser Skript nun über Ansible ausführen.

Verwenden von Become für Privilegien-Eskalation

Manchmal müssen Sie Skripte mit erhöhten Berechtigungen ausführen, z. B. Befehle, die Root-Zugriff erfordern. In diesen Fällen reicht es möglicherweise nicht aus, dem Skript einfach Ausführungsberechtigungen hinzuzufügen. Ansible bietet die Direktive become, um Tasks mit Privilegien-Eskalation auszuführen.

Verstehen der Become-Direktive

Die become-Direktive in Ansible ermöglicht es Ihnen, Tasks als ein anderer Benutzer auszuführen, typischerweise mit erhöhten Berechtigungen. Dies ähnelt der Verwendung von sudo in der Befehlszeile.

Wichtige Optionen für die become-Direktive sind:

become: yes: Aktiviert die Privilegien-Eskalation
become_user: <username>: Gibt an, welcher Benutzer werden soll (Standard ist root)
become_method: <method>: Gibt an, wie der Benutzer werden soll (Standard ist sudo)

Erstellen eines Skripts, das Root-Privilegien benötigt

Erstellen wir ein Skript, das Root-Privilegien benötigt, um erfolgreich ausgeführt zu werden:

cd ~/project/ansible-lab/scripts
touch system_info.sh

Fügen Sie den folgenden Inhalt in die Datei system_info.sh ein:

#!/bin/bash
echo "System information - requires root privileges"
echo "Hostname: $(hostname)"
echo "Kernel version: $(uname -r)"
echo "Available disk space:"
df -h /
echo "User executing the script: $(whoami)"

Machen Sie das Skript ausführbar:

chmod +x ~/project/ansible-lab/scripts/system_info.sh

Erstellen eines Playbooks mit Become

Erstellen wir nun ein Playbook, das die become-Direktive verwendet:

cd ~/project/ansible-lab/playbooks
touch root_script.yml

Fügen Sie den folgenden Inhalt in die Datei root_script.yml ein:

---
- name: Run a script as root
  hosts: local
  tasks:
    - name: Execute the system info script
      script: ../scripts/system_info.sh
      become: yes
      register: script_output

    - name: Display script output
      debug:
        var: script_output.stdout_lines

Die Direktive become: yes weist Ansible an, das Skript mit erhöhten Berechtigungen auszuführen.

Ausführen des Playbooks mit Become

Führen wir unser neues Playbook aus:

cd ~/project/ansible-lab
ansible-playbook -i inventory.ini playbooks/root_script.yml

Das Playbook sollte erfolgreich ausgeführt werden, und Sie sollten eine Ausgabe ähnlich dieser sehen:

PLAY [Run a script as root] *********************************

TASK [Gathering Facts] **************************************
ok: [localhost]

TASK [Execute the system info script] **********************
changed: [localhost]

TASK [Display script output] *******************************
ok: [localhost] => {
    "script_output.stdout_lines": [
        "System information - requires root privileges",
        "Hostname: localhost",
        "Kernel version: 5.15.0-1015-aws",
        "Available disk space:",
        "Filesystem      Size  Used Avail Use% Mounted on",
        "/dev/root        59G   17G   42G  29% /",
        "User executing the script: root"
    ]
}

PLAY RECAP ************************************************
localhost                  : ok=3    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Beachten Sie, dass in der Skriptausgabe der "User executing the script" jetzt root ist, nicht labex. Dies zeigt, dass unser Skript aufgrund der Direktive become: yes mit erhöhten Berechtigungen ausgeführt wurde.

Verstehen, wann Become verwendet werden soll

Sie sollten die become-Direktive in den folgenden Situationen verwenden:

Wenn das Skript auf Systemdateien oder -verzeichnisse zugreifen muss, die Root-Privilegien erfordern
Wenn das Skript Pakete installieren oder Systemkonfigurationen ändern muss
Wenn das Skript Befehle ausführen muss, die normalerweise sudo in der Befehlszeile erfordern würden

Durch die angemessene Verwendung der become-Direktive können Sie sicherstellen, dass Ihre Skripte die erforderlichen Berechtigungen haben, um erfolgreich ausgeführt zu werden, und so Fehler aufgrund von Berechtigungsverweigerung vermeiden.

Best Practices zur Vermeidung von Berechtigungsproblemen

Nachdem wir verstanden haben, wie man Berechtigungsprobleme mit chmod und become behebt, wollen wir einige Best Practices untersuchen, um zu verhindern, dass Berechtigungsprobleme überhaupt erst auftreten.

1. Skripte immer ausführbar machen, bevor man sie verwendet

Stellen Sie vor der Verwendung eines Skripts in Ansible immer sicher, dass es die Ausführungsberechtigung hat:

chmod +x path/to/script.sh

Es ist eine gute Praxis, dies als Teil Ihres Skripterstellungsprozesses zu tun.

2. Versionskontrolle mit korrekten Dateimodus verwenden

Wenn Sie Git oder ein anderes Versionskontrollsystem verwenden, stellen Sie sicher, dass es die Dateimodus (Berechtigungen) beibehält. In Git können Sie dies mit Folgendem konfigurieren:

git config core.fileMode true

Für bestehende Repositories müssen Sie möglicherweise die Dateimodus aktualisieren:

git update-index --chmod=+x path/to/script.sh

3. Ein Skript erstellen, um Berechtigungen zu überprüfen und zu korrigieren

Erstellen wir ein Hilfsskript, das die Berechtigungen für alle Skripte in unserem Projekt überprüft und korrigiert:

cd ~/project/ansible-lab
touch fix_permissions.sh

Fügen Sie den folgenden Inhalt in die Datei fix_permissions.sh ein:

#!/bin/bash
echo "Fixing permissions for scripts in ansible-lab"

## Find all .sh files and make them executable
find ~/project/ansible-lab -name "*.sh" -type f -exec chmod +x {} \;

echo "Done. All script files now have execute permissions."

Machen Sie das Skript ausführbar:

chmod +x ~/project/ansible-lab/fix_permissions.sh

Führen Sie das Skript aus, um sicherzustellen, dass alle Skripte in Ihrem Projekt Ausführungsberechtigungen haben:

./fix_permissions.sh

4. Verwenden Sie das Ansible-File-Modul, um Berechtigungen festzulegen

Sie können auch das file-Modul von Ansible verwenden, um sicherzustellen, dass Skriptdateien die korrekten Berechtigungen haben. Erstellen wir ein Playbook, das dies tut:

cd ~/project/ansible-lab/playbooks
touch set_permissions.yml

Fügen Sie den folgenden Inhalt in die Datei set_permissions.yml ein:

---
- name: Set correct permissions for scripts
  hosts: local
  tasks:
    - name: Find all script files
      find:
        paths: /home/labex/project/ansible-lab
        patterns: "*.sh"
        recurse: yes
      register: script_files

    - name: Make script files executable
      file:
        path: "{{ item.path }}"
        mode: "0755"
      loop: "{{ script_files.files }}"

Führen Sie dieses Playbook aus, um sicherzustellen, dass alle Skripte die korrekten Berechtigungen haben:

cd ~/project/ansible-lab
ansible-playbook -i inventory.ini playbooks/set_permissions.yml

5. Erstellen Sie ein Pre-Flight-Check-Playbook

Erstellen wir abschließend ein Pre-Flight-Check-Playbook, das vor Ihren Haupt-Playbooks ausgeführt wird, um zu überprüfen, ob alles korrekt eingerichtet ist:

cd ~/project/ansible-lab/playbooks
touch preflight_check.yml

Fügen Sie den folgenden Inhalt in die Datei preflight_check.yml ein:

---
- name: Pre-flight checks
  hosts: local
  tasks:
    - name: Check if scripts are executable
      find:
        paths: /home/labex/project/ansible-lab
        patterns: "*.sh"
        recurse: yes
      register: script_files

    - name: Verify script permissions
      stat:
        path: "{{ item.path }}"
      register: stat_results
      loop: "{{ script_files.files }}"
      failed_when: not stat_results.stat.executable
      ignore_errors: yes

Dieses Playbook überprüft, ob alle .sh-Dateien ausführbar sind, und meldet alle, die es nicht sind.

Führen wir den Pre-Flight-Check aus:

cd ~/project/ansible-lab
ansible-playbook -i inventory.ini playbooks/preflight_check.yml

Wenn alle Ihre Skripte die korrekten Berechtigungen haben, sollte das Playbook ohne Fehler abgeschlossen werden. Wenn einem Skript Ausführungsberechtigungen fehlen, wird eine Benachrichtigung angezeigt.

Durch Befolgen dieser Best Practices können Sie Fehler aufgrund von Berechtigungsverweigerung in Ihren Ansible-Skripten vermeiden und sicherstellen, dass Ihre Automatisierung reibungslos abläuft.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie man 'Permission denied'-Fehler bei der Verwendung des Ansible-Skriptmoduls identifiziert und behebt.

Wichtige Erkenntnisse aus diesem Lab sind:

Verständnis der Bedeutung von Dateiberechtigungen in Linux und wie sie die Skriptausführung in Ansible beeinflussen
Verwendung des chmod-Befehls, um Skriptdateien Ausführungsberechtigungen hinzuzufügen
Verwendung der become-Direktive von Ansible für die Privilegien-Eskalation beim Ausführen von Skripten, die Root-Zugriff erfordern
Implementierung von Best Practices zur Vermeidung von Berechtigungsproblemen, einschließlich:
- Skripte ausführbar machen, bevor man sie verwendet
- Aufrechterhaltung korrekter Dateimodus in der Versionskontrolle
- Erstellen von Hilfsskripten zum Überprüfen und Beheben von Berechtigungen
- Verwendung des Ansible-File-Moduls zum Festlegen von Berechtigungen
- Implementierung von Pre-Flight-Checks zur Überprüfung Ihrer Umgebung

Durch die Anwendung dieser Techniken können Sie sicherstellen, dass Ihre Ansible-Skripte ohne Berechtigungsfehler reibungslos ausgeführt werden, was die Zuverlässigkeit Ihrer Automatisierungs-Workflows erhöht.

Die in diesem Lab erlernten Fähigkeiten sind grundlegend für die effektive Arbeit mit Ansible und können auf eine Vielzahl von Automatisierungsszenarien angewendet werden.

So beheben Sie den 'Permission denied'-Fehler im Ansible-Skriptmodul