SQL erweitert, neu: ansible, Linux umd passwd und shadows erweitert

This commit is contained in:
Sven Riwoldt
2026-08-19 13:50:00 +02:00
parent 2a8733f8f8
commit d696ff35e7
3 changed files with 1226 additions and 11 deletions
+667
View File
@@ -0,0 +1,667 @@
# Ansible Ad-hoc -- Kurzreferenz
Diese Kurzreferenz fasst die besprochenen Ansible-Ad-hoc-Befehle
zusammen: mehrere Rechner direkt ansprechen, speziellen SSH-User
verwenden, Dateien sichern und kopieren, Rechte setzen, Benutzer mit
Home-Verzeichnis anlegen und per `su` statt `sudo` zu `root` wechseln.
## Rechner direkt ansprechen
Ohne Inventory-Datei können Hosts direkt mit `-i` angegeben werden.
Wichtig ist das abschließende Komma.
```bash
ansible all \
-i "server01,server02,server03," \
-m ping
```
Alternativ mit IP-Adressen:
```bash
ansible all \
-i "10.10.1.20,10.10.1.21,10.10.1.22," \
-m ping
```
## Speziellen SSH-User verwenden
Mit `-u` bzw. `--user` wird festgelegt, mit welchem Benutzer Ansible die
SSH-Verbindung aufbaut.
```bash
ansible all \
-i "server01,server02,server03," \
-u deployuser \
-m ping
```
Wenn die SSH-Anmeldung ein Passwort benötigt, zusätzlich `-k` verwenden:
```bash
ansible all \
-i "server01,server02,server03," \
-u deployuser \
-k \
-m ping
```
`-k` fragt das SSH-Passwort des Login-Users ab.
## Datei kopieren, Rechte setzen und Backup erstellen
Das `copy`-Modul kann die Datei verteilen, Owner/Gruppe/Rechte setzen
und gleichzeitig die vorhandene Zieldatei sichern.
```bash
ansible all \
-i "server01,server02,server03," \
-u deployuser \
-m copy \
-a "src=./config.conf dest=/etc/myapp/config.conf owner=root group=root mode=0644 backup=yes"
```
Falls für den Zielpfad erhöhte Rechte benötigt werden, muss zusätzlich
Become verwendet werden.
### Mit sudo
```bash
ansible all \
-i "server01,server02,server03," \
-u deployuser \
-b \
-m copy \
-a "src=./config.conf dest=/etc/myapp/config.conf owner=root group=root mode=0644 backup=yes"
```
Falls `sudo` ein Passwort benötigt:
```bash
ansible all \
-i "server01,server02,server03," \
-u deployuser \
-b -K \
-m copy \
-a "src=./config.conf dest=/etc/myapp/config.conf owner=root group=root mode=0644 backup=yes"
```
## Vorher prüfen mit `--check`
Viele Änderungen können zunächst im Check-Modus getestet werden:
```bash
ansible all \
-i "server01,server02,server03," \
-u deployuser \
-b \
-m copy \
-a "src=./config.conf dest=/etc/myapp/config.conf owner=root group=root mode=0644 backup=yes" \
--check
```
## Neuen User inklusive Home-Verzeichnis anlegen
```bash
ansible all \
-i "server01,server02,server03," \
-u deployuser \
-b \
-m user \
-a "name=newuser state=present create_home=yes shell=/bin/bash"
```
Dabei wird `newuser` angelegt und normalerweise `/home/newuser`
erstellt.
Zum vorherigen Test:
```bash
ansible all \
-i "server01,server02,server03," \
-u deployuser \
-b \
-m user \
-a "name=newuser state=present create_home=yes shell=/bin/bash" \
--check
```
## `su` statt `sudo` verwenden
Wenn auf den Zielsystemen nicht `sudo`, sondern `su` für den Wechsel zu
`root` verwendet werden muss:
```bash
ansible all \
-i "server01,server02,server03," \
-u deployuser \
-b \
--become-method=su \
--become-user=root \
-K \
-m user \
-a "name=newuser state=present create_home=yes shell=/bin/bash"
```
Bedeutung:
- `-u deployuser` -- SSH-Login als `deployuser`
- `-b` -- Become/Privilege Escalation aktivieren
- `--become-method=su` -- `su` statt `sudo` verwenden
- `--become-user=root` -- zu `root` wechseln
- `-K` -- Become-/`su`-Passwort interaktiv abfragen
## `su` zunächst testen
Bevor Änderungen durchgeführt werden, kann geprüft werden, ob der
Wechsel zu `root` funktioniert:
```bash
ansible all \
-i "server01,server02,server03," \
-u deployuser \
-b \
--become-method=su \
--become-user=root \
-K \
-m command \
-a "whoami"
```
Bei erfolgreichem Wechsel sollte jeder Host `root` zurückgeben.
## SSH-Passwort und `su`-Passwort
Wenn sowohl die SSH-Anmeldung als auch `su` ein Passwort benötigen,
müssen `-k` und `-K` verwendet werden:
```bash
ansible all \
-i "server01,server02,server03," \
-u deployuser \
-k \
-b \
--become-method=su \
--become-user=root \
-K \
-m command \
-a "whoami"
```
Dabei gilt:
Option Bedeutung
---------------------- ---------------------------------------
`-u deployuser` SSH-Login-User
`-k` SSH-Passwort des Login-Users abfragen
`-b` Become aktivieren
`--become-method=su` `su` als Become-Methode
`--become-user=root` Zielbenutzer für Become
`-K` Become-/`su`-Passwort abfragen
Bei Verwendung von `-k` und `-K` fragt Ansible typischerweise nach:
```text
SSH password:
BECOME password:
```
Ohne `-k` kann Ansible beispielsweise einen vorhandenen SSH-Key oder
SSH-Agent verwenden und fragt deshalb nicht nach dem SSH-Passwort.
## Komplettbeispiel: Datei mit `su` verteilen
SSH-Anmeldung als `deployuser` per Passwort, anschließend `su` zu
`root`, vorhandene Datei sichern und neue Datei mit korrekten Rechten
verteilen:
```bash
ansible all \
-i "server01,server02,server03," \
-u deployuser \
-k \
-b \
--become-method=su \
--become-user=root \
-K \
-m copy \
-a "src=./config.conf dest=/etc/myapp/config.conf owner=root group=root mode=0644 backup=yes"
```
######################################################################
# Ansible Ad-hoc -- Kurzreferenz
Diese Kurzreferenz fasst die besprochenen Ansible-Ad-hoc-Befehle
zusammen: mehrere Rechner direkt ansprechen, speziellen SSH-User
verwenden, Dateien sichern und kopieren, Rechte setzen, Benutzer mit
Home-Verzeichnis anlegen und per `su` statt `sudo` zu `root` wechseln.
## Rechner direkt ansprechen
Ohne Inventory-Datei können Hosts direkt mit `-i` angegeben werden.
Wichtig ist das abschließende Komma.
```bash
ansible all \
  -i "server01,server02,server03," \
  -m ping
```
Alternativ mit IP-Adressen:
```bash
ansible all \
  -i "10.10.1.20,10.10.1.21,10.10.1.22," \
  -m ping
```
## Speziellen SSH-User verwenden
Mit `-u` bzw. `--user` wird festgelegt, mit welchem Benutzer Ansible die
SSH-Verbindung aufbaut.
```bash
ansible all \
  -i "server01,server02,server03," \
  -u deployuser \
  -m ping
```
Wenn die SSH-Anmeldung ein Passwort benötigt, zusätzlich `-k` verwenden:
```bash
ansible all \
  -i "server01,server02,server03," \
  -u deployuser \
  -k \
  -m ping
```
`-k` fragt das SSH-Passwort des Login-Users ab.
## Datei kopieren, Rechte setzen und Backup erstellen
Das `copy`-Modul kann die Datei verteilen, Owner/Gruppe/Rechte setzen
und gleichzeitig die vorhandene Zieldatei sichern.
```bash
ansible all \
  -i "server01,server02,server03," \
  -u deployuser \
  -m copy \
  -a "src=./config.conf dest=/etc/myapp/config.conf owner=root group=root mode=0644 backup=yes"
```
Falls für den Zielpfad erhöhte Rechte benötigt werden, muss zusätzlich
Become verwendet werden.
### Mit sudo
```bash
ansible all \
  -i "server01,server02,server03," \
  -u deployuser \
  -b \
  -m copy \
  -a "src=./config.conf dest=/etc/myapp/config.conf owner=root group=root mode=0644 backup=yes"
```
Falls `sudo` ein Passwort benötigt:
```bash
ansible all \
  -i "server01,server02,server03," \
  -u deployuser \
  -b -K \
  -m copy \
  -a "src=./config.conf dest=/etc/myapp/config.conf owner=root group=root mode=0644 backup=yes"
```
## Vorher prüfen mit `--check`
Viele Änderungen können zunächst im Check-Modus getestet werden:
```bash
ansible all \
  -i "server01,server02,server03," \
  -u deployuser \
  -b \
  -m copy \
  -a "src=./config.conf dest=/etc/myapp/config.conf owner=root group=root mode=0644 backup=yes" \
  --check
```
## Neuen User inklusive Home-Verzeichnis anlegen
```bash
ansible all \
  -i "server01,server02,server03," \
  -u deployuser \
  -b \
  -m user \
  -a "name=newuser state=present create_home=yes shell=/bin/bash"
```
Dabei wird `newuser` angelegt und normalerweise `/home/newuser`
erstellt.
Zum vorherigen Test:
```bash
ansible all \
  -i "server01,server02,server03," \
  -u deployuser \
  -b \
  -m user \
  -a "name=newuser state=present create_home=yes shell=/bin/bash" \
  --check
```
## `su` statt `sudo` verwenden
Wenn auf den Zielsystemen nicht `sudo`, sondern `su` für den Wechsel zu
`root` verwendet werden muss:
```bash
ansible all \
  -i "server01,server02,server03," \
  -u deployuser \
  -b \
  --become-method=su \
  --become-user=root \
  -K \
  -m user \
  -a "name=newuser state=present create_home=yes shell=/bin/bash"
```
Bedeutung:
-   `-u deployuser` -- SSH-Login als `deployuser`
-   `-b` -- Become/Privilege Escalation aktivieren
-   `--become-method=su` -- `su` statt `sudo` verwenden
-   `--become-user=root` -- zu `root` wechseln
-   `-K` -- Become-/`su`-Passwort interaktiv abfragen
## `su` zunächst testen
Bevor Änderungen durchgeführt werden, kann geprüft werden, ob der
Wechsel zu `root` funktioniert:
```bash
ansible all \
  -i "server01,server02,server03," \
  -u deployuser \
  -b \
  --become-method=su \
  --become-user=root \
  -K \
  -m command \
  -a "whoami"
```
Bei erfolgreichem Wechsel sollte jeder Host `root` zurückgeben.
## SSH-Passwort und `su`-Passwort
Wenn sowohl die SSH-Anmeldung als auch `su` ein Passwort benötigen,
müssen `-k` und `-K` verwendet werden:
```bash
ansible all \
  -i "server01,server02,server03," \
  -u deployuser \
  -k \
  -b \
  --become-method=su \
  --become-user=root \
  -K \
  -m command \
  -a "whoami"
```
Dabei gilt:
  Option                 Bedeutung
  ---------------------- ---------------------------------------
  `-u deployuser`        SSH-Login-User
  `-k`                   SSH-Passwort des Login-Users abfragen
  `-b`                   Become aktivieren
  `--become-method=su`   `su` als Become-Methode
  `--become-user=root`   Zielbenutzer für Become
  `-K`                   Become-/`su`-Passwort abfragen
