So legen Sie den Standard-SSH-Benutzer für Ansible-Verbindungen fest

Einführung

Ansible ist ein leistungsstarkes Automatisierungswerkzeug, das die Verwaltung von Remote-Servern vereinfacht. Ein entscheidender Aspekt von Ansible ist die Fähigkeit, sichere SSH-Verbindungen zu diesen Servern herzustellen. In diesem Tutorial werden wir untersuchen, wie man den standardmäßigen SSH-Benutzer für Ansible-Verbindungen festlegt, um einen reibungslosen und effizienten Arbeitsablauf für Ihre Serververwaltungsaufgaben zu gewährleisten.

Installation und Einrichtung von Ansible

Bevor wir den SSH-Benutzer für Ansible konfigurieren, müssen wir sicherstellen, dass Ansible auf unserem System korrekt installiert und eingerichtet ist.

Installation von Ansible

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

sudo apt update
sudo apt install -y ansible

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

ansible --version

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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, x86_64)
  jinja version = 3.0.3
  libyaml = True

Erstellen eines Ansible-Arbeitsverzeichnisses

Als Nächstes erstellen wir eine Verzeichnisstruktur für unser Ansible-Projekt. Dies hilft uns, unsere Dateien organisiert zu halten:

mkdir -p ~/project/ansible/inventory
cd ~/project/ansible

Erstellen einer einfachen Inventory-Datei

Ansible verwendet Inventory-Dateien, um die Hosts zu definieren, die es verwaltet. Erstellen wir eine einfache Inventory-Datei:

echo "[webservers]
localhost ansible_connection=local" > ~/project/ansible/inventory/hosts

Diese Inventory-Datei definiert eine Gruppe namens webservers mit nur einem Host, localhost, und weist Ansible an, für diesen Host eine lokale Verbindung anstelle von SSH zu verwenden.

Überprüfen wir nun unser Inventory:

ansible -i inventory/hosts --list-hosts all

Sie sollten eine Ausgabe wie folgt sehen:

  hosts (1):
    localhost

Dies zeigt, dass Ansible unser Inventory und die darin definierten Hosts erkennt.

Verständnis von Ansible SSH-Verbindungen und -Konfiguration

Ansible verwendet hauptsächlich SSH, um sich mit Remote-Hosts zu verbinden und Befehle auszuführen. Lassen Sie uns untersuchen, wie Ansible SSH-Verbindungen herstellt und wie wir den standardmäßigen SSH-Benutzer konfigurieren können.

Wie Ansible SSH verwendet

Standardmäßig versucht Ansible, Ihren aktuellen Systembenutzer zu verwenden, um SSH-Verbindungen herzustellen. Das bedeutet, wenn Sie als Benutzer labex angemeldet sind und einen Ansible-Befehl ausführen, versucht Ansible, sich als Benutzer labex mit Remote-Hosts zu verbinden.

Dieses Standardverhalten ist möglicherweise nicht immer das, was Sie wollen. Zum Beispiel:

• Der Remote-Server benötigt möglicherweise einen anderen Benutzer für den Zugriff.
• Sie möchten möglicherweise einen dedizierten Benutzer für Automatisierungsaufgaben verwenden.
• Verschiedene Server benötigen möglicherweise unterschiedliche Benutzer.

Ansible-Konfigurationshierarchie

Ansible verwendet eine Hierarchie von Konfigurationsquellen, um zu bestimmen, welcher SSH-Benutzer verwendet werden soll:

1. Befehlszeilenoptionen (höchste Priorität)
2. Aufgabenspezifische Optionen in Playbooks
3. Host- und Gruppenvariablen im Inventory
4. Ansible-Konfigurationsdatei
5. Standardwerte (niedrigste Priorität)

Erstellen wir eine einfache Ansible-Konfigurationsdatei, um dies besser zu verstehen:

cat > ~/project/ansible/ansible.cfg << 'EOF'
[defaults]
inventory = ./inventory/hosts
host_key_checking = False
EOF

Diese Konfigurationsdatei weist Ansible an:

• Standardmäßig unsere Inventory-Datei zu verwenden
• Die Host-Key-Überprüfung zu deaktivieren (nützlich für Tests in Laborumgebungen)

Werfen wir einen Blick auf die Datei, die wir gerade erstellt haben:

cat ~/project/ansible/ansible.cfg

Sie sollten den Inhalt sehen, den wir gerade der Datei hinzugefügt haben.

Testen eines einfachen Ansible-Befehls

Führen wir nun einen einfachen Ansible-Befehl aus, um den aktuellen Benutzer zu sehen:

