wmpsites.com

Terminal öffnen und zum Skriptverzeichnis navigieren

Um ein Linux-Skript auszuführen, musst du zunächst ein Terminal öffnen und zum Verzeichnis navigieren, in dem sich das Skript befindet.

Terminal öffnen

Je nach verwendetem Linux-Desktop gibt es verschiedene Möglichkeiten, ein Terminal zu öffnen:

• Konsolenemulator (Terminal): Suche im Anwendungsmenü nach "Terminal" oder "Konsole".
• Tastenkürzel: Verwende häufig Ctrl + Alt + T oder Ctrl + Shift + T.
• Befehlszeile: Öffne ein Terminalfenster über die Befehlszeile mit dem Befehl gnome-terminal oder xterm.

Zum Skriptverzeichnis navigieren

Um zum Verzeichnis zu navigieren, in dem sich das Skript befindet, verwende den Befehl cd. Hier sind einige Beispiele:

Beispiel: Zum Ordner Dokumente navigieren:

cd ~/Dokumente

Beispiel: Zum Verzeichnis scripts innerhalb des Ordners Dokumente navigieren:

cd ~/Dokumente/scripts

Du kannst auch den absoluten Pfad zum Verzeichnis angeben:

cd /home/dein_benutzername/Dokumente/scripts

Skript mit Shell-Befehlen ausführen

Der grundlegendste Ansatz zur Ausführung eines Linux-Skripts besteht darin, die Befehlszeile zu verwenden. Dies umfasst verschiedene Möglichkeiten, je nach den spezifischen Anforderungen des Skripts und deiner persönlichen Vorlieben.

sh-Befehl

Der sh-Befehl (Shell) kann verwendet werden, um Skripts auszuführen, indem du den vollständigen Pfad zum Skript angibst. Dies sieht folgendermaßen aus:

sh /pfad/zum/skript.sh

bash-Befehl

Wenn dein Skript für die Ausführung mit der Bash-Shell geschrieben wurde, kannst du den bash-Befehl verwenden, um es auszuführen. Dies bietet zusätzliche Funktionen und Flexibilität:

bash /pfad/zum/skript.sh

Interpreter direkt aufrufen

Du kannst den Interpreter, der das Skript ausführen soll, auch direkt aufrufen. Dies ist besonders nützlich, wenn du eine bestimmte Shell-Version oder Konfiguration verwenden möchtest:

/bin/bash /pfad/zum/skript.sh

Weitere Optionen

Neben der Angabe des Pfads zum Skript kannst du auch zusätzliche Optionen verwenden, um die Ausführung zu steuern:

• -x: Aktiviert die Debug-Ausgabe und zeigt jedes ausgeführte Kommando an.
• -v: Aktiviert den verbose-Modus und gibt Details zu Variablen und Befehlsargumenten aus.
• -c: Führt den angegebenen Befehl statt des Skripts aus.

Interpreter explizit angeben

Um sicherzustellen, dass dein Skript mit dem beabsichtigten Interpreter ausgeführt wird, kannst du den Interpreter explizit angeben. Dies ist besonders nützlich, wenn du mehrere Interpreter auf deinem System installiert hast.

Wie funktioniert es?

Wenn du ein Skript ausführst, sucht das Betriebssystem nach einem Interpreter, der der ersten Zeile des Skripts entspricht. Diese erste Zeile wird auch als "Shebang"-Zeile bezeichnet. Wenn du den Interpreter explizit angibst, überschreibst du diese Standardsuche.

Syntax

Die allgemeine Syntax zum expliziten Angeben des Interpreters lautet:

#!/Pfad/zum/Interpreter

wobei /Pfad/zum/Interpreter der vollständige Pfad zum Interpreter ist, den du verwenden möchtest.

Beispiele

Wenn du beispielsweise ein Bash-Skript mit dem Namen test.sh hast, kannst du den Interpreter explizit wie folgt angeben:

#!/bin/bash

Dies weist das Betriebssystem an, das Skript mit dem Bash-Interpreter auszuführen, auch wenn die systemweite Standard-Shebang-Zeile auf einen anderen Interpreter gesetzt ist.

Vorteile

Die explizite Angabe des Interpreters bietet folgende Vorteile:

• Konsistenz: Stellt sicher, dass dein Skript immer mit dem vorgesehenen Interpreter ausgeführt wird, unabhängig von den Systemeinstellungen.
• Portabilität: Ermöglicht die Ausführung deines Skripts auf Systemen mit unterschiedlichen Standard-Shell-Einstellungen.
• Fehlerbehebung: Hilft bei der Behebung von Ausführungsproblemen, die durch eine falsche Interpreterzuordnung verursacht werden.

