0Pricing
Linux Command Line & Bash Scripting Mastery · Lektion

Bereitstellung von Benutzern und Gruppen automatisieren

Erstellen, ändern und prüfen Sie Konten in großen Mengen mit useradd, chage und der Verwaltung von sudoers-Fragmenten.

Bereitstellung von Benutzern und Gruppen automatisieren ist eine kostenlose Linux Command Line & Bash Scripting Mastery-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Linux Command Line & Bash Scripting Mastery-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Linux Command Line & Bash Scripting Mastery-Kurs umfasst insgesamt 4 Lektionen.

Warum die Benutzerbereitstellung automatisieren?

Die Verwaltung von Benutzern mit useradd einzeln funktioniert bei einer Handvoll Konten gut, doch in Unternehmensumgebungen werden regelmäßig Dutzende oder Hunderte Benutzer gleichzeitig angelegt. Manuelle Befehle sind fehleranfällig, uneinheitlich und nicht revisionssicher.

Mit Bash-Skripten können Sie:

  • Benutzer jedes Mal mit standardisierten Einstellungen (Shell, Home-Verzeichnis, Passwortrichtlinie) anlegen
  • Eine CSV- oder Textdatei mit neuen Mitarbeitenden einlesen und sie in einem einzigen Durchlauf bereitstellen
  • Jede Aktion protokollieren, sodass für Compliance-Zwecke ein Prüfpfad vorhanden ist
  • Konfigurationsmanagement-Pipelines (Ansible, Chef, Jenkins) integrieren

In dieser Lektion erstellen Sie von Grund auf ein produktionsreifes Skript zur Benutzerbereitstellung. Dabei behandeln Sie useradd, chage, usermod, die Gruppenverwaltung, sudoers-Drop-ins und die Prüfung nach der Ausführung.

Eine Benutzerliste gesammelt einlesen

Das standardmäßige Eingabeformat für die Bereitstellung mehrerer Benutzer ist eine durch Trennzeichen strukturierte Textdatei — ein Datensatz pro Zeile. Eine typische CSV-Datei könnte so aussehen:

username,full_name,group,shell
alice,Alice Smith,developers,/bin/bash
bob,Bob Jones,ops,/bin/zsh

Verwenden Sie IFS und read innerhalb einer while-Schleife, um die Datei sicher zu analysieren. Wenn Sie die Kopfzeile mit tail -n +2 überspringen, bleibt die Logik übersichtlich.

Wichtige Schutzmaßnahmen:

  • Entfernen Sie führende und nachgestellte Leerzeichen aus jedem Feld
  • Überspringen Sie leere Zeilen und Kommentarzeilen, die mit # beginnen
  • Prüfen Sie vor dem Aufruf von Systembefehlen, dass Pflichtfelder nicht leer sind
#!/usr/bin/env bash
# parse_users.sh — safely read a CSV of users
set -euo pipefail

USER_FILE="${1:-users.csv}"

[[ -f "$USER_FILE" ]] || { echo "ERROR: $USER_FILE not found"; exit 1; }

