Linux Command Line & Bash Scripting Mastery · Lektion

Fortgeschrittenes Skripting-Projekt

Bearbeiten Sie ein umfassendes Projekt, das alle erlernten Konzepte verbindet – von Befehlszeilentools bis hin zu fortgeschrittenen Bash-Skripting-Techniken.

Fortgeschrittenes Skripting-Projekt ist eine kostenlose Linux Command Line & Bash Scripting Mastery-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Projektstart: Die Herausforderung

Willkommen bei unserem Abschlussprojekt! Im Laufe dieses Kurses haben Sie viele leistungsfähige Linux-Befehle und Bash-Scripting-Techniken kennengelernt. Jetzt ist es an der Zeit, alles zusammenzuführen.

In dieser Lektion erstellen wir von Grund auf ein praktisches, fortgeschrittenes Bash-Skript. Dieses Projekt fordert Sie heraus, alles Gelernte in einer einzigen funktionalen Lösung zu verbinden.

Unser Projektziel definieren

Unser Ziel ist es, ein Skript zur Dateiüberwachung und Archivierung zu erstellen. Stellen Sie sich vor, Sie haben einen Server, der Protokolldateien erzeugt, und müssen diese regelmäßig ohne manuelles Eingreifen verarbeiten.

Unser Skript wird Folgendes tun:

Ein bestimmtes Verzeichnis kontinuierlich auf neue Textdateien überwachen.
Jede neue Datei verarbeiten (z. B. ihre Zeilen zählen).
Die verarbeitete Datei in ein Archivverzeichnis verschieben.
Alle Aktivitäten einschließlich Zeitstempeln und etwaiger Fehler protokollieren.

Skriptgrundlage: Shebang und Variablen

Jedes gute Skript beginnt mit einer klaren Grundlage. Wir definieren zunächst unseren Shebang und richten wichtige Variablen ein. Diese Variablen machen unser Skript flexibel und einfach konfigurierbar.

Wir definieren Pfade für unser Überwachungsverzeichnis, unser Archivverzeichnis und eine Protokolldatei.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

Sicherstellen, dass Verzeichnisse vorhanden sind

Bevor unser Skript Dateien überwachen oder archivieren kann, müssen wir sicherstellen, dass die erforderlichen Verzeichnisse vorhanden sind. Die Verwendung von mkdir -p ist hierbei entscheidend: Der Befehl erstellt Verzeichnisse nur dann, wenn sie noch nicht vorhanden sind, und erzeugt keinen Fehler, wenn sie bereits existieren.

Außerdem fügen wir eine grundlegende Fehlerbehandlung hinzu, damit das Skript bei einem Fehler beim Erstellen der Verzeichnisse ordnungsgemäß beendet wird.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

Die Überwachungsschleife

Unser Skript muss kontinuierlich ausgeführt werden, um neue Dateien zu überwachen. Eine while true-Schleife eignet sich dafür hervorragend. Innerhalb der Schleife verwenden wir sleep, um zwischen den Prüfungen einige Sekunden zu warten und so zu verhindern, dass zu viele Ressourcen verbraucht werden.

Außerdem protokollieren wir jede Prüfung, damit die Aktivitäten nachvollziehbar bleiben.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

# --- Main Monitoring Loop ---
while true; do
  echo "$(date): Checking for new files in $MONITOR_DIR..." >> "$LOG_FILE"
  # File processing will go here
  sleep 5 # Check every 5 seconds
done

Dateien finden und verarbeiten

In unserer Schleife müssen wir neue Textdateien finden. Der Befehl find eignet sich ideal dafür, kombiniert mit einer for-Schleife, um jede gefundene Datei zu verarbeiten. Als Verarbeitungsschritt verwenden wir wc -l, um die Zeilen in jeder Datei zu zählen.

Dies zeigt, wie sich Befehlszeilenwerkzeuge in einem Skript kombinieren lassen.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

# --- Main Monitoring Loop ---
while true; do
  echo "$(date): Checking for new files in $MONITOR_DIR..." >> "$LOG_FILE"
  # Find new .txt files and process them
  for file in $(find "$MONITOR_DIR" -maxdepth 1 -type f -name "*.txt"); do
    if [ -f "$file" ]; then # Double-check if it's a regular file
      LINE_COUNT=$(wc -l < "$file")
      echo "$(date): Found '$file'. Lines: $LINE_COUNT." >> "$LOG_FILE"
      # Archiving will go here
    fi
  done
  sleep 5 # Check every 5 seconds
done

Verarbeitete Dateien archivieren

Nach der Verarbeitung einer Datei müssen wir sie in unser Archivverzeichnis verschieben. Dafür verwenden wir den Befehl mv. Zusätzlich fügen wir eine if-Anweisung hinzu, die den Exit-Status von mv prüft. So stellen wir sicher, dass das Verschieben erfolgreich war, und protokollieren alle Fehler.

Dadurch wird unser Skript robuster.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

# --- Main Monitoring Loop ---
while true; do
  echo "$(date): Checking for new files in $MONITOR_DIR..." >> "$LOG_FILE"
  for file in $(find "$MONITOR_DIR" -maxdepth 1 -type f -name "*.txt"); do
    if [ -f "$file" ]; then
      LINE_COUNT=$(wc -l < "$file")
      echo "$(date): Found '$file'. Lines: $LINE_COUNT." >> "$LOG_FILE"
      
      mv "$file" "$ARCHIVE_DIR/"
      if [ $? -eq 0 ]; then
        echo "$(date): Moved '$file' to '$ARCHIVE_DIR'." >> "$LOG_FILE"
      else
        echo "$(date): ERROR: Failed to move '$file' to '$ARCHIVE_DIR'." >> "$LOG_FILE"
      fi
    fi
  done
  sleep 5