Root-Berechtigungen für Skriptausführung

Nicht alle Skripte können erfolgreich ausgeführt werden, ohne dass du über Root-Berechtigungen verfügst. Root-Berechtigungen gewähren dir Zugriff auf bestimmte Systemressourcen und -funktionen, die für die ordnungsgemäße Ausführung bestimmter Skripte erforderlich sind.

Warum benötige ich Root-Berechtigungen?

Skripte, die systemweite Änderungen vornehmen oder auf geschützte Dateien zugreifen müssen, erfordern Root-Berechtigungen. Beispielsweise benötigst du Root-Berechtigungen, um Folgendes zu tun:

• Installation oder Entfernung von Software
• Ändern von Systemkonfigurationen
• Zugriff auf Systemprotokolle
• Verwaltung von Benutzerkonten

Wie erhalte ich Root-Berechtigungen?

Es gibt zwei Möglichkeiten, Root-Berechtigungen zu erhalten:

• sudo Befehl: Du kannst den Befehl sudo verwenden, um einen Befehl mit Root-Berechtigungen auszuführen. Gebe einfach sudo gefolgt vom Befehl ein, den du ausführen möchtest. Beispiel:

sudo apt install my-package

• su Befehl: Du kannst auch den Befehl su verwenden, um eine Root-Shell zu öffnen. Sobald du dich in der Root-Shell befindest, kannst du Befehle mit Root-Berechtigungen ausführen. Beispiel:

su -
# apt install my-package

Vorsicht beim Verwenden von Root-Berechtigungen

Denke daran, dass Root-Berechtigungen dir Zugriff auf alle Teile des Systems gewähren. Dies kann gefährlich sein, wenn du nicht vorsichtig bist. Stelle sicher, dass du die Befehle, die du ausführen möchtest, gründlich verstehst, bevor du Root-Berechtigungen verwendest.

Alternative zu Root-Berechtigungen

In einigen Fällen kannst du Root-Berechtigungen umgehen, indem du die setcap-Funktion verwendest, um bestimmte Berechtigungen auf ein Skript zu übertragen. Dies kann jedoch nur für bestimmte Arten von Skripten durchgeführt werden. Konsultiere die setcap-Manpage für weitere Informationen.

Ausführungsrechte für Skript festlegen

Damit dein Skript ausgeführt werden kann, musst du ihm die entsprechenden Ausführungsrechte zuweisen. Dies erreichst du mit dem Befehl chmod.

chmod-Befehl

Der chmod-Befehl ändert die Zugriffsrechte von Dateien und Verzeichnissen. Die Syntax des Befehls lautet:

chmod <Optionen> <Rechte> <Dateiname>

Dabei sind:

• Optionen: Eine Reihe von Optionen, die das Verhalten des Befehls steuern.
• Rechte: Die Rechte, die du festlegen möchtest.
• Dateiname: Der Name der Datei oder des Verzeichnisses, für das du die Rechte festlegen möchtest.

Rechte festlegen

Um einem Skript Ausführungsrechte zu erteilen, musst du den Rechten für den Benutzer (u), die Gruppe (g) und andere (o) ein "x" zuweisen.

chmod ugo+x <Dateiname>

Dies weist allen drei Kategorien die Berechtigung zu, die Datei auszuführen.

Beispiele

• Benutzerberechtigung festlegen:

chmod u+x skript.sh

• Gruppenberechtigung festlegen:

chmod g+x skript.sh

• Andere Berechtigung festlegen:

chmod o+x skript.sh

Vorsicht mit Root-Berechtigungen

Wenn du einem Skript Ausführungsrechte als Root-Benutzer gewährst, kann es in deinem System potenziell großen Schaden anrichten. Daher solltest du dies nur tun, wenn es unbedingt erforderlich ist.

Umgebungsvariablen festlegen

Umgebungsvariablen sind benannte Werte, die bestimmte Konfigurationen oder Metriken innerhalb eines Unix-ähnlichen Systems oder einer Shell-Sitzung speichern. Du kannst sie verwenden, um das Verhalten eines Skripts zu ändern oder zusätzliche Informationen an das Skript zu übergeben.

Hinzufügen von Umgebungsvariablen

Um eine Umgebungsvariable festzulegen, verwendest du die Syntax key=value gefolgt von dem zu ausführenden Befehl. So legst du beispielsweise die Variable MY_VAR auf den Wert my_value fest:

MY_VAR=my_value ./my_script.sh

Abrufen von Umgebungsvariablen

Um den Wert einer Umgebungsvariablen in deinem Skript abzurufen, verwendest du die Syntax $key. Beispielsweise würdest du die Variable MY_VAR in deinem Skript wie folgt abrufen:

echo $MY_VAR