tail -n +2 "$USER_FILE" | while IFS=',' read -r username full_name group shell; do
  # trim whitespace
  username="${username// /}"
  [[ -z "$username" || "$username" == \#* ]] && continue

  echo "Parsed -> user=$username group=$group shell=$shell"
done

Benutzer mit useradd anlegen

useradd ist das Dienstprogramm auf niedriger Ebene, das in /etc/passwd, /etc/shadow und /etc/group schreibt. Die wichtigsten Optionen für Skripte sind:

  • -m — das Home-Verzeichnis anlegen
  • -s — die Login-Shell festlegen
  • -c — das GECOS-Kommentarfeld (vollständiger Name)
  • -G — zusätzliche Gruppen (durch Kommas getrennt)
  • -e — Ablaufdatum des Kontos (YYYY-MM-DD)

Prüfen Sie immer mit id, ob der Benutzer bereits vorhanden ist, bevor Sie useradd aufrufen. Bei einem vorhandenen Benutzer wird der Exit-Code 9 zurückgegeben und eine Fehlermeldung ausgegeben, die die Protokolle unnötig füllen kann.

Hinweis: useradd erfordert Root-Rechte. Fügen Sie am Anfang Ihres Skripts eine Prüfung der Berechtigungen ein.

#!/usr/bin/env bash
# create_user.sh — idempotent single-user creation
set -euo pipefail

[[ $EUID -ne 0 ]] && { echo "Must run as root"; exit 1; }

USERNAME="$1"
FULL_NAME="${2:-}"
GROUP="${3:-staff}"
SHELL="${4:-/bin/bash}"

if id "$USERNAME" &>/dev/null; then
  echo "[SKIP] User $USERNAME already exists"
else
  useradd \
    --create-home \
    --shell "$SHELL" \
    --comment "$FULL_NAME" \
    --groups "$GROUP" \
    "$USERNAME"
  echo "[OK] Created $USERNAME"
fi

Erste Passwörter sicher festlegen

Hinterlegen Sie niemals Passwörter fest im Skript. Für die Bereitstellung mehrerer Benutzer gibt es zwei sichere Ansätze:

  • Ein zufälliges Initialpasswort erzeugen mit openssl rand oder /dev/urandom, es einmalig ausgeben und den Benutzer zwingen, es bei der ersten Anmeldung zu ändern
  • Ein vorab gehashtes Passwort festlegen mit usermod -p und einem SHA-512-Hash, damit der Klartext niemals in der Prozessliste erscheint

chpasswd ist das empfohlene Werkzeug zum Festlegen von Passwörtern in Skripten — es liest username:password-Paare von stdin, sodass das Passwort nicht in den Befehlszeilenargumenten erscheint (die über ps sichtbar wären).

Verwenden Sie nach dem Festlegen des Passworts chage -d 0, um bei der nächsten Anmeldung eine sofortige Passwortänderung zu erzwingen.

#!/usr/bin/env bash
# set_temp_password.sh
set -euo pipefail

[[ $EUID -ne 0 ]] && { echo "Must run as root"; exit 1; }

USERNAME="$1"

# Generate a 16-char random password (alphanumeric only)
TMP_PASS=$(tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 16)

# Set password via chpasswd (password never in argv)
echo "${USERNAME}:${TMP_PASS}" | chpasswd

# Force password change on next login
chage -d 0 "$USERNAME"

echo "[OK] Temporary password for $USERNAME: $TMP_PASS"
echo "[OK] User must change password on first login"

Passwortalterung mit chage verwalten

chage (change age) steuert die in /etc/shadow gespeicherte Richtlinie zur Passwortalterung. Sicherheitsrichtlinien in Unternehmen schreiben typischerweise Folgendes vor:

  • Maximales Passwortalter (z. B. 90 Tage)
  • Mindestanzahl an Tagen, bevor ein Passwort erneut geändert werden kann
  • Warnzeitraum vor dem Ablauf
  • Sperrung des Kontos nach einer bestimmten Inaktivitätsdauer seit der letzten Passwortverwendung

Wichtige Optionen von chage:

  • -M <days> — maximales Passwortalter
  • -m <days> — Mindestalter des Passworts
  • -W <days> — Anzahl der Warntage vor dem Ablauf
  • -I <days> — Anzahl der Inaktivitätstage bis zur Kontosperrung
  • -E <date> — absolutes Ablaufdatum des Kontos
  • -l — aktuelle Einstellungen eines Benutzers auflisten
#!/usr/bin/env bash
# apply_password_policy.sh — enforce org-wide ageing policy
set -euo pipefail

[[ $EUID -ne 0 ]] && { echo "Must run as root"; exit 1; }

# Policy constants
MAX_AGE=90
MIN_AGE=1
WARN_DAYS=14
INACTIVE_DAYS=30

apply_policy() {
  local user="$1"
  chage \
    -M "$MAX_AGE" \
    -m "$MIN_AGE" \
    -W "$WARN_DAYS" \
    -I "$INACTIVE_DAYS" \
    "$user"
  echo "[OK] Policy applied to $user"
}

# Apply to all non-system users (UID >= 1000)
awk -F: '$3 >= 1000 && $3 < 65534 { print $1 }' /etc/passwd | while read -r user; do
  apply_policy "$user"
done

Gruppen gesammelt verwalten

Gruppen sind der wichtigste Mechanismus zur Steuerung des Ressourcenzugriffs. Ein Bereitstellungsskript muss sicherstellen, dass erforderliche Gruppen vorhanden sind, bevor Benutzer ihnen hinzugefügt werden — useradd -G nonexistent schlägt andernfalls fehl.

Verwenden Sie groupadd idempotent, indem Sie den Exit-Code prüfen: Bei einer bereits vorhandenen Gruppe wird 9 zurückgegeben. Der Ausdruck getent group <name> ist eine portable und gut lesbare Alternative zur Suche mit grep in /etc/group.

gpasswd -a fügt einen Benutzer einer Gruppe hinzu, ohne vorhandene Mitgliedschaften zu ersetzen (anders als usermod -G, das die Liste der zusätzlichen Gruppen ersetzt).

#!/usr/bin/env bash
# ensure_groups.sh — create groups if missing, then add users
set -euo pipefail

[[ $EUID -ne 0 ]] && { echo "Must run as root"; exit 1; }

REQUIRED_GROUPS=(developers ops security auditors)

for grp in "${REQUIRED_GROUPS[@]}"; do
  if getent group "$grp" &>/dev/null; then
    echo "[SKIP] Group $grp already exists"
  else
    groupadd "$grp"
    echo "[OK] Created group $grp"
  fi
done

# Safely add a user to a group (append, don't replace)
add_to_group() {
  local user="$1" group="$2"
  gpasswd -a "$user" "$group" 2>/dev/null && echo "[OK] $user -> $group"
}

Vollständiges Skript zur Sammelbereitstellung

Alles zusammengeführt: Ein einziges Skript liest eine CSV-Datei ein, legt Benutzer und Gruppen an, setzt die Passwortrichtlinie, protokolliert jede Aktion und behandelt Fehler ordnungsgemäß, ohne die gesamte Verarbeitung abzubrechen.

Wichtige Designentscheidungen im folgenden Skript:

  • Eine LOG_FILE-Datei mit Zeitstempeln erfasst alle Vorgänge zur Prüfung
  • Fehler bei einzelnen Benutzern werden protokolliert, brechen die Schleife jedoch nicht ab (|| log_error)
  • Das Skript ist idempotent — es kann nach teilweise fehlgeschlagenen Durchläufen sicher erneut ausgeführt werden
  • Alle Ausgaben werden über tee sowohl an das Terminal als auch an die Protokolldatei gesendet
#!/usr/bin/env bash
# bulk_provision.sh — production user provisioning
set -uo pipefail

[[ $EUID -ne 0 ]] && { echo "Must run as root"; exit 1; }

USER_FILE="${1:-users.csv}"
LOG_FILE="/var/log/user_provision_$(date +%F).log"

log()  { echo "[$(date '+%F %T')] $*" | tee -a "$LOG_FILE"; }
err()  { log "ERROR: $*"; }

log "=== Provisioning started from $USER_FILE ==="

tail -n +2 "$USER_FILE" | while IFS=',' read -r username fullname group shell; do
  username="${username// /}"
  [[ -z "$username" || "$username" == \#* ]] && continue
  group="${group:-staff}"
  shell="${shell:-/bin/bash}"

  # Ensure group exists
  getent group "$group" &>/dev/null || groupadd "$group"

  # Create user idempotently
  if id "$username" &>/dev/null; then
    log "[SKIP] $username exists"
  else
    useradd -m -s "$shell" -c "$fullname" -G "$group" "$username" || { err "useradd failed for $username"; continue; }
    TMP="$(tr -dc 'A-Za-z0-9' < /dev/urandom | head -c 14)"
    echo "${username}:${TMP}" | chpasswd
    chage -M 90 -m 1 -W 14 -I 30 -d 0 "$username"
    log "[OK] $username created (group=$group) tmp_pass=$TMP"
  fi
done

log "=== Provisioning complete ==="

Drop-in-Fragmente für sudoers verwalten

Das direkte Bearbeiten von /etc/sudoers ist gefährlich — ein Syntaxfehler sperrt alle Benutzer von sudo aus. Der sichere Ansatz besteht darin, Drop-in-Dateien in /etc/sudoers.d/ zu verwenden und jede Datei mit visudo -c -f zu prüfen, bevor sie installiert wird.

Bewährte Verfahren für sudoers-Fragmente:

  • Benennen Sie Dateien nach dem Team oder der Rolle, für die sie Berechtigungen gewähren (z. B. 10-developers, 20-ops)
  • Verwenden Sie gruppenbasierte Regeln (%developers ALL=(ALL) NOPASSWD: /usr/bin/systemctl) statt zeilenweiser Regeln für einzelne Benutzer
  • Setzen Sie die Berechtigungen immer auf 0440 und den Eigentümer auf root:root
  • Prüfen Sie mit visudo -c — bei jedem Syntaxfehler wird ein Wert ungleich null zurückgegeben
#!/usr/bin/env bash
# write_sudoers_fragment.sh
set -euo pipefail

[[ $EUID -ne 0 ]] && { echo "Must run as root"; exit 1; }

FRAGMENT_NAME="${1:-10-developers}"
SUDOERS_DIR="/etc/sudoers.d"
TMP_FILE="$(mktemp)"

# Write the fragment to a temp file first
cat > "$TMP_FILE" << 'EOF'
# Developers: restart services and view journals without full root
%developers ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart *, /usr/bin/journalctl
%ops        ALL=(ALL) NOPASSWD: ALL
EOF

# Validate BEFORE installing
if visudo -c -f "$TMP_FILE"; then
  install -m 0440 -o root -g root "$TMP_FILE" "${SUDOERS_DIR}/${FRAGMENT_NAME}"
  echo "[OK] Installed ${SUDOERS_DIR}/${FRAGMENT_NAME}"
else
  echo "[ERROR] sudoers syntax check failed — fragment NOT installed"
  rm -f "$TMP_FILE"
  exit 1
fi
rm -f "$TMP_FILE"

Vorhandene Konten prüfen

Nach der Bereitstellung und regelmäßig danach sollten Sie die Benutzerdatenbank auf Auffälligkeiten prüfen:

  • Konten mit UID 0 — jedes Konto mit UID 0 außer root ist ein kritischer Sicherheitsfund
  • Konten ohne Passwort — Einträge mit einem leeren Passwortfeld oder einem Passwortfeld mit ! in /etc/shadow
  • Abgelaufene, aber weiterhin aktive Konten — die Ausgabe von chage -l kann gesammelt ausgewertet werden
  • Benutzer mit Shell, aber ohne Home-Verzeichnis — eine Fehlkonfiguration, die die Anmeldung verhindert

Mit mail oder durch Anhängen an einen überwachten Protokollpfad lässt sich problemlos ein strukturierter Bericht erstellen und an das Sicherheitsteam senden.

#!/usr/bin/env bash
# audit_users.sh — produce a security-relevant user report
set -uo pipefail

REPORT="/var/log/user_audit_$(date +%F).txt"

echo "=== User Audit Report $(date) ===" > "$REPORT"

echo "" >> "$REPORT"
echo "--- Accounts with UID 0 (should be root only) ---" >> "$REPORT"
awk -F: '$3 == 0 { print $1 }' /etc/passwd >> "$REPORT"

echo "" >> "$REPORT"
echo "--- Accounts with empty password field ---" >> "$REPORT"
awk -F: '($2 == "" || $2 == "!") && $3 >= 1000 { print $1 }' /etc/shadow 2>/dev/null >> "$REPORT" || echo "  (requires root)" >> "$REPORT"

echo "" >> "$REPORT"
echo "--- Normal users (UID 1000-60000) ---" >> "$REPORT"
awk -F: '$3 >= 1000 && $3 < 60000 { printf "%-20s uid=%-6s shell=%s\n", $1, $3, $7 }' /etc/passwd >> "$REPORT"

cat "$REPORT"
echo "Report saved to $REPORT"

Konten sperren, entsperren und entfernen

Das Offboarding ist ebenso wichtig wie das Onboarding. Wenn ein Benutzer das Unternehmen verlässt, ist die richtige Reihenfolge:

  1. Konto sofort sperren (usermod -L) — fügt dem Passwort-Hash in shadow ein ! voran und verhindert die Anmeldung, ohne Daten zu löschen
  2. sudo-Berechtigung entziehen — das zugehörige sudoers-Fragment entfernen, falls eines vorhanden ist
  3. Eigentümerschaft an den Dateien auf ein Manager- oder Archivkonto übertragen
  4. Das Home-Verzeichnis vor dem Löschen als Tarball archivieren
  5. Mit userdel -r löschen — dabei werden Home-Verzeichnis und Mail-Spool entfernt

usermod -U entsperrt ein Konto (entfernt das Präfix !) und eignet sich für eine vorübergehende Sperrung.

#!/usr/bin/env bash
# offboard_user.sh — lock, archive, then optionally delete
set -euo pipefail

[[ $EUID -ne 0 ]] && { echo "Must run as root"; exit 1; }

USERNAME="$1"
ARCHIVE_DIR="/srv/archived-homes"
mkdir -p "$ARCHIVE_DIR"

# 1. Lock account
usermod -L "$USERNAME"
echo "[OK] Account $USERNAME locked"

# 2. Remove sudoers fragment if present
SUDOERS_FILE="/etc/sudoers.d/${USERNAME}"
[[ -f "$SUDOERS_FILE" ]] && rm -f "$SUDOERS_FILE" && echo "[OK] Removed sudoers fragment"

# 3. Archive home directory
HOME_DIR="$(getent passwd "$USERNAME" | cut -d: -f6)"
if [[ -d "$HOME_DIR" ]]; then
  tar -czf "${ARCHIVE_DIR}/${USERNAME}_$(date +%F).tar.gz" -C "$(dirname "$HOME_DIR")" "$(basename "$HOME_DIR")"
  echo "[OK] Home archived to ${ARCHIVE_DIR}/${USERNAME}_$(date +%F).tar.gz"
fi

echo "[NOTICE] Review archive, then run: userdel -r $USERNAME"

Das Skript mit einem Dry-Run-Modus testen

Produktionsskripte zur Bereitstellung müssen ohne Seiteneffekte testbar sein. Implementieren Sie einen Dry-Run-Modus mit einem DRY_RUN-Flag, das alle verändernden Befehle durch echo-Platzhalter ersetzt.

Das Muster ist einfach: Definieren Sie eine Hilfsfunktion run(), die den Befehl abhängig vom Flag entweder ausführt oder ausgibt. Dadurch gilt:

  • Jeder Ausführungspfad wird während des Tests durchlaufen
  • Die Ausgabe zeigt genau, was bei einer produktiven Ausführung geschehen würde
  • CI-Pipelines können die Logik ohne Root-Zugriff prüfen

Ergänzen Sie den Dry-Run durch ein spezielles Präfix für Testbenutzer (z. B. test_), damit diese nach Integrationstests leicht bereinigt werden können.

#!/usr/bin/env bash
# provision_with_dryrun.sh
set -euo pipefail

DRY_RUN="${DRY_RUN:-false}"

# Wrapper: execute or echo
run() {
  if [[ "$DRY_RUN" == "true" ]]; then
    echo "[DRY-RUN] $*"
  else
    "$@"
  fi
}

create_user() {
  local user="$1" group="$2"
  if id "$user" &>/dev/null; then
    echo "[SKIP] $user exists"
    return
  fi
  run useradd -m -s /bin/bash -G "$group" "$user"
  run chage -M 90 -m 1 -W 14 -d 0 "$user"
  echo "[OK] $user provisioned (dry=$DRY_RUN)"
}

# Test run
DRY_RUN=true create_user testuser developers
echo "---"
create_user realuser developers 2>/dev/null || true

Welchen Befehl sollten Sie verwenden, um einen Benutzer einer zusätzlichen Gruppe hinzuzufügen, ohne vorhandene Gruppenmitgliedschaften zu entfernen?

In einem Skript zur Sammelbereitstellung müssen Sie einen vorhandenen Benutzer der Gruppe auditors zuweisen. Der Benutzer ist bereits Mitglied der Gruppen developers und staff. Welcher Befehl behält alle vorhandenen Mitgliedschaften bei und fügt die neue hinzu?

Lektionsrückblick: Benutzer- und Gruppenbereitstellung automatisieren

In dieser Lektion haben Sie ein vollständiges, produktionsreifes Toolkit zur Benutzerbereitstellung erstellt. Die wichtigsten Erkenntnisse:

  • Eingaben defensiv analysieren — verwenden Sie IFS/read-Schleifen, überspringen Sie leere Zeilen und Kommentare und prüfen Sie die Felder vor jedem Systemaufruf
  • Grundlagen von useradd — verwenden Sie immer -m (Home), -s (Shell), -c (Kommentar) und -G (Gruppen); prüfen Sie für Idempotenz zuerst mit id, ob der Benutzer vorhanden ist
  • Passwörter — setzen Sie sie über stdin von chpasswd, damit der Klartext nicht in den Prozessargumenten erscheint; erzwingen Sie die Änderung bei der ersten Anmeldung mit chage -d 0
  • chage für Richtlinien — standardisieren Sie maximales Passwortalter (-M), Warntage (-W) und Inaktivitätssperre (-I) für alle Nicht-Systemkonten
  • Gruppenmitgliedschaft — verwenden Sie gpasswd -a oder usermod -aG (mit dem Flag -a), um Mitgliedschaften zu ergänzen statt zu ersetzen
  • sudoers-Drop-ins — schreiben Sie nach /etc/sudoers.d/, prüfen Sie mit visudo -c -f, bevor Sie die Datei installieren, und setzen Sie die Berechtigungen auf 0440 root:root
  • Offboarding — sperren (usermod -L), Home-Verzeichnis archivieren und anschließend löschen; überspringen Sie niemals die Archivierung
  • Dry-Run-Modus — kapseln Sie verändernde Befehle in einer Hilfsfunktion run(), damit Pipelines die Logik ohne Root-seitige Auswirkungen prüfen können

Durch die Kombination dieser Muster erhalten Sie eine wiederholbare, revisionssichere und sichere Automatisierungsschicht für das Linux-Identitätsmanagement in jeder Größenordnung.

Häufig gestellte Fragen

Ist die Lektion „Bereitstellung von Benutzern und Gruppen automatisieren“ kostenlos?

Ja — der vollständige Text von „Bereitstellung von Benutzern und Gruppen automatisieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Linux Command Line & Bash Scripting Mastery-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Linux Command Line & Bash Scripting Mastery-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Bereitstellung von Benutzern und Gruppen automatisieren“?

Erstellen, ändern und prüfen Sie Konten in großen Mengen mit useradd, chage und der Verwaltung von sudoers-Fragmenten. Du übst Linux Command Line & Bash Scripting Mastery mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Linux Command Line & Bash Scripting Mastery zu starten?

Keine Vorkenntnisse erforderlich. Linux Command Line & Bash Scripting Mastery auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Bereitstellung von Benutzern und Gruppen automatisieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Linux Command Line & Bash Scripting Mastery-Lektion Code schreiben und ausführen?

Ja. Jede Linux Command Line & Bash Scripting Mastery-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Bereitstellung von Benutzern und Gruppen automatisieren
  2. systemd-Dienste steuern und Unit-Dateien schreiben
  3. Datenträger-, Dateisystem- und Mount-Automatisierung
  4. Skripte für Systemprüfungen und Warnmeldungen erstellen
← Zurück zu Linux Command Line & Bash Scripting Mastery