done

Graceful Exit mit Trap hinzufügen

Ein langfristig laufendes Skript benötigt eine Möglichkeit zum kontrollierten Beenden. Mit dem Befehl trap können wir Signale wie SIGINT (ausgelöst durch Strg+C) abfangen und vor dem Beenden eine Bereinigungsfunktion ausführen. So stellt unser Skript sicher, dass sein Herunterfahren protokolliert wird.

Dies ist ein entscheidender Schritt für produktionsreife Skripte.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# --- Functions ---
cleanup() {
  echo "$(date): Script received stop signal. Exiting gracefully." >> "$LOG_FILE"
  exit 0 # Exit with success status
}

# --- Trap Signals ---
# Trap SIGINT (Ctrl+C) and call the cleanup function
trap cleanup SIGINT

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

# --- Main Monitoring Loop ---
while true; do
  echo "$(date): Checking for new files in $MONITOR_DIR..." >> "$LOG_FILE"
  for file in $(find "$MONITOR_DIR" -maxdepth 1 -type f -name "*.txt"); do
    if [ -f "$file" ]; then
      LINE_COUNT=$(wc -l < "$file")
      echo "$(date): Found '$file'. Lines: $LINE_COUNT." >> "$LOG_FILE"
      
      mv "$file" "$ARCHIVE_DIR/"
      if [ $? -eq 0 ]; then
        echo "$(date): Moved '$file' to '$ARCHIVE_DIR'." >> "$LOG_FILE"
      else
        echo "$(date): ERROR: Failed to move '$file' to '$ARCHIVE_DIR'." >> "$LOG_FILE"
      fi
    fi
  done
  sleep 5
done

Ihr erweitertes Skript testen

Unser Skript ist nun vollständig – Zeit, es zu testen! Üblicherweise würden Sie es im Hintergrund ausführen (z. B. ./monitor.sh &), anschließend Testdateien im Verzeichnis $MONITOR_DIR erstellen und $LOG_FILE sowie $ARCHIVE_DIR beobachten.

Hier ist ein kleines Skript, mit dem Sie ganz einfach eine Testdatei für Ihre Überwachung erstellen können.

#!/bin/bash
# create_test_file.sh

MONITOR_DIR="/tmp/coddykit_monitor"
mkdir -p "$MONITOR_DIR" # Ensure dir exists for this test script

# Create a unique test file
TEST_FILE="$MONITOR_DIR/test_log_$(date +%Y%m%d_%H%M%S).txt"
echo "This is a test entry." > "$TEST_FILE"
echo "Another line for testing." >> "$TEST_FILE"
echo "Created new test file: $TEST_FILE"

Skriptlogik überprüfen

Unser erweitertes Skript verbindet viele Konzepte. Sehen wir uns kurz einige der wichtigsten Befehle und Strukturen an, die wir verwendet haben.

Überlegen Sie, welche Rolle jeder Befehl beim Erreichen unseres Projektziels spielt.

Darüber hinaus: Zeitplanung und Anpassung

Dieses Skript ist dafür ausgelegt, kontinuierlich zu laufen. In einem realen Szenario könnten Sie es mit nohup ./script.sh & im Hintergrund ausführen oder – was häufiger vorkommt – die regelmäßige Ausführung mit Cron planen.

Denken Sie daran: Cron eignet sich hervorragend, um Aufgaben wie diese zu automatisieren. Sie könnten die Ausführung alle paar Minuten planen, damit das Verzeichnis überprüft und Dateien nach Bedarf verarbeitet werden.

Sie können das Skript beispielsweise anpassen, um:

andere Dateitypen zu verarbeiten.
andere Aktionen auszuführen (z. B. Dateien zu komprimieren oder in die Cloud hochzuladen).
eine fortschrittlichere Fehlerberichterstattung hinzuzufügen (z. B. E-Mail-Benachrichtigungen).

Projektzusammenfassung und nächste Schritte

Herzlichen Glückwunsch! Sie haben gerade ein fortgeschrittenes Bash-Scripting-Projekt abgeschlossen und dabei eine Vielzahl von Linux-Befehlen und Scripting-Techniken integriert.

Sie haben gelernt:

ein robustes, langfristig laufendes Skript zu strukturieren.
Variablen für die Konfiguration zu verwenden.
Schleifen zur kontinuierlichen Überwachung einzusetzen.
Befehle wie find, wc und mv zu kombinieren.
mit trap die Fehlerbehandlung und ein kontrolliertes Beenden zu ergänzen.

Dieses Projekt bildet eine solide Grundlage für komplexere Automatisierungslösungen. Experimentieren und entwickeln Sie weiter!

Häufig gestellte Fragen

Ist die Lektion „Fortgeschrittenes Skripting-Projekt“ kostenlos?

Ja — der vollständige Text von „Fortgeschrittenes Skripting-Projekt“ 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 „Fortgeschrittenes Skripting-Projekt“?

Bearbeiten Sie ein umfassendes Projekt, das alle erlernten Konzepte verbindet – von Befehlszeilentools bis hin zu fortgeschrittenen Bash-Skripting-Techniken. 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 3 von 4.

Wie lange dauert die Lektion „Fortgeschrittenes Skripting-Projekt“?

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

Aufgaben mit Cron planen
Systemadministration automatisieren
Fortgeschrittenes Skripting-Projekt
Automatische Log-Rotation und Bereinigung

← Zurück zu Linux Command Line & Bash Scripting Mastery