Ansible Anleitung · 11 min read · Dec 20, 2025
Wie man Ansible auf Ubuntu 22.04 installiert und konfiguriert
Ansible ist ein sehr beliebtes Konfigurationsmanagement-Tool, das entwickelt wurde, um den Prozess der Steuerung einer großen Anzahl von Servern zu optimieren. Es kann den Prozess der Einrichtung neuer Server und der Installation von Anwendungen mit einem einzigen Befehl oder einer Datei automatisieren. Sie können so viele Server steuern und Prozesse gleichzeitig von einem einzigen Knoten aus ausführen. Ansible benötigt keine spezielle Software, die auf den Serverknoten installiert werden muss, und kann sie über SSH steuern.
In diesem Leitfaden lernen wir, wie man Ansible auf einem Ubuntu 22.04-Server installiert und konfiguriert.
Voraussetzungen
- Zwei oder mehr Serversysteme, die Ubuntu 22.04 mit installiertem OpenSSH-Server ausführen.
- Sowohl der Server als auch die Knoten sind über öffentliche IP-Adressen zugänglich.
- Ein Nicht-Root-Benutzer mit Sudo-Rechten ist auf dem Ansible-Server eingerichtet, und ein Root-Benutzer mit einem Passwort ist auf den Ansible-Clients eingerichtet.
Schritt 1 - Ansible installieren
Wir werden das offizielle Repository von Ansible verwenden, um die neueste Version zu installieren. Fügen Sie das offizielle Repository von Ansible zum Server hinzu.
$ sudo add-apt-repository ppa:ansible/ansible
Glücklicherweise wird Ubuntu mit Ansible 2.9 ausgeliefert, das wir installieren werden. Führen Sie den folgenden Befehl aus, um Ansible zu installieren.
$ sudo apt install ansible -y
Testen Sie Ihre Installation, indem Sie den folgenden Befehl ausführen.
$ ansible --version
ansible [core 2.13.3rc1]
config file = /etc/ansible/ansible.cfg
configured module search path = ['/home/navjot/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
ansible python module location = /usr/lib/python3/dist-packages/ansible
ansible collection location = /home/navjot/.ansible/collections:/usr/share/ansible/collections
executable location = /usr/bin/ansible
python version = 3.10.4 (main, 29. Jun 2022, 12:14:53) [GCC 11.2.0]
jinja version = 3.0.3
libyaml = True
Installieren und aktivieren Sie das Paket python3-argcomplete, um die Bash-Vervollständigung für Ansible einzurichten.
$ sudo apt install python3-argcomplete
$ sudo activate-global-python-argcomplete3
Sie können jetzt die Tab-Taste drücken, um eine Liste von Optionen für die Bash-Shell zu erhalten.
Schritt 2 - Einrichten der Inventardatei
Um sich mit mehreren Hosts verbinden zu können, benötigen Sie eine Datei, die die Details der Knoten aufzeichnet. Diese Datei wird als Inventardatei bezeichnet.
Je nachdem, wie viele Server Sie steuern möchten, ermöglicht die Inventardatei von Ansible auch, sie in Gruppen und Untergruppen anzuordnen. Sie können auch benutzerdefinierte Variablen festlegen, die für ausgewählte Hosts oder Gruppen gelten, die dann beim Übermitteln der Anweisungen weiterverwendet werden können.
Ansible wird mit einer Standard-Inventardatei geliefert, die unter /etc/ansible/hosts verfügbar ist. Öffnen Sie sie mit dem Nano-Editor.
$ sudo nano /etc/ansible/hosts
Fügen Sie den folgenden Code am Ende der Datei ein.
[servers]
server1 ansible_host=203.0.113.111
server2 ansible_host=203.0.113.112
server3 ansible_host=203.0.113.113
[all:vars]
ansible_python_interpreter=/usr/bin/python3
Der Abschnitt servers definiert die Liste der Knoten, mit denen Sie sich verbinden möchten. Sie können so viele Gruppen erstellen, um Server in mehrere Gruppen anzuordnen.
Die Gruppe all:vars setzt den Parameter ansible_python_interpreter für alle Hosts im Inventar. Sie stellt sicher, dass Ansible das Python 3-Executable anstelle von Python 2 verwendet, das in den neuesten Ubuntu-Versionen entfernt wurde.
Wenn Sie fertig sind, speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie zur Bestätigung Ihrer Änderungen aufgefordert werden.
Hinweis: Sie können Ihre Inventardatei auch an einem beliebigen Ort Ihrer Wahl erstellen, die Sie dann mit dem -i-Parameter beim Ausführen von Ansible-Befehlen übergeben können.
Sie können Ihre Inventarliste mit dem folgenden Befehl überprüfen.
$ ansible-inventory --list -y
all:
children:
servers:
hosts:
server1:
ansible_host: 203.0.113.111
ansible_python_interpreter: /usr/bin/python3
server2:
ansible_host: 203.0.113.112
ansible_python_interpreter: /usr/bin/python3
server3:
ansible_host: 203.0.113.113
ansible_python_interpreter: /usr/bin/python3
ungrouped: {}
Server in Gruppen und Untergruppen organisieren
Dies ist ein nützlicher Tipp, wenn Sie viele Server haben, von denen einige spezifische Funktionen ausführen. Zum Beispiel können Sie diese Methode verwenden, um Webserver und Datenbankserver separat zu gruppieren. Sie können sogar einen Host Teil mehrerer Gruppen machen. Um dies zu erreichen, sollte Ihre Inventardatei etwa wie folgt aussehen.
[webservers]
203.0.113.111
203.0.113.112
[dbservers]
203.0.113.113
server_hostname
[development]
203.0.113.111
203.0.113.113
[production]
203.0.113.112
server_hostname
Schritt 3 - SSH-Schlüssel einrichten
Damit Ansible sich mit den Servern verbinden kann, müssen Sie SSH-Schlüssel zwischen Ihrem Ansible-Server und den in der Inventardatei angegebenen Hosts konfigurieren. Dies funktioniert nur, wenn die Ansible-Clients keinen öffentlichen Schlüssel aktiviert haben und ein Root-Konto mit einem Passwort aktiviert ist.
Verwenden Sie die folgenden Schritte, um einen SSH-Schlüssel für Ansible und seine Knoten zu erstellen und einzurichten.
Erstellen Sie den Schlüssel für Ansible.
$ ssh-keygen -t rsa -b 4096 -C "Ansible key"
Kopieren Sie den öffentlichen Schlüssel auf Ihre Konten auf den Remote-Servern. Dazu verwenden wir den Befehl ssh-copy-id.
$ ssh-copy-id -i $HOME/.ssh/id_rsa.pub [email protected]
$ ssh-copy-id -i $HOME/.ssh/id_rsa.pub [email protected]
$ ssh-copy-id -i $HOME/.ssh/id_rsa.pub [email protected]
Das ist alles. Jetzt sollte Ansible in der Lage sein, mit Ihren Servern zu kommunizieren.
SSH-Schlüssel auf Knoten mit vorhandenem öffentlichem Schlüssel einrichten
Wenn die Clients bereits öffentliche Schlüssel aktiviert haben, müssen Sie einige zusätzliche Schritte befolgen. Dazu müssen Sie auf jedem Knotenserver einen neuen Benutzer erstellen, der nur von Ansible zugänglich ist. Dieser Benutzer hat Sudo-Rechte, die ohne Passwort zugänglich sind, und kann nur von Ihrem Ansible-Server aus zugegriffen werden.
Um einen ansible-Benutzer zu erstellen, führen Sie den folgenden Befehl aus.
$ sudo adduser ansible
Wählen Sie ein sicheres Passwort und lassen Sie alle anderen Felder leer.
Konfigurieren Sie nun den passwortlosen Sudo-Zugriff für diesen Benutzer mit dem folgenden Befehl.
$ echo "ansible ALL=(ALL) NOPASSWD:ALL" | sudo tee /etc/sudoers.d/ansible
Jetzt, da Sie den neuen Benutzer hinzugefügt und konfiguriert haben, können Sie den SSH-Schlüssel von Ihrem Ansible-Server auf den Knotenserver mit dem folgenden Befehl kopieren.
$ ssh-copy-id [email protected]
Sie werden nach dem Passwort für den Ansible-Benutzer gefragt. Geben Sie es ein, und der SSH-Schlüssel wird kopiert.
Als Nächstes deaktivieren Sie die passwortbasierte Anmeldung für den ansible-Benutzer auf dem Knotenserver.
$ sudo usermod -L ansible
Jetzt ist Ihr Knotenserver nur vom Ansible-Server aus zugänglich, da nur dieser Server den öffentlichen Schlüssel dafür hat, und Sie können ihn nicht direkt mit Sudo-Rechten auf dem Knotenserver verwenden, da die Passwortanmeldung deaktiviert ist.
Sie müssen diese Schritte für jeden Knotenserver wiederholen. Ersetzen Sie auch den root-Benutzer durch den ansible-Benutzer in diesem Tutorial.
Schritt 4 - Verbindung testen
Nachdem Sie die Inventardatei und die SSH-Schlüssel eingerichtet haben, sollten wir überprüfen, ob Ansible sich mit den Servern verbinden kann.
Geben Sie den folgenden Befehl ein, um die Verbindung zu überprüfen. Dieser Befehl testet die Verbindung zu allen Servern aus der Inventardatei.
$ ansible all -m ping -u root
Dieser Befehl verwendet das Ping-Modul von Ansible, um einen Konnektivitätstest auf allen Servern durchzuführen. Sie sollten eine Ausgabe wie die folgende erhalten.
server1 | SUCCESS => {
"changed": false,
"ping": "pong"
}
server2 | SUCCESS => {
"changed": false,
"ping": "pong"
}
server3 | SUCCESS => {
"changed": false,
"ping": "pong"
}
Wenn Sie Ansible zum ersten Mal verwenden, werden Sie aufgefordert, die Authentizität aller Server zu bestätigen. Wenn Sie dazu aufgefordert werden, geben Sie yes ein und drücken Sie ENTER, um zu bestätigen.
Schritt 5 - Einige grundlegende Befehle ausführen
Lassen Sie uns einige grundlegende Befehle auf den Servern mit Ansible ausführen. Um einen Befehl auf dem Server auszuführen, wird das folgende Format verwendet.
$ ansible all -a "command" -u
Festplattennutzung überprüfen
Zuerst lassen Sie uns die Festplattennutzung auf allen unseren Servern überprüfen.
$ ansible all -a "df -h" -u root
server1 | CHANGED | rc=0 >>
Filesystem Size Used Avail Use% Mounted on
tmpfs 198M 972K 197M 1% /run
/dev/sda2 50G 3.9G 44G 9% /
tmpfs 989M 0 989M 0% /dev/shm
tmpfs 5.0M 0 5.0M 0% /run/lock
tmpfs 198M 4.0K 198M 1% /run/user/1000
server2 | CHANGED | rc=0 >>
Filesystem Size Used Avail Use% Mounted on
tmpfs 198M 922K 197M 1% /run
/dev/sda2 50G 4.9G 43G 10% /
tmpfs 989M 0 989M 0% /dev/shm
tmpfs 5.0M 0 5.0M 0% /run/lock
tmpfs 198M 4.0K 198M 1% /run/user/1000
Einzelne Hosts und Gruppen anvisieren
Bis jetzt haben wir Befehle auf allen Remote-Servern gleichzeitig ausgeführt. Aber das ist nicht immer der Fall. Um einen Befehl nur auf einem Server auszuführen, sollten Sie das folgende Format verwenden.
$ ansible server1 -a "uptime" -u root
server1 | CHANGED | rc=0 >>
21:38:26 up 11 min, 2 users, load average: 0.00, 0.20, 0.19
Der obige Befehl überprüft die Uptime auf server1 aus der Inventargruppe.
Sie können auch mehrere Server mit dem folgenden Format anvisieren.
$ ansible server1:server2 -m ping -u root
Sie können auch Gruppen oder Untergruppen direkt aus der Inventardatei anvisieren.
$ ansible groupname -m ping -u
Alle Server aktualisieren
Für dieses Tutorial gehen wir davon aus, dass alle Remote-Server Debian oder Ubuntu OS ausführen.
Führen Sie den folgenden Befehl aus, um die Software auf allen Ihren Servern zu aktualisieren.
$ ansible all -m apt -a "update_cache=yes upgrade=yes" -u root
Der Parameter -m definiert das Modul, das Ansible ausführen soll. Der Parameter -a bezieht sich auf die Argumente oder Befehle für das zugehörige Modul. Hier verwenden wir das apt-Modul von Ansible, um Server zu aktualisieren, genau wie wir das ping-Modul in unserem letzten Beispiel verwendet haben. Das update_cache aktualisiert den APT-Cache auf dem Server, und upgrade=yes sagt Ansible, dass es den Befehl apt upgrade ausführen soll.
Wenn Sie den ansible-Benutzer wie oben dokumentiert verwenden, müssen Sie den Ansible-Befehl so ändern, dass er mit erhöhten Sudo-Rechten ausgeführt wird.
$ ansible server2 -m apt -a "update_cache=yes upgrade=yes" -K -b -u ansible
Hier fragt -K nach einem Passwort für die Privilegieneskalation. -b führt die Ansible-Operation mit become aus, was es Ihnen ermöglicht, ein anderer Benutzer zu sein. Beide Variablen zusammen ermöglichen es Ansible, mit erhöhten Sudo-Rechten zu arbeiten. Sie müssen dies für alle Befehle verwenden, die Sudo-Rechte erfordern.
Manchmal können einige dieser Aktualisierungsbefehle einen Neustart erfordern, also führen Sie den folgenden Befehl aus, um alle Ihre Server neu zu starten.
$ ansible all -a "reboot" -u root
Das waren nur einige der grundlegenden Befehle, die Sie mit Ansible ausführen können.
Schritt 6 - Einführung in Playbooks
Die obigen Befehle ermöglichen es Ihnen, einmalige Aufgaben auszuführen, aber wenn Sie mehrere Server einrichten oder die gleiche Befehlsfolge auf mehreren Servern ausführen möchten, müssen Sie Playbooks einrichten. Playbooks sind Dateien, die im YAML-Format geschrieben sind und Anweisungen enthalten, um eine Folge von Aufgaben zur Einrichtung von Anwendungen und Diensten zu automatisieren.
Wir werden jetzt ein Playbook erstellen, um Nginx zu installieren und eine HTML-Seite auf dem Ansible-Knoten einzurichten. Erstellen Sie ein Verzeichnis für Ansible in Ihrem Home-Verzeichnis.
$ mkdir ~/ansible
Erstellen und öffnen Sie die Playbook-Datei zur Bearbeitung.
$ cd ~/ansible
$ nano testplaybook.yml
Playbooks verwenden das YAML-Format, um ein oder mehrere Plays zu definieren. Ein Play ist eine Reihe von geordneten Aufgaben, die so angeordnet sind, dass sie einen Prozess automatisieren. Die Plays werden als YAML-Liste definiert.
Der erste Schritt zur Definition eines Plays besteht darin, festzulegen, welche Hosts das Ziel sind, indem Sie die Direktive hosts: all verwenden. Die Direktive become wird verwendet, um anzugeben, dass die folgenden Aufgaben von einem Superbenutzer ausgeführt werden müssen.
Wir werden drei Aufgaben definieren: eine zum Hinzufügen eines Benutzers, eine zum Aktualisieren aller Pakete und die letzte zum Installieren des Nginx-Servers. Der Abschnitt vars des Playbooks wird verwendet, um benutzerdefinierte Variablen zu definieren. Wir definieren zwei Variablen, eine für den Benutzer, den wir hinzufügen müssen, und die zweite, um den Status des Pakets zu definieren, das wir installieren müssen. Um die Variable zu verwenden, müssen wir den Variablennamen zwischen doppelte geschweifte Klammern setzen.
Das Modul ansible.builtin.user wird verwendet, um einen neuen Benutzer mit Sudo-Rechten hinzuzufügen. Um den Benutzer hinzuzufügen, verwenden wir die Variablen name, password und group. Die Variable group wird auf sudo gesetzt, um dem Benutzer Superuser-Berechtigungen zu geben. Sie können das Klartext-Passwort nicht in der Playbook-Datei angeben, daher fügen wir ein SHA-hashiertes Geheimnis hinzu. Wir verwenden das Dienstprogramm mkpasswd dafür. Um es zu installieren, führen Sie den folgenden Befehl aus, um das Paket whois zu installieren.
$ sudo apt install whois
Generieren Sie das hashierte Passwort. Sie werden nach dem üblichen Passwort gefragt und erhalten einen hashierten String dafür. Notieren Sie sich den hashierten Schlüssel, der in der Playbook-Datei verwendet werden soll.
$ mkpasswd --method=sha-512
Password:
$6$dGbprm2oVqClDDDh$Epk6r5eXYkYBaQpQpP.H7VCdz0g9Aj0aO8hjy/WXq4WmfQ7GvQP2/cl/cNhd7.LRFuCKix9uCF2t8X5/Pv0Lk1
Die Direktive update_cache dient dazu, die Repository-Liste des Systems zu aktualisieren, genau wie der Befehl apt update, und die Direktive upgrade: dist sagt Ansible, dass es das System aktualisieren soll. Die dritte Aufgabe ist selbsterklärend, die die neueste Version des Nginx-Servers installiert.
Basierend auf den Informationen, die wir besprochen haben, fügen Sie den folgenden Code in die Datei ein. Fügen Sie den hashierten Schlüssel, den Sie erhalten haben, als Wert für die Variable password ein.
---
- name: Test playbook
hosts: all
become: true
vars:
state: latest
user: navjot
tasks:
- name: Add the user {{ user }}
ansible.builtin.user:
name: "{{ user }}"
password: '$6$dGbprm2oVqClDDDh$Epk6r5eXYkYBaQpQpP.H7VCdz0g9Aj0aO8hjy/WXq4WmfQ7GvQP2/cl/cNhd7.LRFuCKix9uCF2t8X5/Pv0Lk1'
group: sudo
- name: Upgrade all apt packages
apt:
update_cache: yes
upgrade: dist
- name: Install the {{ state }} of package "nginx"
apt:
name: "nginx"
state: "{{ state }}"
Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie zur Bestätigung Ihrer Änderungen aufgefordert werden.
Um das Playbook auszuführen, führen Sie den folgenden Befehl aus. Das Flag --ask-become-pass fragt nach Ihrem Root-Passwort, um eine erhöhte Operation durchzuführen.
$ ansible-playbook testplaybook.yml --ask-become-pass
Sie erhalten die folgende Ausgabe.
BECOME password:
PLAY [Test playbook] *************************************************************************************************
TASK [Gathering Facts] *********************************************************************************************
ok: [server1]
ok: [server2]
ok: [server3]
TASK [Add the user casablanca] *************************************************************************************
changed: [server3]
changed: [server2]
changed: [server1]
TASK [Upgrade all apt packages] ************************************************************************************
changed: [server1]
changed: [server2]
changed: [server3]
TASK [Install the latest of package "nginx"] ***********************************************************************
changed: [server3]
changed: [server2]
changed: [server1]
PLAY RECAP ***********************************************************************************************************
server1 : ok=4 changed=3 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
server2 : ok=4 changed=3 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
server3 : ok=4 changed=3 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0
Dies bestätigt, dass Ihr Playbook erfolgreich ausgeführt wurde.
Wenn Sie eine benutzerdefinierte Inventardatei verwenden, müssen Sie den Speicherort der Datei im Befehl wie folgt angeben.
$ ansible-playbook -i /etc/ansible/custominventory testplaybook.yml --ask-become-pass
Fazit
Das war unser Tutorial zur Installation und Konfiguration von Ansible auf dem Ubuntu 22.04-Server. Wenn Sie Fragen haben, posten Sie diese in den Kommentaren unten.
Erhalte neue Beiträge in deinem Posteingang.
Kein Spam. Jederzeit abmelden.