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

• Benutzer hinzufügen
• Benutzer- und Gruppenverwaltung
• Linux Berechtigungssystem
• Shell-Scripting Grundlagen

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

• Standard-Speicherort für Skeleton-Dateien
• Versteckte Dateien (beginnend mit .) werden ebenfalls kopiert
• Berechtigungen werden mit kopiert
• Kann angepasst werden mit `useradd -k` Option

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

# 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/

# 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

# 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

# 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"

# 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"

# 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>"

Erweitern Sie das Standard-Skeleton:

1. Fügen Sie nützliche Aliases zur .bashrc hinzu
2. Erstellen Sie Standard-Verzeichnisse
3. Testen Sie mit einem neuen Testbenutzer

Erstellen Sie ein Entwickler-Skeleton:

1. Git-Konfiguration vorbereiten
2. Entwicklungsverzeichnisse anlegen
3. IDE-Konfiguration hinzufügen

==== Übung 3: Template-System #### Implementieren Sie ein Template-System:

1. Mehrere Benutzertyp-Templates erstellen
2. Script für Template-basierte Benutzer-Erstellung
3. Test verschiedener Templates

==== Übung 4: Automatisierung #### Automatisieren Sie Skeleton-Management:

1. Backup-System für Skeleton-Änderungen
2. Versionierung der Template-Änderungen
3. Deployment neuer Templates

# 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"

==== Ausbildungs-Environment ####

# 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

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

Problem: Skeleton-Dateien werden nicht kopiert

# 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/

Problem: Falsche Berechtigungen nach Skeleton-Kopie

# 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

Problem: Skeleton-Änderungen gelten nicht für bestehende Benutzer

# 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

==== 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

• Benutzer hinzufügen
• Benutzer- und Gruppenverwaltung
• Shell-Scripting
• Bash-Konfiguration
• Linux Berechtigungssystem
• Home-Verzeichnis-Management