Bei Verwendung von `-k` und `-K` fragt Ansible typischerweise nach:
```text
SSH password:
BECOME password:
```
Ohne `-k` kann Ansible beispielsweise einen vorhandenen SSH-Key oder
SSH-Agent verwenden und fragt deshalb nicht nach dem SSH-Passwort.
## Komplettbeispiel: Datei mit `su` verteilen
SSH-Anmeldung als `deployuser` per Passwort, anschließend `su` zu
`root`, vorhandene Datei sichern und neue Datei mit korrekten Rechten
verteilen:
```bash
ansible all \
  -i "server01,server02,server03," \
  -u deployuser \
  -k \
  -b \
  --become-method=su \
  --become-user=root \
  -K \
  -m copy \
  -a "src=./config.conf dest=/etc/myapp/config.conf owner=root group=root mode=0644 backup=yes"
```
## Benutzer ohne nutzbares Passwort (`!!` in `/etc/shadow`)
Mit dem Ansible-`user`-Modul kann das Passwort eines Accounts mit `password_lock=yes` gesperrt werden:
```bash
ansible all \
  -i "server01,server02,server03," \
  -u deployuser \
  -k \
  -b \
  --become-method=su \
  --become-user=root \
  -K \
  -m user \
  -a "name=newuser state=present create_home=yes shell=/bin/bash password_lock=yes"
```
Auf üblichen Linux-Systemen ist das Passwortfeld damit gesperrt. Bei einem neu angelegten Benutzer kann `/etc/shadow` beispielsweise `newuser:!!:...` enthalten. Das genaue Sperrkennzeichen kann je nach Distribution und Ausgangszustand variieren.
### Bedeutung von `-m user` und `name=newuser`
| Ausdruck | Bedeutung |
|---|---|
| `-m user` | Ansible-Modul `user` verwenden |
| `name=newuser` | Benutzer `newuser` verwalten bzw. anlegen |
| `state=present` | Sicherstellen, dass der Benutzer existiert |
| `create_home=yes` | Home-Verzeichnis anlegen |
| `shell=/bin/bash` | Bash als Login-Shell setzen |
| `password_lock=yes` | Passwort des Accounts sperren |
Wichtig: `-m` bezeichnet bei Ansible das **Modul**. Der Name des neuen Benutzers steht hinter `name=`.
Beispiel für `appuser`:
```bash
ansible all \
  -i "server01,server02,server03," \
  -u deployuser \
  -k \
  -b \
  --become-method=su \
  --become-user=root \
  -K \
  -m user \
  -a "name=appuser state=present create_home=yes shell=/bin/bash password_lock=yes"
```
Nicht mit `useradd` verwechseln: Bei `useradd -m appuser` bedeutet `-m`, dass das Home-Verzeichnis erstellt wird. Bei `ansible ... -m user` wählt `-m` dagegen das Ansible-Modul aus.
## Benutzer ohne Ansible anlegen
Direkt auf Linux:
```bash
useradd -m -s /bin/bash newuser
```
Passwortstatus bzw. Shadow-Eintrag prüfen:
```bash
passwd -S newuser
grep '^newuser:' /etc/shadow
```
Passwort explizit sperren:
```bash
passwd -l newuser
```
`passwd -l` sperrt einen vorhandenen Passwort-Hash durch ein vorangestelltes `!`. Der exakte Inhalt in `/etc/shadow` muss daher nicht zwingend exakt `!!` sein.