Ansible Sudo Passwort fehlt: So beheben Sie das Problem

Einführung

Ansible ist ein leistungsstarkes Automatisierungswerkzeug, das bei der Verwaltung und Konfiguration von Servern hilft, ohne dass manuelles Eingreifen erforderlich ist. Viele Ansible-Aufgaben erfordern jedoch erhöhte Berechtigungen, um ordnungsgemäß ausgeführt zu werden. Beim Ausführen von Befehlen, die Administratorrechte benötigen, verwendet Ansible den Sudo-Mechanismus, der möglicherweise zur Eingabe eines Passworts auffordert.

In diesem Lab lernen Sie, wie Sie Sudo-Passworteinstellungen in Ansible-Playbooks richtig konfigurieren, häufige Sudo-bezogene Probleme verstehen und Best Practices implementieren, um sicherzustellen, dass Ihre Automatisierung reibungslos mit den erforderlichen Berechtigungen abläuft.

Installation von Ansible und Erstellung eines einfachen Playbooks

In diesem ersten Schritt installieren wir Ansible und erstellen ein einfaches Playbook, das Sudo-Rechte benötigt. Dies hilft uns, die grundlegenden Anforderungen für die Ausführung von Ansible-Aufgaben mit erhöhten Berechtigungen zu verstehen.

Installation von Ansible

Beginnen wir mit der Installation von Ansible auf unserem System. Öffnen Sie ein Terminal und führen Sie die folgenden Befehle aus:

sudo apt update
sudo apt install -y ansible

Nach Abschluss der Installation überprüfen Sie, ob Ansible korrekt installiert wurde:

ansible --version

Sie sollten eine Ausgabe ähnlich dieser sehen, die die Ansible-Version und Konfigurationsinformationen 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 (main, Ubuntu, linux/x86_64)
  jinja version = 3.0.3
  libyaml = True

Erstellen eines einfachen Ansible Playbooks

Erstellen wir nun ein einfaches Ansible Playbook, das Sudo-Rechte benötigt. Dieses Playbook installiert das Paket htop auf dem lokalen System.

Erstellen Sie ein neues Verzeichnis für Ihr Ansible-Projekt:

mkdir -p ~/project/ansible-sudo-lab
cd ~/project/ansible-sudo-lab

Erstellen Sie als Nächstes die Inventardatei, die die Hosts definiert, die Ansible verwalten soll. Für dieses Lab verwenden wir localhost:

echo "localhost ansible_connection=local" > inventory

Erstellen Sie nun ein einfaches Playbook, das Sudo-Rechte benötigt. Öffnen Sie den VSCode-Editor und erstellen Sie eine neue Datei mit dem Namen basic_playbook.yml:

Klicken Sie im WebIDE-Menü auf "File" (Datei)
Wählen Sie "New File" (Neue Datei)
Kopieren und fügen Sie den folgenden Inhalt ein:

---
- name: Basic sudo operation
  hosts: localhost
  become: true ## This enables sudo

  tasks:
    - name: Install htop
      apt:
        name: htop
        state: present
        update_cache: yes

Speichern Sie die Datei als ~/project/ansible-sudo-lab/basic_playbook.yml

Dieses Playbook hat die Direktive become: true, die Ansible anweist, Sudo für die Ausführung der Aufgaben zu verwenden. Die Aufgabe selbst versucht, das Paket htop mit dem Modul apt zu installieren.

Ausführen des Playbooks

Führen wir nun unser Playbook aus und beobachten wir, was passiert:

cd ~/project/ansible-sudo-lab
ansible-playbook -i inventory basic_playbook.yml

Da der Benutzer labex passwortlosen Sudo-Zugriff hat, sollte das Playbook erfolgreich ausgeführt werden, ohne zur Eingabe eines Passworts aufzufordern. Sie sollten eine Ausgabe ähnlich dieser sehen:

PLAY [Basic sudo operation] ******************************************

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

TASK [Install htop] ************************************************
ok: [localhost]

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

Das Playbook wurde erfolgreich ausgeführt, da unser aktueller Benutzer (labex) bereits mit passwortlosem Sudo-Zugriff konfiguriert ist. In den nächsten Schritten werden wir untersuchen, wie man Szenarien behandelt, in denen ein Sudo-Passwort erforderlich ist.