Globale Umgebungsvariablen

Umgebungsvariablen können entweder global oder lokal für eine bestimmte Shell-Sitzung sein. Globale Umgebungsvariablen werden für alle Unterprozesse und Shells verfügbar sein, die von der aktuellen Shell gestartet werden. Um eine globale Umgebungsvariable festzulegen, kannst du den Befehl export verwenden. So legst du beispielsweise die globale Variable PATH fest:

export PATH=$PATH:/usr/local/bin

Lokale Umgebungsvariablen

Lokale Umgebungsvariablen sind nur für die aktuelle Shell-Sitzung verfügbar. Sie werden nicht an Unterprozesse oder andere Shells weitergegeben. Um eine lokale Umgebungsvariable festzulegen, verwendest du den Befehl local. So legst du beispielsweise die lokale Variable MY_VAR fest:

local MY_VAR=my_value

Verwendung von Umgebungsvariablen in Skripten

Du kannst Umgebungsvariablen in deinen Skripten verwenden, um beispielsweise auf Konfigurationseinstellungen zuzugreifen, Benutzereingaben zu speichern oder Informationen zwischen Skripten zu übergeben. Hier ist ein Beispiel für ein Skript, das eine Umgebungsvariable verwendet:

#!/bin/bash

# Hole den Wert der Umgebungsvariablen MY_VAR
my_var=$MY_VAR

# Verwende die Variable im Skript
echo "Der Wert von MY_VAR ist: $my_var"

Befehlszeilenargumente an Skript übergeben

Wenn du ein Linux-Skript ausführst, kannst du optionale Argumente an das Skript übergeben, um dessen Verhalten zu steuern oder zusätzliche Informationen bereitzustellen. Diese Argumente werden nach dem Skriptnamen in der Befehlszeile angegeben.

Argumente über $1, $2, … referenzieren

Die Argumente werden in speziellen Shell-Variablen gespeichert: $1 für das erste Argument, $2 für das zweite und so weiter. Um beispielsweise das erste Argument abzurufen, würdest du Folgendes verwenden:

echo $1

Argumente in Schleifen iterieren

Wenn du auf alle Argumente zugreifen möchtest, kannst du eine Schleife verwenden:

for arg in "$@"; do
  echo $arg
done

Argumente mit Getopt verarbeiten

Um Argumente flexibler zu verarbeiten und Optionen zu definieren, kannst du die getopt-Bibliothek verwenden. Mit getopt kannst du Optionen mit kurzen und langen Namen angeben und Argumente nach Optionstyp validieren.

Beispiel:

#!/bin/bash

# Optionen definieren
options="a:b::c"

# Argumente parsen
set -- $(getopt -q "$options" "$@")

# Optionen verarbeiten
while [ $# -gt 0 ]; do
  case $1 in
    -a) var1=$2; shift 2;;
    -b) var2=$2; shift 2;;
    -c) var3=true; shift 1;;
    --) shift; break;;
    -*) echo "Ungültige Option: $1"; exit 1;;
  esac
done

# ... Skriptlogik ...

Skript im Hintergrund ausführen

Wenn du ein Skript auf deinem System ausführst, wird es standardmäßig im Vordergrund ausgeführt und blockiert die Eingabeaufforderung, bis es abgeschlossen ist. In manchen Fällen kann es wünschenswert sein, ein Skript im Hintergrund auszuführen, sodass du andere Aufgaben ausführen kannst, während das Skript seine Arbeit erledigt.

Hintergrundaufgaben mit ‚&‘

Die einfachste Möglichkeit, ein Skript im Hintergrund auszuführen, ist das Anhängen eines kaufmännischen Und-Zeichens (&) an den Befehl. Beispiel:

./meinskript.sh &

Wenn du diesen Befehl ausführst, startet das Skript meinskript.sh im Hintergrund. Dir wird eine Prozess-ID (PID) angezeigt, die du verwenden kannst, um den Status des Skripts zu überwachen.

Jobsteuerung mit ‚bg‘ und ‚fg‘

Du kannst auch die Befehle bg und fg verwenden, um Jobs in den Hintergrund zu verschieben und in den Vordergrund zu holen. Führe dazu zunächst das Skript in der Eingabeaufforderung aus:

./meinskript.sh

Drücke dann Strg+z, um den Job anzuhalten. Du kannst den Job jetzt mit bg in den Hintergrund verschieben:

bg

Um den Job wieder in den Vordergrund zu holen, verwende fg:

fg

Verwendung von ’nohup‘ für unterbrechungsresistente Ausführung