cd ~/project/ansible
ansible localhost -m command -a "whoami"

Die Ausgabe sollte Folgendes anzeigen:

localhost | CHANGED | rc=0 >>
labex

Dies bestätigt, dass Ansible Befehle als aktueller Benutzer (labex) ausführt.

Festlegen des standardmäßigen SSH-Benutzers für Ansible

Nachdem wir verstanden haben, wie Ansible SSH verwendet, wollen wir verschiedene Möglichkeiten erkunden, um den standardmäßigen SSH-Benutzer für unsere Verbindungen festzulegen.

Methode 1: Verwenden der Ansible-Konfigurationsdatei

Der einfachste Weg, einen globalen Standard-SSH-Benutzer festzulegen, ist über die Ansible-Konfigurationsdatei. Ändern wir unsere ansible.cfg-Datei:

cat > ~/project/ansible/ansible.cfg << 'EOF'
[defaults]
inventory = ./inventory/hosts
host_key_checking = False
remote_user = ansible_user
EOF

In dieser Konfiguration haben wir den Parameter remote_user hinzugefügt, der Ansible anweist, ansible_user als standardmäßigen SSH-Benutzer für alle Verbindungen zu verwenden.

Methode 2: Festlegen des Benutzers in der Inventory-Datei

Ein weiterer Ansatz ist die Definition des SSH-Benutzers in der Inventory-Datei. Mit dieser Methode können Sie verschiedene Benutzer für verschiedene Hosts oder Gruppen festlegen.

Ändern wir unsere Inventory-Datei:

cat > ~/project/ansible/inventory/hosts << 'EOF'
[webservers]
localhost ansible_connection=local

[dbservers]
db.example.com ansible_user=db_admin

[all:vars]
ansible_user=default_user
EOF

In diesem Beispiel:

• Wir haben eine neue Gruppe namens dbservers mit dem Host db.example.com hinzugefügt und angegeben, dass Ansible den Benutzer db_admin verwenden soll, wenn eine Verbindung zu diesem Host hergestellt wird.
• Wir haben auch eine Gruppenvariable ansible_user=default_user hinzugefügt, die für alle Hosts gilt, sofern sie nicht überschrieben wird.

Methode 3: Verwenden von Befehlszeilenoptionen

Sie können den SSH-Benutzer auch direkt in der Befehlszeile angeben, wenn Sie Ansible-Befehle ausführen:

ansible localhost -m command -a "whoami" -u specific_user

Die Option -u weist Ansible an, für diesen spezifischen Befehl specific_user zu verwenden und somit alle in Konfigurationsdateien oder im Inventory definierten Benutzer zu überschreiben.

Methode 4: Festlegen des Benutzers in Playbooks

Bei der Verwendung von Ansible-Playbooks können Sie den SSH-Benutzer auf der Play-Ebene angeben:

Erstellen wir ein einfaches Playbook, um dies zu demonstrieren:

cat > ~/project/ansible/user_demo.yml << 'EOF'
---
- name: Demonstrate user configuration
  hosts: localhost
  remote_user: playbook_user
  
  tasks:
    - name: Show current user
      command: whoami
      register: current_user
      
    - name: Display current user
      debug:
        msg: "Current user is {{ current_user.stdout }}"
EOF

In diesem Playbook legt der Parameter remote_user den SSH-Benutzer für alle Aufgaben in diesem Play auf playbook_user fest.

Benutzerpriorität in Ansible

Das Verständnis der Priorität dieser verschiedenen Methoden ist wichtig:

1. Befehlszeilenoptionen (Flag -u) haben die höchste Priorität
2. Einstellungen auf Task-Ebene in Playbooks
3. Einstellungen auf Play-Ebene in Playbooks
4. Host-Variablen im Inventory
5. Gruppenvariablen im Inventory
6. Einstellungen in der Konfigurationsdatei (remote_user in ansible.cfg)
7. Standard-Systembenutzer (niedrigste Priorität)

Dies bedeutet, dass spezifischere Benutzereinstellungen allgemeinere überschreiben.

Testen und Verifizieren der SSH-Benutzerkonfiguration

Nachdem wir den standardmäßigen SSH-Benutzer auf verschiedene Weise konfiguriert haben, wollen wir unsere Konfiguration testen und verifizieren.

Testen der Konfigurationsdateieinstellung

Zuerst wollen wir einen einfachen Ansible-Befehl ausführen, um zu sehen, ob unsere Konfigurationsdateieinstellungen angewendet werden:

cd ~/project/ansible
ansible localhost -m command -a "whoami"