Verständnis der Sudo-Passwortkonfiguration in Ansible

Im vorherigen Schritt haben wir ein einfaches Playbook erstellt, das Sudo-Rechte verwendete, ohne ein Passwort zu benötigen. In vielen realen Szenarien müssen Sie jedoch ein Sudo-Passwort angeben, um privilegierte Befehle auszuführen. Lassen Sie uns untersuchen, wie man Sudo-Passwörter in Ansible handhabt.

Wie Ansible Sudo-Passwörter handhabt

Wenn Ansible einen Befehl mit erhöhten Berechtigungen auf einem Remote-System ausführen muss, verwendet es die become-Funktionalität. Standardmäßig verwendet Ansible den Befehl sudo für die Privilegienerweiterung, aber Sie können es so konfigurieren, dass es andere Methoden wie su, pbrun oder pfexec verwendet.

Wenn der Benutzer, der Ansible ausführt, ein Passwort benötigt, um sudo zu verwenden, muss Ansible dieses Passwort kennen. Es gibt verschiedene Möglichkeiten, das Sudo-Passwort an Ansible zu übergeben:

Befehlszeilenoption: -K oder --ask-become-pass
Playbook-Variable: become_password
Konfigurationsdatei: ansible.cfg
Ansible Vault: Zur sicheren Speicherung von Passwörtern

Erstellen eines Testbenutzers mit Sudo-Passwortanforderung

Um zu demonstrieren, wie man Sudo-Passwörter handhabt, erstellen wir einen Testbenutzer, der ein Passwort für Sudo-Operationen benötigt:

sudo adduser ansible_test

Geben Sie bei Aufforderung das Passwort ansible123 ein und schließen Sie den Benutzererstellungsprozess ab.

Als Nächstes geben wir diesem Benutzer Sudo-Rechte, verlangen aber ein Passwort:

echo "ansible_test ALL=(ALL) ALL" | sudo tee /etc/sudoers.d/ansible_test

Diese Konfiguration erlaubt dem Benutzer ansible_test, sudo zu verwenden, erfordert aber jedes Mal das Passwort des Benutzers.

Erstellen eines Playbooks mit Sudo-Passworthandling

Erstellen wir nun ein Playbook, das zeigt, wie man Sudo-Passwörter handhabt. Erstellen Sie im WebIDE eine neue Datei mit dem Namen sudo_password_playbook.yml:

---
- name: Playbook with sudo password handling
  hosts: localhost
  become: true
  ## We'll provide the become_password when running the playbook

  tasks:
    - name: Get current user
      command: whoami
      register: current_user
      become: false ## This task doesn't need sudo

    - name: Print current user
      debug:
        msg: "Current user is {{ current_user.stdout }}"
      become: false ## This task doesn't need sudo

    - name: Run a command with sudo
      command: apt update
      register: sudo_output

    - name: Print sudo command result
      debug:
        msg: "Command ran with sudo: {{ sudo_output.rc == 0 }}"

Speichern Sie diese Datei als ~/project/ansible-sudo-lab/sudo_password_playbook.yml

Ausführen des Playbooks mit Passworteingabe

Wenn Sie ein Playbook als Benutzer ausführen möchten, der ein Sudo-Passwort benötigt, können Sie die Option -K (oder --ask-become-pass) verwenden, um zur Eingabe des Passworts aufgefordert zu werden:

ansible-playbook -i inventory sudo_password_playbook.yml -K

Da wir als Benutzer labex arbeiten, der passwortlosen Sudo-Zugriff hat, werden Sie tatsächlich nicht nach einem Passwort gefragt. In einer Produktionsumgebung, in der passwortloser Sudo nicht konfiguriert ist, würde Ansible Sie jedoch auffordern, das Sudo-Passwort einzugeben.

Um dieses Szenario mit unserem Testbenutzer zu simulieren, können Sie den folgenden Befehl ausführen (obwohl er in dieser Lab-Umgebung aufgrund fehlender SSH-Einrichtung nicht vollständig funktioniert):

ansible-playbook -i inventory sudo_password_playbook.yml -u ansible_test -K

Wenn Sie nach dem BECOME-Passwort gefragt werden, würden Sie ansible123 eingeben.

Angeben des Sudo-Passworts in einer Ansible-Variable

