====== Skeleton-Dateien für Benutzererstellung ======

===== Lernziel =====

Sie lernen das `/etc/skel` Verzeichnis und Skeleton-Dateien kennen und können diese zur Automatisierung der Benutzer-Umgebung bei der Account-Erstellung nutzen.

===== Voraussetzungen =====
  * [[workshop:useradd|Benutzer hinzufügen]]
  * [[workshop:benutzer_gruppenverwaltung|Benutzer- und Gruppenverwaltung]]
  * [[workshop:berechtigungen|Linux Berechtigungssystem]]
  * [[workshop:shell_scripting|Shell-Scripting Grundlagen]]

===== Theorie =====

==== Was sind Skeleton-Dateien? ====
**Skeleton-Dateien** (Skelett-Dateien) sind Vorlagen, die automatisch in das Home-Verzeichnis neuer Benutzer kopiert werden:
  * Befinden sich standardmäßig in **/etc/skel/**
  * Werden von `useradd -m` automatisch kopiert
  * Definieren Standard-Umgebung für neue Benutzer
  * Können für verschiedene Benutzertypen angepasst werden

==== Das /etc/skel Verzeichnis ====
  * **Standard-Speicherort** für Skeleton-Dateien
  * **Versteckte Dateien** (beginnend mit .) werden ebenfalls kopiert
  * **Berechtigungen** werden mit kopiert
  * **Kann angepasst** werden mit `useradd -k` Option

==== Typische Skeleton-Inhalte ====
  * **Shell-Konfiguration:** .bashrc, .bash_profile, .zshrc
  * **Desktop-Einstellungen:** .config/, .local/
  * **Anwendungs-Templates:** Dokument-Vorlagen, Standard-Bookmarks
  * **Entwicklungs-Umgebung:** Git-Konfiguration, Editor-Settings

===== Kommandos =====

==== Standard /etc/skel erkunden ====
<code bash>
# Inhalt von /etc/skel anzeigen
ls -la /etc/skel/
tree /etc/skel/ 2>/dev/null || find /etc/skel -type f

# Skeleton-Dateien im Detail
find /etc/skel -type f -exec ls -la {} \;

# Versteckte Dateien und Verzeichnisse
find /etc/skel -name ".*" -type f

# Größe des Skeleton-Verzeichnisses
du -sh /etc/skel/
du -ah /etc/skel/
</code>

==== Standard-Skeleton-Dateien anpassen ====
<code bash>
# Backup des aktuellen /etc/skel erstellen
sudo cp -r /etc/skel /etc/skel.backup.$(date +%Y%m%d)

# Erweiterte .bashrc erstellen
sudo tee /etc/skel/.bashrc << 'EOF'
# ~/.bashrc: executed by bash(1) for non-login shells.

# If not running interactively, don't do anything
case $- in
    *i*) ;;
      *) return;;
esac

# History-Einstellungen
HISTCONTROL=ignoreboth
HISTSIZE=10000
HISTFILESIZE=20000
shopt -s histappend

# Window-Size nach Resize prüfen
shopt -s checkwinsize

# Lesbares less für Binärdateien
[ -x /usr/bin/lesspipe ] && eval "$(SHELL=/bin/sh lesspipe)"

# Colored prompt
if [ "$color_prompt" = yes ]; then
    PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '
else
    PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '
fi

# Aliases
alias ll='ls -alF'
alias la='ls -A'
alias l='ls -CF'
alias ..='cd ..'
alias ...='cd ../..'
alias grep='grep --color=auto'
alias fgrep='fgrep --color=auto'
alias egrep='egrep --color=auto'

# Git-Aliase
alias gs='git status'
alias ga='git add'
alias gc='git commit'
alias gp='git push'
alias gl='git log --oneline'

# System-Aliase
alias df='df -h'
alias du='du -h'
alias free='free -h'
alias ps='ps aux'

# Completion aktivieren
if ! shopt -oq posix; then
  if [ -f /usr/share/bash-completion/bash_completion ]; then
    . /usr/share/bash-completion/bash_completion
  elif [ -f /etc/bash_completion ]; then
    . /etc/bash_completion
  fi
fi

# Lokale Anpassungen
if [ -f ~/.bashrc.local ]; then
    . ~/.bashrc.local
fi
EOF

# Erweiterte .bash_profile
sudo tee /etc/skel/.bash_profile << 'EOF'
# ~/.bash_profile: executed by bash(1) for login shells.

# Include .bashrc if it exists
if [ -f "$HOME/.bashrc" ]; then
    . "$HOME/.bashrc"
fi

# User specific environment and startup programs
PATH="$HOME/bin:$HOME/.local/bin:$PATH"
export PATH

# Standard-Editor setzen
export EDITOR=nano
export VISUAL=nano

# Locale-Einstellungen
export LANG=de_DE.UTF-8
export LC_ALL=de_DE.UTF-8
EOF
</code>

==== Spezielle Skeleton-Verzeichnisse erstellen ====
<code bash>
# Entwickler-Skeleton erstellen
sudo mkdir -p /etc/skel.developer

# Standard-Dateien kopieren
sudo cp -r /etc/skel/. /etc/skel.developer/

# Git-Konfiguration für Entwickler
sudo tee /etc/skel.developer/.gitconfig << 'EOF'
[user]
    # Wird beim ersten Git-Commit angepasst
    name = CHANGEME
    email = CHANGEME@company.com

[core]
    editor = nano
    autocrlf = input

[init]
    defaultBranch = main

[push]
    default = simple

[pull]
    rebase = false

[alias]
    st = status
    co = checkout
    br = branch
    up = pull
    ci = commit
    lg = log --oneline --graph --decorate
EOF

# SSH-Verzeichnis vorbereiten
sudo mkdir -p /etc/skel.developer/.ssh
sudo chmod 700 /etc/skel.developer/.ssh

# Entwickler-spezifische .bashrc-Erweiterung
sudo tee /etc/skel.developer/.bashrc.local << 'EOF'
# Entwickler-spezifische Aliases und Funktionen

# Development-Aliases
alias python='python3'
alias pip='pip3'
alias serve='python3 -m http.server'
alias json='python3 -m json.tool'

# Docker-Aliases (falls installiert)
alias d='docker'
alias dc='docker-compose'
alias dps='docker ps'
alias di='docker images'

# Nützliche Funktionen
mkcd() {
    mkdir -p "$1" && cd "$1"
}

# Projekt-Setup Funktion
project_setup() {
    if [ -z "$1" ]; then
        echo "Usage: project_setup <project_name>"
        return 1
    fi
    
    mkdir -p "$1"/{src,tests,docs,config}
    cd "$1"
    git init
    echo "# $1" > README.md
    echo ".env" > .gitignore
    echo "Projekt $1 erstellt und initialisiert"
}

# PATH für lokale Entwicklungstools
export PATH="$HOME/.local/bin:$HOME/bin:$PATH"

# Node.js
export PATH="$HOME/.npm-global/bin:$PATH"

# Python
export PATH="$HOME/.local/bin:$PATH"
EOF

# Admin-Skeleton erstellen
sudo mkdir -p /etc/skel.admin
sudo cp -r /etc/skel/. /etc/skel.admin/

# Admin-spezifische .bashrc-Erweiterung
sudo tee /etc/skel.admin/.bashrc.local << 'EOF'
# Admin-spezifische Aliases und Funktionen

# System-Administration Aliases
alias services='systemctl list-units --type=service'
alias logs='journalctl -f'
alias ports='netstat -tuln'
alias processes='ps aux --sort=-%cpu | head'
alias diskspace='df -h | grep -E "^/dev"'
alias meminfo='free -h && echo && cat /proc/meminfo | head'

# Log-Analyse
alias auth_log='sudo tail -f /var/log/auth.log'
alias sys_log='sudo tail -f /var/log/syslog'
alias apache_error='sudo tail -f /var/log/apache2/error.log 2>/dev/null || echo "Apache nicht installiert"'
alias nginx_error='sudo tail -f /var/log/nginx/error.log 2>/dev/null || echo "Nginx nicht installiert"'

# Netzwerk-Tools
alias myip='curl -s ipinfo.io/ip'
alias listening='ss -tuln'
alias connections='ss -tuap'

# Backup-Funktionen
backup_home() {
    if [ -z "$1" ]; then
        echo "Usage: backup_home <username>"
        return 1
    fi
    
    backup_dir="/backup/home/$(date +%Y%m%d)"
    sudo mkdir -p "$backup_dir"
    sudo tar -czf "$backup_dir/${1}_$(date +%H%M%S).tar.gz" "/home/$1"
    echo "Backup erstellt: $backup_dir/${1}_$(date +%H%M%S).tar.gz"
}

# System-Monitoring
system_overview() {
    echo "=== System Overview $(date) ==="
    echo
    echo "=== CPU ==="
    lscpu | head -10
    echo
    echo "=== Memory ==="
    free -h
    echo
    echo "=== Disk ==="
    df -h | head -10
    echo
    echo "=== Load ==="
    uptime
    echo
    echo "=== Top Processes ==="
    ps aux --sort=-%cpu | head -6
}

# Prompt-Anpassung für Admin
export PS1='\[\033[01;31m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '
EOF
</code>

===== Schritt-für-Schritt Anleitung =====

==== 1. Aktuelles Skeleton analysieren ====
<code bash>
# Umfassende Analyse des Standard-Skeleton
echo "=== Standard Skeleton-Analyse ==="

# Verzeichnisstruktur
echo "Verzeichnisinhalt:"
ls -la /etc/skel/

# Dateigrößen
echo ""
echo "Dateigrößen:"
find /etc/skel -type f -exec ls -lh {} \;

# Versteckte Dateien
echo ""
echo "Versteckte Dateien:"
find /etc/skel -name ".*" -type f

# Gesamtgröße
echo ""
echo "Gesamtgröße des Skeleton:"
du -sh /etc/skel/

# Test: Neuen Benutzer erstellen und Skeleton testen
echo ""
echo "=== Test-Benutzer-Erstellung ==="
test_user="skeleton_test_$(date +%s)"
sudo useradd -m "$test_user"

echo "Home-Verzeichnis des Test-Benutzers:"
sudo ls -la "/home/$test_user/"

# Test-Benutzer wieder löschen
sudo userdel -r "$test_user"
</code>

==== 2. Angepasstes Skeleton erstellen ====
<code bash>
# Backup und neues Skeleton erstellen
backup_date=$(date +%Y%m%d_%H%M%S)
sudo cp -r /etc/skel "/etc/skel.backup.$backup_date"

echo "Backup erstellt: /etc/skel.backup.$backup_date"

# Erweiterte Verzeichnisstruktur
sudo mkdir -p /etc/skel/{Documents,Downloads,Scripts,Projects}
sudo mkdir -p /etc/skel/.config
sudo mkdir -p /etc/skel/.local/bin

# Willkommens-Datei
sudo tee /etc/skel/README.txt << 'EOF'
Willkommen in Ihrem neuen Benutzer-Account!

Diese Dateien wurden automatisch erstellt:
- .bashrc: Shell-Konfiguration
- .bash_profile: Login-Shell-Konfiguration
- Documents/: Für Ihre Dokumente
- Downloads/: Für Downloads
- Scripts/: Für eigene Scripts
- Projects/: Für Entwicklungsprojekte

Hilfreiche Befehle:
- ls -la: Alle Dateien anzeigen (auch versteckte)
- history: Befehlshistorie anzeigen
- man befehl: Hilfe zu einem Befehl

Für weitere Hilfe wenden Sie sich an den System-Administrator.
EOF

# Beispiel-Script
sudo tee /etc/skel/Scripts/example.sh << 'EOF'
#!/bin/bash
# Beispiel-Script für neue Benutzer

echo "Hallo $(whoami)!"
echo "Heute ist $(date)"
echo "Du befindest dich in: $(pwd)"
echo "Deine Benutzer-ID ist: $(id -u)"
echo "Du gehörst zu folgenden Gruppen: $(groups)"
EOF

sudo chmod +x /etc/skel/Scripts/example.sh

# Git-Ignore-Template
sudo tee /etc/skel/.gitignore_global << 'EOF'
# Compiled source
*.com
*.class
*.dll
*.exe
*.o
*.so

# Packages
*.7z
*.dmg
*.gz
*.iso
*.jar
*.rar
*.tar
*.zip

# Logs and databases
*.log
*.sql
*.sqlite

# OS generated files
.DS_Store
.DS_Store?
._*
.Spotlight-V100
.Trashes
ehthumbs.db
Thumbs.db

# Editor backups
*~
*.swp
*.swo

# Python
__pycache__/
*.py[cod]
*$py.class
*.egg-info/
dist/
build/

# Node.js
node_modules/
npm-debug.log*

# IDE
.vscode/
.idea/
*.sublime-project
*.sublime-workspace
EOF

echo "Angepasstes Skeleton erstellt"
</code>

==== 3. Rollenbasierte Skeleton-Templates ====
<code bash>
# Template-System für verschiedene Benutzertypen
echo "=== Erstelle rollenbasierte Skeleton-Templates ==="

# Basis-Template (Standard)
sudo mkdir -p /etc/skel.templates/standard
sudo cp -r /etc/skel/. /etc/skel.templates/standard/

# Entwickler-Template
sudo mkdir -p /etc/skel.templates/developer
sudo cp -r /etc/skel.templates/standard/. /etc/skel.templates/developer/

# Entwickler-spezifische Erweiterungen
sudo mkdir -p /etc/skel.templates/developer/{Projects,Repositories,.vscode,.config/git}
sudo tee /etc/skel.templates/developer/.vscode/settings.json << 'EOF'
{
    "editor.tabSize": 4,
    "editor.insertSpaces": true,
    "editor.detectIndentation": true,
    "files.autoSave": "afterDelay",
    "files.autoSaveDelay": 1000,
    "terminal.integrated.shell.linux": "/bin/bash"
}
EOF

# Admin-Template
sudo mkdir -p /etc/skel.templates/admin
sudo cp -r /etc/skel.templates/standard/. /etc/skel.templates/admin/
sudo mkdir -p /etc/skel.templates/admin/{Backups,Monitoring,Scripts/admin}

# Admin-Scripts
sudo tee /etc/skel.templates/admin/Scripts/admin/system_check.sh << 'EOF'
#!/bin/bash
# System-Check Script für Administratoren

echo "=== System Check $(date) ==="
echo ""

echo "System Uptime:"
uptime
echo ""

echo "Disk Usage:"
df -h | head -10
echo ""

echo "Memory Usage:"
free -h
echo ""

echo "Load Average:"
cat /proc/loadavg
echo ""

echo "Active Services:"
systemctl list-units --state=active --type=service | head -10
echo ""

echo "Failed Services:"
systemctl list-units --state=failed
EOF

sudo chmod +x /etc/skel.templates/admin/Scripts/admin/system_check.sh

# Template-Auswahlscript
sudo tee /usr/local/bin/create_user_with_template << 'EOF'
#!/bin/bash
# Script zur Benutzer-Erstellung mit Template-Auswahl

if [ "$EUID" -ne 0 ]; then
    echo "Dieses Script muss als root ausgeführt werden"
    exit 1
fi

if [ $# -lt 2 ]; then
    echo "Usage: $0 <username> <template>"
    echo "Available templates:"
    ls /etc/skel.templates/ 2>/dev/null || echo "Keine Templates gefunden"
    exit 1
fi

username="$1"
template="$2"
template_path="/etc/skel.templates/$template"

if [ ! -d "$template_path" ]; then
    echo "Template '$template' nicht gefunden!"
    echo "Verfügbare Templates:"
    ls /etc/skel.templates/
    exit 1
fi

echo "Erstelle Benutzer '$username' mit Template '$template'"

# Benutzer mit spezifischem Skeleton erstellen
useradd -m -k "$template_path" "$username"

if [ $? -eq 0 ]; then
    echo "Benutzer '$username' erfolgreich erstellt"
    echo "Home-Verzeichnis: /home/$username"
    echo "Template verwendet: $template"
    
    # Optional: Passwort setzen
    echo "Möchten Sie ein Passwort für $username setzen? (y/n)"
    read -r answer
    if [ "$answer" = "y" ] || [ "$answer" = "Y" ]; then
        passwd "$username"
    fi
else
    echo "Fehler beim Erstellen des Benutzers"
    exit 1
fi
EOF

sudo chmod +x /usr/local/bin/create_user_with_template

echo "Rollenbasierte Templates erstellt:"
echo "- /etc/skel.templates/standard"
echo "- /etc/skel.templates/developer" 
echo "- /etc/skel.templates/admin"
echo ""
echo "Verwendung: sudo create_user_with_template <username> <template>"
</code>

===== Übungen =====

==== Übung 1: Standard-Skeleton erweitern ====
Erweitern Sie das Standard-Skeleton:
  - Fügen Sie nützliche Aliases zur .bashrc hinzu
  - Erstellen Sie Standard-Verzeichnisse
  - Testen Sie mit einem neuen Testbenutzer

==== Übung 2: Entwickler-Environment ====
Erstellen Sie ein Entwickler-Skeleton:
  - Git-Konfiguration vorbereiten
  - Entwicklungsverzeichnisse anlegen
  - IDE-Konfiguration hinzufügen

==== Übung 3: Template-System ####
Implementieren Sie ein Template-System:
  - Mehrere Benutzertyp-Templates erstellen
  - Script für Template-basierte Benutzer-Erstellung
  - Test verschiedener Templates

==== Übung 4: Automatisierung ####
Automatisieren Sie Skeleton-Management:
  - Backup-System für Skeleton-Änderungen
  - Versionierung der Template-Änderungen
  - Deployment neuer Templates

===== Praktische Anwendungen =====

==== Unternehmens-Standard-Environment ====
<code bash>
# Firmen-spezifisches Skeleton erstellen
company_name="mycompany"
sudo mkdir -p "/etc/skel.${company_name}"
sudo cp -r /etc/skel/. "/etc/skel.${company_name}/"

# Firmen-spezifische Bookmarks
sudo mkdir -p "/etc/skel.${company_name}/.config"
sudo tee "/etc/skel.${company_name}/.config/bookmarks.txt" << EOF
# ${company_name} Standard-Bookmarks
Intranet: https://intranet.${company_name}.com
Helpdesk: https://helpdesk.${company_name}.com
Documentation: https://docs.${company_name}.com
Git Repository: https://git.${company_name}.com
EOF

# Firmen-spezifische Umgebungsvariablen
sudo tee "/etc/skel.${company_name}/.bashrc.company" << EOF
# ${company_name} Umgebungsvariablen
export COMPANY_NAME="${company_name}"
export COMPANY_DOMAIN="${company_name}.com"
export INTERNAL_REPO="git.${company_name}.com"

# Proxy-Einstellungen (falls benötigt)
# export http_proxy="http://proxy.${company_name}.com:8080"
# export https_proxy="http://proxy.${company_name}.com:8080"

# Firmen-spezifische Aliases
alias company_docs='firefox https://docs.${company_name}.com &'
alias company_git='firefox https://git.${company_name}.com &'
alias intranet='firefox https://intranet.${company_name}.com &'
EOF

# In .bashrc einbinden
echo "source ~/.bashrc.company" | sudo tee -a "/etc/skel.${company_name}/.bashrc"
</code>

==== Ausbildungs-Environment ####
<code bash>
# Skeleton für Auszubildende/Praktikanten
sudo mkdir -p /etc/skel.trainee
sudo cp -r /etc/skel/. /etc/skel.trainee/

# Lern-Verzeichnisse
sudo mkdir -p /etc/skel.trainee/{Learning,Exercises,Projects,Resources}

# Lern-Ressourcen
sudo tee /etc/skel.trainee/Resources/linux_cheatsheet.txt << 'EOF'
=== Linux Cheatsheet für Einsteiger ===

Basis-Navigation:
  pwd                 - Aktuelles Verzeichnis anzeigen
  ls                  - Dateien auflisten
  ls -la              - Alle Dateien mit Details
  cd verzeichnis      - In Verzeichnis wechseln
  cd ..               - Eine Ebene höher
  cd ~                - Zum Home-Verzeichnis

Dateien und Verzeichnisse:
  mkdir verzeichnis   - Verzeichnis erstellen
  rmdir verzeichnis   - Leeres Verzeichnis löschen
  rm datei            - Datei löschen
  cp quelle ziel      - Datei kopieren
  mv quelle ziel      - Datei verschieben/umbenennen

Dateien anzeigen:
  cat datei           - Datei komplett anzeigen
  less datei          - Datei seitenweise anzeigen
  head datei          - Erste Zeilen anzeigen
  tail datei          - Letzte Zeilen anzeigen

Hilfe:
  man befehl          - Handbuch zu einem Befehl
  befehl --help       - Kurze Hilfe zu einem Befehl

Berechtigungen:
  chmod 755 datei     - Ausführungsrechte setzen
  chown user datei    - Besitzer ändern
  ls -l               - Detaillierte Auflistung mit Rechten
EOF

# Übungsaufgaben
sudo tee /etc/skel.trainee/Exercises/week1_tasks.txt << 'EOF'
=== Woche 1: Grundlagen-Übungen ===

1. Navigation:
   - Navigieren Sie durch verschiedene Verzeichnisse
   - Finden Sie heraus, wo sich wichtige Systemdateien befinden
   - Erstellen Sie eine Verzeichnisstruktur für Ihre Projekte

2. Dateien verwalten:
   - Erstellen Sie 5 Textdateien mit verschiedenen Inhalten
   - Kopieren Sie diese in ein neues Verzeichnis
   - Umbenennen Sie die Dateien systematisch

3. Befehle lernen:
   - Verwenden Sie 'man' um die Hilfe zu 5 verschiedenen Befehlen zu lesen
   - Testen Sie verschiedene Optionen der Befehle ls, cp, mv

4. Text bearbeiten:
   - Lernen Sie einen Texteditor (nano oder vim)
   - Erstellen Sie ein kleines Shell-Script
   - Machen Sie das Script ausführbar

Deadline: Ende der Woche
Bei Fragen: Fragen Sie Ihren Mentor!
EOF

# Mentor-Kontakt
sudo tee /etc/skel.trainee/mentor_contact.txt << 'EOF'
=== Mentor-Kontakte ===

Linux-Grundlagen: mentor.linux@company.com
Programmierung: mentor.dev@company.com
Netzwerk: mentor.network@company.com

Allgemeine Fragen: trainee.support@company.com

Sprechzeiten:
Mo-Fr: 9:00-17:00
Notfall: +49 123 456789
EOF
</code>

===== Troubleshooting =====

==== Häufige Probleme ####

**Problem:** Skeleton-Dateien werden nicht kopiert
<code bash>
# useradd ohne -m Option
sudo useradd username           # Falsch - kein Home-Verzeichnis
sudo useradd -m username        # Richtig - mit Home-Verzeichnis

# Skeleton manuell kopieren
sudo cp -r /etc/skel/. /home/username/
sudo chown -R username:username /home/username/
</code>

**Problem:** Falsche Berechtigungen nach Skeleton-Kopie
<code bash>
# Berechtigungen reparieren
username="problematic_user"
sudo chown -R "$username:$username" "/home/$username"
sudo chmod 755 "/home/$username"
sudo chmod 644 "/home/$username"/.* 2>/dev/null
sudo chmod 755 "/home/$username"/.local/bin/* 2>/dev/null
</code>

**Problem:** Skeleton-Änderungen gelten nicht für bestehende Benutzer
<code bash>
# Neue Skeleton-Dateien zu bestehenden Benutzern kopieren
new_file="/etc/skel/.bashrc.new"
for user_home in /home/*; do
    if [ -d "$user_home" ]; then
        username=$(basename "$user_home")
        if id "$username" &>/dev/null; then
            echo "Aktualisiere $username"
            sudo cp "$new_file" "$user_home/.bashrc.new"
            sudo chown "$username:$username" "$user_home/.bashrc.new"
        fi
    fi
done
</code>

===== Best Practices =====

==== Template-Management ####
  * **Versionierung** der Skeleton-Templates mit Git
  * **Backup** vor Änderungen an /etc/skel
  * **Test** neuer Templates mit Dummy-Benutzern
  * **Dokumentation** aller Template-Änderungen

==== Sicherheit ####
  * **Minimale Rechte** in Skeleton-Dateien
  * **Keine sensiblen Daten** in Templates
  * **Sichere Standard-Konfiguration** verwenden
  * **Regelmäßige Überprüfung** der Skeleton-Inhalte

==== Wartung ####
  * **Regelmäßige Updates** der Standard-Konfigurationen
  * **Cleanup** veralteter Template-Versionen
  * **Monitoring** der Skeleton-Nutzung
  * **Feedback** von Benutzern sammeln

==== Automatisierung ####
  * **Scripts** für Template-Deployment
  * **Hooks** für automatische Updates
  * **Testing** neuer Skeleton-Versionen
  * **Rollback-Mechanismus** für fehlerhafte Templates

\\
===== Weiterführende Links =====
  * [[workshop:useradd|Benutzer hinzufügen]]
  * [[workshop:benutzer_gruppenverwaltung|Benutzer- und Gruppenverwaltung]]
  * [[workshop:shell_scripting|Shell-Scripting]]
  * [[workshop:bash_konfiguration|Bash-Konfiguration]]
  * [[workshop:berechtigungen|Linux Berechtigungssystem]]
  * [[workshop:home_verzeichnis|Home-Verzeichnis-Management]]