Manchmal ist es wünschenswert, ein Skript auch dann weiter auszuführen, wenn die Verbindung zum Terminal unterbrochen wird. Hier kommt nohup ins Spiel. Dieser Befehl erstellt eine neue Sitzung für das Skript, die vom Terminal unabhängig ist. Beispiel:

nohup ./meinskript.sh > /dev/null 2>&1 &

Durch die Umleitung der Standardausgabe (> /dev/null) und der Standardfehlerausgabe (2>&1) wird sichergestellt, dass das Skript keine Ausgaben auf dem Terminal ausgibt.

Skriptausgabe umleiten

Wenn du die Ausgabe deines Skripts in eine Datei oder einen anderen Befehl umleiten möchtest, kannst du dies mit den folgenden Techniken tun:

Ausgabe in eine Datei umleiten

Verwende das Umleitungssymbol > gefolgt vom Dateinamen, um die Ausgabe in eine Datei umzuleiten. Beispiel:

./script.sh > ausgabe.txt

Ausgabe an einen anderen Befehl anhängen

Verwende das Symbol >> zum Anfügen der Ausgabe an das Ende einer bestehenden Datei. Beispiel:

./script.sh >> ausgabe.txt

Ausgabe in einen anderen Befehl umleiten

Verwende das Pipe-Symbol | gefolgt von dem zu verwendenden Befehl, um die Ausgabe in einen anderen Befehl umzuleiten. Beispiel:

./script.sh | grep "Fehler"

Ausgabe sowohl in eine Datei als auch in einen anderen Befehl umleiten

Du kannst die Ausgabe auch in eine Datei umleiten und gleichzeitig einen Befehl darauf anwenden, indem du den Befehl tee verwendest:

./script.sh | tee ausgabe.txt | grep "Fehler"

Fragen und Tipps

• Welche Dateiberechtigungen benötige ich, um in eine Datei umzuleiten? Du benötigst Schreibberechtigungen für die Datei, in die du umleiten möchtest.
• Warum wird meine Ausgabe nicht in die Datei umgeleitet? Überprüfe, ob du Schreibberechtigungen für die Datei hast und ob der Dateiname korrekt ist.
• Kann ich die Ausgabe in mehrere Dateien oder Befehle umleiten? Ja, du kannst Pipes (|) verwenden, um die Ausgabe in eine Kette von Befehlen oder Dateien umzuleiten.
• Wie kann ich die Umleitung debuggen? Verwende das Tool strace, um die Systemaufrufe zu verfolgen, die von deinem Skript ausgeführt werden, und um mögliche Probleme zu identifizieren.

Skriptausführung überwachen und verwalten

Die Überwachung und Verwaltung der Skriptausführung ist für die Sicherstellung eines reibungslosen Ablaufs und die Erkennung potenzieller Probleme unerlässlich. Hier sind einige bewährte Verfahren:

Den Skriptstatus überprüfen

Mit dem Befehl ps kannst du den Status laufender Prozesse überprüfen, einschließlich deiner Skripte. Gib ps aux | grep "dein_skriptname" ein, um Informationen zum Ausführungsstatus, zur Prozess-ID (PID), zum Benutzer und anderen Details zu erhalten.

Den Skriptfortschritt überwachen

Wenn dein Skript einen Fortschrittsbalken oder anderweitig sichtbare Meldungen ausgibt, kannst du seinen Fortschritt leicht überwachen. Andernfalls kannst du das Dienstprogramm tail verwenden, um der Skriptausgabe in Echtzeit zu folgen: tail -f /pfad/zum/skript.sh.

Ausgaben und Fehler protokollieren

Es ist ratsam, sowohl Standardausgaben als auch Fehlermeldungen in eine Protokolldatei umzuleiten. Dies erleichtert die Fehlerbehebung und ermöglicht dir die spätere Überprüfung des Skriptablaufs: dein_skript.sh > /pfad/zur/ausgabedatei 2>&1.

Prozess-ID abrufen

Die Prozess-ID (PID) ist eine eindeutige Kennung für jeden laufenden Prozess. Du kannst sie mit dem Befehl pgrep abrufen, um beispielsweise den Prozess deines Skripts zu beenden: kill -9 $(pgrep "dein_skriptname").

Skript im Hintergrund ausführen

Mit dem Symbol & kannst du ein Skript im Hintergrund ausführen, wodurch du die Konsole für andere Aufgaben verwenden kannst. Um den Status des Hintergrundprozesses zu überprüfen, verwende jobs und um einen Prozess zu beenden, gib kill %job_number.

Ausführung planen

Du kannst die Ausführung von Skripten mit Tools wie cron oder systemd planen. Dadurch wird sichergestellt, dass wichtige Aufgaben regelmäßig oder zu bestimmten Zeiten ausgeführt werden, selbst wenn du nicht eingeloggt bist.