Anstatt das Passwort interaktiv einzugeben, können Sie das Sudo-Passwort als Variable angeben, wenn Sie das Playbook ausführen:

ansible-playbook -i inventory sudo_password_playbook.yml -e "ansible_become_password=ansible123"

Dieser Ansatz ist nützlich für automatisierte Skripte, bei denen eine interaktive Eingabe nicht möglich ist. Er legt das Passwort jedoch in der Befehlszeilenhistorie offen, was ein Sicherheitsrisiko darstellt. In einer Produktionsumgebung sollten Sie Ansible Vault verwenden, um sensible Informationen sicher zu speichern.

Verwendung von Ansible Vault für sicheres Passwortmanagement

Im vorherigen Schritt haben wir verschiedene Möglichkeiten untersucht, Sudo-Passwörter an Ansible-Playbooks zu übergeben. Das Speichern von Passwörtern in Klartextdateien oder deren Übergabe über die Befehlszeile ist jedoch nicht sicher. In diesem Schritt lernen wir, wie man Ansible Vault verwendet, um sensible Informationen wie Sudo-Passwörter sicher zu verwalten.

Was ist Ansible Vault?

Ansible Vault ist eine Funktion, mit der Sie sensible Daten wie Passwörter, API-Schlüssel oder Zertifikate verschlüsseln können. Die verschlüsselten Dateien können sicher in Versionskontrollsystemen gespeichert werden, ohne die sensiblen Informationen preiszugeben. Ansible kann diese Dateien während der Playbook-Ausführung automatisch entschlüsseln.

Erstellen einer verschlüsselten Vault-Datei

Erstellen wir eine verschlüsselte Datei, um unser Sudo-Passwort zu speichern:

cd ~/project/ansible-sudo-lab
ansible-vault create vault.yml

Sie werden aufgefordert, ein neues Vault-Passwort zu erstellen. Geben Sie vaultpassword123 ein und bestätigen Sie es.

Nachdem Sie das Vault-Passwort festgelegt haben, wird ein Editor geöffnet. Geben Sie den folgenden Inhalt in den Editor ein:

---
vault_sudo_password: ansible123

Speichern Sie die Datei und beenden Sie den Editor.

Wenn Sie nun versuchen, den Inhalt der Vault-Datei anzuzeigen, sehen Sie, dass sie verschlüsselt ist:

cat vault.yml

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

$ANSIBLE_VAULT;1.1;AES256
32623438613466396238613731623338376461653866353031313632316237613561393639613131
3562626166616332386265373761653835356134613561380a363761333362323238663136633439
32343032333832313562353261333530666639643239303436643363393630643639316232303564
3962356162356361370a313038333432353162333462323035323262396233333039326535356662
31363539613432656362326565613232336535393232653939323466323131393362

Verwenden von Vault-Variablen in einem Playbook

Erstellen wir nun ein Playbook, das das verschlüsselte Sudo-Passwort verwendet. Erstellen Sie eine neue Datei mit dem Namen secure_sudo_playbook.yml:

---
- name: Playbook with secure sudo password
  hosts: localhost
  become: true
  become_password: "{{ vault_sudo_password }}"
  vars_files:
    - vault.yml

  tasks:
    - name: Get sudo user
      command: whoami
      register: sudo_user

    - name: Print sudo user
      debug:
        msg: "Running as {{ sudo_user.stdout }}"

    - name: Check sudo access
      command: apt update
      register: apt_result
      failed_when: false

    - name: Print result
      debug:
        msg: "Sudo access successful: {{ apt_result.rc == 0 }}"

Speichern Sie diese Datei als ~/project/ansible-sudo-lab/secure_sudo_playbook.yml

Ausführen eines Playbooks mit Vault

Wenn Sie ein Playbook ausführen, das eine verschlüsselte Vault-Datei enthält, müssen Sie das Vault-Passwort angeben. Es gibt verschiedene Möglichkeiten, dies zu tun:

Verwenden der Option --ask-vault-pass:

ansible-playbook -i inventory secure_sudo_playbook.yml --ask-vault-pass

Geben Sie bei Aufforderung das Vault-Passwort ein: vaultpassword123

Verwenden einer Vault-Passwortdatei:

Erstellen Sie zuerst eine Datei, die das Vault-Passwort enthält:

echo "vaultpassword123" > vault_password_file
chmod 600 vault_password_file