Da wir uns mit ansible_connection=local mit localhost verbinden, führt Ansible Befehle weiterhin als aktueller Benutzer aus, unabhängig von der Einstellung remote_user. Wenn dies jedoch eine Remote-Verbindung wäre, würde Ansible versuchen, den in der Konfiguration angegebenen Benutzer ansible_user zu verwenden.

Verwenden von ansible-inventory zum Überprüfen der Benutzereinstellungen

Ansible bietet einen Befehl namens ansible-inventory, mit dem wir sehen können, wie Ansible unser Inventory interpretiert, einschließlich der SSH-Benutzereinstellungen:

ansible-inventory --list

Dieser Befehl gibt eine JSON-Darstellung des Inventars aus, die alle Variablen anzeigt, die jedem Host zugeordnet sind, einschließlich der SSH-Benutzereinstellungen.

Testen der Benutzereinstellungen mit einem Playbook

Führen wir das Playbook aus, das wir im vorherigen Schritt erstellt haben:

ansible-playbook user_demo.yml

Die Ausgabe zeigt in etwa Folgendes:

PLAY [Demonstrate user configuration] ******************************************

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

TASK [Show current user] *******************************************************
changed: [localhost]

TASK [Display current user] ****************************************************
ok: [localhost] => {
    "msg": "Current user is labex"
}

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

Die Ausgabe zeigt, dass der Befehl weiterhin als Benutzer labex ausgeführt wird, was erwartet wird, da wir uns mit ansible_connection=local mit localhost verbinden.

Erstellen eines realen SSH-Benutzerkonfigurationsbeispiels

Erstellen wir ein realistischeres Beispiel, das zeigt, wie man die SSH-Benutzerkonfiguration für Remote-Hosts einrichtet. Wir erstellen ein neues Playbook:

cat > ~/project/ansible/remote_user_example.yml << 'EOF'
---
- name: Example of remote user configuration
  hosts: all
  remote_user: admin_user
  
  tasks:
    - name: This task uses the play-level user (admin_user)
      debug:
        msg: "This would run as admin_user"
      
    - name: This task uses a specific user
      debug:
        msg: "This would run as operator_user"
      remote_user: operator_user
      
    - name: This task uses become to elevate privileges
      debug:
        msg: "This would run as the root user"
      become: true
      become_user: root
EOF

In diesem Playbook:

• Wir setzen remote_user: admin_user auf der Play-Ebene, was standardmäßig für alle Aufgaben gilt.
• Die zweite Aufgabe überschreibt dies mit remote_user: operator_user.
• Die dritte Aufgabe verwendet become: true, um die Berechtigungen auf den Benutzer root zu erhöhen.

Dieses Beispiel zeigt die verschiedenen Ebenen, auf denen Sie den SSH-Benutzer in Ansible konfigurieren können.

Erweiterte SSH-Benutzerkonfiguration und Fehlerbehebung

Nachdem wir die Grundlagen des Festlegens des standardmäßigen SSH-Benutzers für Ansible behandelt haben, wollen wir einige erweiterte Techniken und Schritte zur Fehlerbehebung untersuchen.

Verwenden von SSH-Keys mit Ansible

Bei der Verbindung zu Remote-Hosts ist es eine Best Practice, die SSH-Schlüsselauthentifizierung anstelle von Passwörtern zu verwenden. Sehen wir uns an, wie man die SSH-Schlüsselauthentifizierung in Ansible konfiguriert:

cat > ~/project/ansible/ssh_key_example.yml << 'EOF'
---
- name: Example using SSH key authentication
  hosts: all
  remote_user: secure_user
  vars:
    ansible_ssh_private_key_file: ~/.ssh/id_rsa
  
  tasks:
    - name: Show SSH connection details
      debug:
        msg: "Connecting as {{ ansible_user }} using key {{ ansible_ssh_private_key_file }}"
EOF

In diesem Beispiel:

• Wir setzen remote_user: secure_user als standardmäßigen SSH-Benutzer.
• Wir geben die zu verwendende private SSH-Schlüsseldatei mit ansible_ssh_private_key_file an.

Festlegen verschiedener Benutzer für verschiedene Umgebungen

In realen Szenarien möchten Sie möglicherweise verschiedene SSH-Benutzer für verschiedene Umgebungen (Entwicklung, Staging, Produktion) verwenden. Sehen wir uns an, wie man dies erreicht:

mkdir -p ~/project/ansible/group_vars

Erstellen wir nun Gruppenvariablendateien für verschiedene Umgebungen:

cat > ~/project/ansible/group_vars/development << 'EOF'
---
ansible_user: dev_user
EOF

cat > ~/project/ansible/group_vars/production << 'EOF'
---
ansible_user: prod_user
ansible_ssh_private_key_file: ~/.ssh/prod_key
EOF

Aktualisieren Sie die Inventory-Datei, um diese Umgebungsgruppen einzubeziehen:

cat > ~/project/ansible/inventory/hosts << 'EOF'
[webservers]
localhost ansible_connection=local

[development]
dev.example.com

[production]
prod1.example.com
prod2.example.com

[all:vars]
ansible_user=default_user
EOF

Mit dieser Konfiguration:

• Hosts in der Gruppe development verwenden den SSH-Benutzer dev_user.
• Hosts in der Gruppe production verwenden den SSH-Benutzer prod_user und einen spezifischen SSH-Schlüssel.
• Alle anderen Hosts verwenden den SSH-Benutzer default_user.

Fehlerbehebung bei der SSH-Benutzerkonfiguration

Wenn Sie Probleme mit der SSH-Benutzerkonfiguration in Ansible haben, finden Sie hier einige Schritte zur Fehlerbehebung:

1. Überprüfen Sie das von Ansible interpretierte Inventory

Um zu sehen, wie Ansible Ihr Inventory interpretiert, einschließlich aller Variablenwerte:

ansible-inventory --list

2. Führen Sie Ansible mit Verbosity aus

Das Ausführen von Ansible mit erhöhter Verbosity kann helfen, Verbindungsprobleme zu identifizieren:

ansible localhost -m ping -vvv

Das Flag -vvv erhöht die Verbosity-Stufe und zeigt detaillierte Informationen über den SSH-Verbindungsprozess an.

3. Testen Sie die SSH-Verbindung manuell

Sie können die SSH-Verbindung manuell testen, um zu überprüfen, ob der Benutzer und der Schlüssel funktionieren:

ssh -i ~/.ssh/id_rsa username@hostname

4. Überprüfen Sie auf SSH-Verbindungsfehler

Häufige SSH-Verbindungsfehler sind:

• Permission denied (publickey): Dies deutet auf ein Problem mit der SSH-Schlüsselauthentifizierung hin.
• Host key verification failed: Dies tritt auf, wenn sich der Hostschlüssel geändert hat.
• Connection refused: Dies deutet darauf hin, dass der SSH-Dienst nicht ausgeführt wird oder durch eine Firewall blockiert wird.

5. Erstellen Sie ein Ansible-Konfigurationstest-Playbook

Erstellen wir ein einfaches Playbook, um unsere SSH-Benutzerkonfiguration zu testen:

cat > ~/project/ansible/test_ssh_config.yml << 'EOF'
---
- name: Test SSH user configuration
  hosts: all
  gather_facts: no
  
  tasks:
    - name: Display connection information
      debug:
        msg: |
          Connected to: {{ inventory_hostname }}
          User: {{ ansible_user | default('not set') }}
          SSH Key: {{ ansible_ssh_private_key_file | default('not set') }}
EOF

Führen Sie dieses Playbook aus, um die Verbindungsinformationen für jeden Host anzuzeigen:

ansible-playbook -i inventory/hosts test_ssh_config.yml

Dieses Playbook zeigt Ihnen den SSH-Benutzer und den Schlüssel, den Ansible für jeden Host verwendet, was bei der Identifizierung von Konfigurationsproblemen helfen kann.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie den standardmäßigen SSH-Benutzer für Ansible-Verbindungen mit verschiedenen Methoden konfigurieren. Sie verstehen jetzt, wie man:

1. Ansible mit einer grundlegenden Konfiguration installiert und einrichtet
2. Den standardmäßigen SSH-Benutzer über die Ansible-Konfigurationsdatei konfiguriert
3. SSH-Benutzer auf verschiedenen Ebenen festlegt: Inventory, Playbook und Befehlszeile
4. Ihre SSH-Benutzerkonfiguration verifiziert und testet
5. Häufige SSH-Verbindungsprobleme behebt

Diese Fähigkeiten ermöglichen es Ihnen, Ihre Infrastruktur mit Ansible effektiver zu verwalten und sichere und zuverlässige Verbindungen zu Ihren Remote-Servern zu gewährleisten. Durch die korrekte Konfiguration des SSH-Benutzers für Ihre Ansible-Verbindungen können Sie konsistente Automatisierungs-Workflows in verschiedenen Umgebungen implementieren und gleichzeitig angemessene Sicherheitspraktiken beibehalten.