Führen Sie dann das Playbook mit der Passwortdatei aus:

ansible-playbook -i inventory secure_sudo_playbook.yml --vault-password-file vault_password_file

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

PLAY [Playbook with secure sudo password] ***************************

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

TASK [Get sudo user] ***********************************************
changed: [localhost]

TASK [Print sudo user] *********************************************
ok: [localhost] => {
    "msg": "Running as root"
}

TASK [Check sudo access] *******************************************
changed: [localhost]

TASK [Print result] ************************************************
ok: [localhost] => {
    "msg": "Sudo access successful: True"
}

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

Best Practices für das Sudo-Passwortmanagement

Hier sind einige Best Practices, die Sie beim Verwalten von Sudo-Passwörtern in Ansible befolgen sollten:

Verwenden Sie immer Ansible Vault, um sensible Informationen zu verschlüsseln
Speichern Sie Vault-Passwörter niemals in der Versionskontrolle
Verwenden Sie eine sichere Methode zur Verteilung von Vault-Passwörtern (z. B. Passwort-Manager)
Erwägen Sie die Verwendung einer Vault-ID für verschiedene Umgebungen (Entwicklung, Staging, Produktion)
Rotieren Sie Vault-Passwörter regelmäßig

In einer Produktionsumgebung können Sie auch die Verwendung eines Tools wie HashiCorp Vault oder AWS Secrets Manager für noch sichereres Geheimnismanagement in Betracht ziehen.

Behebung häufiger Sudo-Passwortprobleme

Auch bei korrekter Konfiguration können Probleme mit Sudo-Passwörtern in Ansible auftreten. In diesem Schritt werden wir häufige Probleme und deren Lösungen untersuchen.

Häufige Sudo-Passwortprobleme

Hier sind einige häufige Probleme, auf die Sie bei der Verwendung von Sudo mit Ansible stoßen können:

Fehlendes Sudo-Passwort: Ansible kann das Sudo-Passwort nicht finden, um privilegierte Befehle auszuführen.
Falsches Sudo-Passwort: Das angegebene Sudo-Passwort ist falsch.
Sudo-Konfigurationsprobleme: Der Zielbenutzer hat nicht die korrekten Sudo-Berechtigungen.
Sudo benötigt ein TTY: Einige Systeme benötigen ein TTY, das für Sudo-Befehle zugewiesen werden muss.

Lassen Sie uns jedes dieser Probleme und deren Lösungen untersuchen.

Erstellen einer problematischen Umgebung zum Testen

Um diese Probleme besser zu verstehen, erstellen wir ein Szenario, in dem Sudo ein TTY benötigt. Bearbeiten Sie die Datei sudoers für unseren Testbenutzer:

sudo cp /etc/sudoers.d/ansible_test /etc/sudoers.d/ansible_test.bak
echo 'Defaults:ansible_test requiretty' | sudo tee -a /etc/sudoers.d/ansible_test

Diese Konfiguration bewirkt, dass Sudo ein TTY benötigt, wenn der Benutzer ansible_test Sudo-Befehle ausführt, was Probleme mit Ansible verursachen kann.

Erstellen eines Playbooks zur Fehlerbehebung

Erstellen Sie ein neues Playbook mit dem Namen troubleshoot_sudo.yml, das einige gängige Techniken zur Fehlerbehebung bei Sudo enthält:

---
- name: Troubleshoot sudo issues
  hosts: localhost
  become: true
  become_method: sudo
  ## We'll provide the become_password when running the playbook

  tasks:
    - name: Check sudo version
      command: sudo --version
      register: sudo_version
      become: false

    - name: Print sudo version
      debug:
        msg: "{{ sudo_version.stdout_lines[0] }}"
      become: false

    - name: Check sudo configuration
      command: sudo -l
      register: sudo_config
      become: false
      failed_when: false

    - name: Print sudo configuration
      debug:
        msg: "{{ sudo_config.stdout_lines }}"
      become: false
      when: sudo_config.rc == 0

    - name: Test sudo command with pty
      command: apt update
      register: sudo_test
      failed_when: false
      vars:
        ansible_become_flags: "-H"

    - name: Print sudo test result
      debug:
        msg: "Sudo command {{ 'succeeded' if sudo_test.rc == 0 else 'failed' }}"

Speichern Sie diese Datei als ~/project/ansible-sudo-lab/troubleshoot_sudo.yml

Ausführen des Playbooks zur Fehlerbehebung

Führen Sie das Playbook zur Fehlerbehebung aus:

ansible-playbook -i inventory troubleshoot_sudo.yml -K

Da wir als Benutzer labex arbeiten, der passwortlosen Sudo-Zugriff hat, sollte das Playbook erfolgreich ausgeführt werden.

Häufige Lösungen für Sudo-Passwortprobleme

Hier sind Lösungen für häufige Sudo-Passwortprobleme:

1. Fehlendes Sudo-Passwort

Wenn Ansible mit einer Meldung wie "Missing sudo password" fehlschlägt, können Sie Folgendes tun:

Verwenden Sie die Option -K, um zur Eingabe des Sudo-Passworts aufgefordert zu werden
Legen Sie die Variable ansible_become_password in Ihrem Inventory oder Playbook fest
Verwenden Sie Ansible Vault, um das Sudo-Passwort sicher zu speichern und bereitzustellen

2. Falsches Sudo-Passwort

Wenn das Sudo-Passwort falsch ist:

Überprüfen Sie das von Ihnen angegebene Passwort noch einmal
Überprüfen Sie, ob das Passwort des Benutzers abgelaufen ist oder geändert wurde
Überprüfen Sie, ob sich die Sudo-Konfiguration auf dem Zielsystem geändert hat

3. Sudo-Konfigurationsprobleme

Wenn der Benutzer nicht die korrekten Sudo-Berechtigungen hat:

Überprüfen Sie die Datei sudoers auf dem Zielsystem
Überprüfen Sie, ob sich der Benutzer in den richtigen Gruppen befindet
Verwenden Sie sudo -l, um die Sudo-Berechtigungen des Benutzers zu überprüfen

4. Sudo benötigt ein TTY

Wenn Sudo ein TTY benötigt:

Fügen Sie ansible_become_flags: "-H" zu Ihrem Playbook oder Inventory hinzu
Ändern Sie die Datei sudoers, um die Option requiretty zu entfernen
Verwenden Sie die Option pty: true in Ihren Tasks

Wiederherstellen der ursprünglichen Sudo-Konfiguration

Stellen wir die ursprüngliche Sudo-Konfiguration für unseren Testbenutzer wieder her:

sudo cp /etc/sudoers.d/ansible_test.bak /etc/sudoers.d/ansible_test
sudo rm /etc/sudoers.d/ansible_test.bak

Dadurch wird die Option requiretty entfernt, die wir zuvor hinzugefügt haben.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie man Sudo-Passwörter in Ansible-Playbooks behandelt, eine häufige Herausforderung für viele Administratoren und DevOps-Ingenieure. Hier ist eine Zusammenfassung dessen, was Sie erreicht haben:

Sie haben Ansible installiert und ein einfaches Playbook erstellt, das Sudo-Berechtigungen verwendet
Sie haben verschiedene Methoden zur Bereitstellung von Sudo-Passwörtern für Ansible-Playbooks kennengelernt
Sie haben Ansible Vault verwendet, um sensible Informationen sicher zu speichern und zu verwalten
Sie haben häufige Sudo-Passwortprobleme untersucht und gelernt, wie man diese behebt

Diese Fähigkeiten helfen Ihnen dabei, sicherere und zuverlässigere Ansible-Playbooks zu erstellen, die verschiedene Sudo-Konfigurationen in verschiedenen Umgebungen verarbeiten können.

Wichtige Erkenntnisse aus diesem Lab:

Verwenden Sie immer sichere Methoden wie Ansible Vault, um sensible Informationen zu speichern
Verstehen Sie die verschiedenen Möglichkeiten, Sudo-Passwörter an Ansible zu übergeben
Wissen Sie, wie Sie häufige Sudo-Passwortprobleme beheben können
Befolgen Sie Best Practices für das Sudo-Passwortmanagement in Ansible

Mit diesen Fähigkeiten können Sie Ansible jetzt sicher für Aufgaben verwenden, die erhöhte Berechtigungen erfordern, und so sicherstellen, dass Ihre Automatisierung reibungslos und sicher abläuft.

Behebung von Problemen mit fehlenden Ansible Sudo-Passwörtern