{"id":14006,"date":"2022-05-30T10:37:25","date_gmt":"2022-05-30T10:37:25","guid":{"rendered":"https:\/\/profi-tutorials.de\/linux\/?page_id=14006"},"modified":"2022-11-23T15:28:50","modified_gmt":"2022-11-23T15:28:50","slug":"linux-befehle-pdf","status":"publish","type":"page","link":"https:\/\/profi-tutorials.de\/linux\/linux-befehle-pdf\/","title":{"rendered":"Linux Befehle PDF"},"content":{"rendered":"

Viele alltägliche Aufgaben lassen sich unter UNIX- bzw. Linux- Betriebssystemen<\/a><\/strong> mithilfe von verschiedenen Befehlen schnell und einfach erledigen – Der sichere Umgang mit dem Terminal<\/a><\/strong> ist daher eine besonders wichtige Fähigkeit für jeden Linux-\/UNIX-Benutzer.  <\/p>\n

In diesem Beitrag werden Sie einen umfassenden Überblick zu den wichtigsten dieser Befehle für UNIX \/ Linux erhalten. Die hier vorgestellten Befehle werden dazu in die Bereiche Grundlagen<\/strong>, Systemadministration <\/strong>und Netzwerke <\/strong>unterteilt. Im ersten Abschnitt Grundlagen <\/strong>finden Sie Befehle, die bei der Nutzung von Linux- bzw. UNIX- Betriebssystemen unabdingbar sind. Im Bereich Systemadministration <\/strong>lernen Sie Befehle kennen, die Sie bei Ihrer täglichen Administrationsarbeit benötigen. Schließlich folgt der Abschnitt Netzwerke<\/strong>, welcher sich besonders an fortgeschrittene Benutzer richtet, aber auch Einsteigern einige hilfreiche Informationen bietet.<\/p>\n

Grundlagen<\/h2>\n

Ein Terminal öffnen<\/h3>\n

Bevor Sie mit der Verwendung der Befehle beginnen können, müssen Sie zunächst ein Terminal auf Ihrem Linux-\/UNIX-System öffnen. Meist ist eine einfache Suche nach “terminal” über die Suchfunktion des Menü dabei ausreichend.<\/p>\n

Auf manchen Linux-Distributionen haben Sie zusätzlich jedoch auch die Möglichkeit, über die Tastenkombination [Alt+F2]<\/strong> ein “Run”-Eingabefeld zu öffnen. Dort können Sie durch Eingabe von “gnome-terminal” beispielsweise das gnome-terminal öffnen.<\/p>\n

gnome-terminal<\/p>\n

An- und Abmeldung<\/h3>\n

login – Benutzer anmelden<\/h4>\n

Der Befehl login <\/strong>wird verwendet, um einen Benutzer anzumelden. Falls bereits ein anderer Benutzer angemeldet ist,  wird dieser automatisch abgemeldet. Der Befehl wird normalerweise automatisch als Antwort auf die login:-Eingabeaufforderung im Terminal ausgeführt.  Es folgt die Syntax<\/a> des Befehls:<\/p>\n

login [Optionen] [Benutzer]\n<\/p>

Nach Ausführung des Befehls erfolgt eine Passwortabfrage für den Benutzer.<\/p>\n

logout – Aktiven Benutzer abmelden<\/h4>\n

Der zurzeit angemeldete Benutzer kann mit dem Befehl logout <\/strong>wieder abgemeldet werden:<\/p>\n

logout<\/p>\n

whoami – Aktiven Benutzer anzeigen<\/h4>\n

Der Abruf des aktuellen Benutzers ist vor allem bei häufigem Wechsel von Identitäten sehr hilfreich. Der mit der aktiven Benutzer-ID (UID) verknüpfte Benutzername lässt sich dazu mit dem Befehl whoami <\/strong>ausgeben:<\/p>\n

whoami<\/p>\n

su – Benutzer wechseln<\/h4>\n

Der Befehl su <\/strong>(s<\/strong>witch u<\/strong>ser) wird in der Praxis immer wieder benötigt: Er ermöglicht es Ihnen, die Identität eines anderen Benutzers anzunehmen. Die Syntax des Befehls lautet grundsätzlich folgendermaßen:<\/p>\n

su [Benutzername]\n<\/p>

Wir der Benutzername nicht mit angegeben, so wird automatisch der root-Benutzer<\/a> verwendet. Bevor Sie mit der Identität des jeweiligen Benutzers fortfahren können, erfolgt zudem eine Passwortabfrage.<\/p>\n

Der Befehl wird vor allem bei administrativen Aufgaben, die besondere root-Rechte benötigen, immer wieder benötigt, um einen Wechsel auf den root-Benutzer zu realisieren.<\/p>\n

sudo – Befehlsausführung im Namen anderer Benutzer<\/h4>\n

Mit dem Befehl sudo <\/strong>(su<\/strong> “do<\/strong>“) können Befehle im Namen bzw. mit den Berechtigungen anderer Benutzer ausgeführt werden. Anwendung findet der Befehl somit oft dann, wenn bestimmte Aktionen ausgeführt werden sollen, die root-Rechte erfordern.<\/p>\n

Damit ein Benutzer \/ eine Gruppe den Befehl sudo <\/strong>verwenden darf, muss er \/ sie in der Datei \/etc\/sudoers<\/strong> registriert werden. Standardmäßig wird hier die Gruppe “sudo”<\/strong> bereitgestellt, dessen Mitglieder alle den sudo<\/strong>-Befehl verwenden dürfen.<\/p>\n

Die allgemeine Syntax von sudo lautet:<\/p>\n

sudo [Optionen] [Befehl]\n<\/p>

sudo <\/strong>kann konkret mit der Option -i<\/strong> auch verwendet werden, um eine Rootshell <\/strong>zu starten:<\/p>\n

sudo -i<\/p>\n

Nähere Informationen zu sudo<\/strong>, der \/etc\/sudoers<\/strong> und verfügbaren Optionen sowie auch Beispiele finden Sie in unserem Beitrag sudo<\/a>.<\/p>\n

exit – Beenden von Sitzungen<\/h4>\n

Sitzungen, wie zum Beispiel Root-Sitzungen, die zuvor per su<\/strong>-Befehl gestartet wurden, oder auch SSH-Sitzungen, können mit dem Befehl exit <\/strong>wieder beendet werden. Genauso kann exit <\/strong>auch verwendet werden, um den aktiven Benutzer abzumelden – ähnlich wie beim dem Befehl logout<\/strong>.<\/p>\n

exit<\/p>\n

Verzeichnisnavigation<\/h3>\n

An erster Stelle ist es bei der Navigation von Verzeichnissen sicherlich sinnvoll zu wissen, wo wir uns gerade befinden. Der Befehl pwd <\/strong>(p<\/strong>rint w<\/strong>orking d<\/strong>irectory) gibt uns hierzu das aktuelle Arbeitsverzeichnis, also das Verzeichnis in dem der Benutzer gerade arbeitet, aus:<\/p>\n

pwd [Optionen]\n<\/p>

In den meisten Fällen werden bei der Verwendung von pwd <\/strong>keine Optionen benötigt. Wenn Sie dennoch Näheres zu den verfügbaren Optionen erfahren möchten, lesen Sie auch unseren Beitrag pwd<\/strong>.<\/p>\n

Der Navigation von Verzeichnissen dient der Befehl cd<\/strong> (c<\/strong>hange d<\/strong>irectory), welcher das Wechseln des aktuellen Arbeitsverzeichnisses ermöglicht. cd <\/strong>ist ein eingebauter Befehl der Shell und muss damit nicht zusätzlich installiert werden.<\/p>\n

cd <\/strong>wird folgendermaßen angewendet:<\/p>\n

cd [Optionen] [Verzeichnis]\n<\/p>

Optionen werden für die meisten Anwendungen des Befehls cd <\/strong>nicht benötigt. Die Angabe eines Verzeichnisses erfolgt mithilfe absoluter oder relativer Verzeichnispfade. Wenn Sie mehr über die verschiedenen Möglichkeiten zur Anwendung des Befehls cd <\/strong>erfahren möchten, sehen Sie sich auch unseren Beitrag cd<\/strong><\/a> an.<\/p>\n

Bei der Verzeichnisnavigation ist es auch wichtig, die Inhalte eines Verzeichnisses, etwa das aktuelle Arbeitsverzeichnis, anzeigen zu können. Hierzu wird der Befehl ls <\/strong>verwendet:<\/p>\n

ls [Optionen] [Datei \/ Verzeichnis]\n<\/p>

Werden weder eine Datei, noch ein Verzeichnis angegeben, so gibt ls <\/strong>standardmäßig den Inhalt des aktuellen Arbeitsverzeichnisses, unter Auflistung der Datei- und \/ oder Verzeichnisnamen aus. Mithilfe absoluter oder relativer Verzeichnis- \/ Dateipfade können die Inhalte bestimmter anderer Verzeichnisse oder einzelne Dateien ausgegeben werden.<\/p>\n

Eine der wichtigsten Optionen des Befehls ls <\/strong>ist die Option -l<\/strong>, welche die Ausgabe detaillierterer Informationen<\/strong> zu Berechtigungen, Zeitstempeln, Kapazitäten etc. ermöglicht:<\/p>\n

ls -l [Datei \/ Verzeichnis]\n<\/p>

Versteckte Dateien<\/strong> können mithilfe der Option -a<\/strong> angezeigt werden:<\/p>\n

ls -a [Datei \/ Verzeichnis]\n<\/p>

Nähere Informationen zum Befehl ls <\/strong>finden Sie in unserem Beitrag ls<\/strong><\/a>.<\/p>\n

Datei-\/Verzeichnismanipulation<\/h3>\n

mkdir – Erstellen von Verzeichnissen<\/h4>\n

Mithilfe von mkdir <\/strong>(m<\/strong>ak<\/strong>e dir<\/strong>ectory) können Sie neue Verzeichnisse erstellen, unter denen weitere Dateien und Verzeichnisse angelegt werden können:<\/p>\n

mkdir [Optionen] [Pfad]\n<\/p>

Wenn Sie einen ganzen Pfad von noch nicht existierenden, verschachtelten Verzeichnissen anlegen wollen, dann müssen Sie die Option -p<\/strong> zusätzlich übergeben. Fehlende Verzeichnisse des angegebenen Pfades werden bei der Ausführung automatisch angelegt.<\/p>\n

mkdir -p [Pfad]\n<\/p>

Für weitere Informationen lesen Sie unseren Beitrag mkdir<\/strong><\/a>.<\/p>\n

touch – Anlegen von Dateien \/ Aktualisieren der Zugriffszeit<\/h4>\n

Neue Dateien mit aktuellen Daten, wie beispielsweise der Zugriffszeit, können mit dem Befehl touch <\/strong>angelegt werden. touch <\/strong>legt jedoch nur dann neue Dateien der Länge null an, wenn die angegebene Datei noch nicht im jeweiligen Verzeichnis existiert. Existiert die Datei bereits, dann wird lediglich ihr Zugriffsdatum bzw. ihre Zugriffszeit aktualisiert. Die Syntax des Befehls lautet:<\/p>\n

touch [Optionen] [Dateipfad]\n<\/p>

Mehr Informationen dazu finden Sie in unserem Beitrag touch<\/strong><\/a>.<\/p>\n

rmdir – Löschen von Verzeichnissen<\/h4>\n

Der Befehl rmdir <\/strong>wird verwendet, um Verzeichnisse zu löschen. Dabei ist zu beachten, dass nur leere Verzeichnisse gelöscht werden können.<\/p>\n

rmdir [Optionen] [Pfad]\n<\/p>

rm – Löschen von Dateien\/Verzeichnissen<\/h4>\n

Einträge einer oder mehrerer Dateien können mit dem Befehl rm <\/strong>aus einem Verzeichnis gelöscht werden.<\/p>\n

rm [Optionen] [Pfad]\n<\/p>

Der Befehl kann außerdem verwendet werden, um rekursiv<\/a> <\/strong>den gesamten Inhalt eines Verzeichnisses zu löschen. Dazu verwenden Sie die Option -r<\/strong>:<\/p>\n

rm -r [Pfad]\n<\/p>

mv – Verschieben und Umbenennen<\/h4>\n

Je nach Anwendung lassen sich mit mv <\/strong>(m<\/strong>ov<\/strong>e) Dateien und Verzeichnisse verschieben und umbenennen. Verschieben lassen sich Dateien \/ Verzeichnisse durch Angabe des alten und neuen Pfades:<\/p>\n

mv [alter Pfad] [neuer Pfad]\n<\/p>

Beim Umbenennen einer Datei \/ eines Verzeichnisses bleiben der alte und der neue Pfad gleich. Lediglich der Datei-\/Verzeichnisname wird verändert.<\/p>\n

cp – Kopieren<\/h4>\n

Mit cp <\/strong>können Sie eine Datei in eine Datei mit einem anderen Namen, oder in ein anderes Verzeichnis kopieren. Außerdem haben Sie die Möglichkeit, mehrere Dateien in ein bestimmtes Verzeichnis zu kopieren. Die Syntax des Befehls lautet:<\/p>\n

cp [Quelle] [Ziel]\n<\/p>

Mehr Informationen zu diesem Befehl finden Sie in unserem Beitrag cp<\/strong><\/a>.<\/p>\n

nano – Texteditor<\/h4>\n

Der Befehl nano <\/strong>ruft einen einfachen Texteditor auf. Zum einen haben Sie die Möglichkeit, eine bestimmte, existierende Datei durch Angabe des Dateipfads mit dem Texteditor zu bearbeiten. Zum anderen können Sie auch eine neue Datei erstellen und diese direkt bearbeiten – Dazu wird entweder kein Pfad angegeben oder die angegebene Datei existiert nicht.<\/p>\n

nano [Dateipfad]\n<\/p>

Mehr Informationen zu diesem Befehl finden Sie in unserem Beitrag nano<\/strong><\/a>.<\/p>\n

cat – Ausgeben von Dateiinhalten<\/h4>\n

Mit cat <\/strong>können Sie den Inhalt einer Datei direkt im Terminal ausgeben, ohne diese zu manipulieren. Der Pfad der Datei wird dazu einfach hinter dem Befehl angegeben:<\/p>\n

cat [Dateipfad]\n<\/p>

Da die angegebene Datei bei der Ausgabe durch cat<\/strong> nicht modifiziert werden kann, eignet sich der Befehl hervorragend dazu, den Inhalt einer Datei nach der Bearbeitung noch einmal zu überprüfen.<\/p>\n

Mehr Informationen zu diesem Befehl finden Sie in unserem Beitrag cat<\/strong><\/a>.<\/p>\n

less – Anzeige von Dateiinhalten mittels Pager<\/h4>\n

less <\/strong>dient als Pager der Anzeige des Inhalts von Dateien. Dabei ist es unter anderem möglich, sowohl vor- als auch rückwärts durch die Inhalte zu scrollen. Über verschiedene Tastenkombinationen, die im weiteren Verlauf noch gezeigt werden, sind auch noch andere Funktionen nutzbar. Im Allgemeinen wird less <\/strong>wie folgt aufgerufen:<\/p>\n

less [Datei]\n<\/p>

Die übergebene Datei wird standardmäßig in einem interaktiven Modus, welcher auf verschiedene Tastatureingaben reagiert, geöffnet. Der folgenden Tabelle sind die zur Steuerung von less <\/strong>verfügbaren Tastenkombinationen zu entnehmen:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
\n

Taste<\/strong><\/p>\n<\/th>\n

\n

Funktion<\/p>\n<\/th>\n<\/tr>\n<\/thead>\n

\n[Pfeiltaste hoch]\n<\/td>\n\n

Eine Zeile weiter<\/p>\n<\/td>\n<\/tr>\n

\n[Pfeiltaste runter]\n<\/td>\n\n

Eine Zeile zurück<\/p>\n<\/td>\n<\/tr>\n

\n[E]\n<\/td>\n\n

Alternative: Eine Zeile weiter<\/p>\n<\/td>\n<\/tr>\n

\n[Y]\n<\/td>\n\n

Alternative: Eine Zeile zurück<\/p>\n<\/td>\n<\/tr>\n

\n[Bild auf]\n<\/td>\n\n

Eine Bildschirmseite weiter<\/p>\n<\/td>\n<\/tr>\n

\n[Bild ab]\n<\/td>\n\n

Eine Bildschirmseite zurück<\/p>\n<\/td>\n<\/tr>\n

\n[F]\n<\/td>\n\n

Alternative: Eine Bildschirmseite weiter<\/p>\n<\/td>\n<\/tr>\n

\n[B]\n<\/td>\n\n

Alternative: Eine Bildschirmseite zurück<\/p>\n<\/td>\n<\/tr>\n

\n[Leertaste]\n<\/td>\n\n

Alternative: Eine Bildschirmseite weiter<\/p>\n<\/td>\n<\/tr>\n

\n

N [Z]\n<\/p><\/td>\n

\n

Springt N Zeilen vorwärts. Zuerst wird dazu eine Zahl N eingegeben und anschließend die Taste [Z] betätigt.<\/p>\n<\/td>\n<\/tr>\n

\n

N [W]\n<\/p><\/td>\n

\n

Springt N Zeilen rückwärts. Wird analog zum Vorwärtsspringen um N Zeilen verwendet.<\/p>\n<\/td>\n<\/tr>\n

\n[G]\n<\/td>\n\n

Springt zum Anfang der Datei<\/p>\n<\/td>\n<\/tr>\n

\n[Shift] + [G]\n<\/td>\n\n

Springt zum Ende der Datei<\/p>\n<\/td>\n<\/tr>\n

\n[\/] Suchbegriff\n<\/td>\n\n

Springt zu Vorkommnissen des angegebenen Suchbegriffs. Für eine Suche wird zuerst die Slash-Taste betätigt und anschließend der Suchbegriff eingegeben. Mit der Taste [N] kann vorwärts durch die Suchergebnisse navigiert werden, mit der Tastenkombination [Shift] + [N] rückwärts.<\/p>\n<\/td>\n<\/tr>\n

\n[H]\n<\/td>\n\n

Hilfeseite mit verfügbaren Funktionen anzeigen<\/p>\n<\/td>\n<\/tr>\n

\n[Q]\n<\/td>\n\n

less beenden<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Weitere Informationen finden Sie in unserem Beitrag less<\/strong><\/a>. Lesen Sie zudem auch den Beitrag more<\/strong><\/a>, welcher einen alternativen Befehl für die Anzeige von Dateiinhalten behandelt.<\/p>\n

head – Ausgabe vom Dateianfang<\/h4>\n

Der Befehl head <\/strong>kann – ähnlich wie der zuvor gezeigte Befehl cat <\/strong>– verwendet werden, um Inhalte einer Datei auszugeben. head wird jedoch in der Regel nicht zur Ausgabe des kompletten Inhalts, sondern nur von einem bestimmten Anteil vom Anfang bzw. Kopf einer Datei, verwendet. Wird head <\/strong>nur der Pfad einer Datei übergeben, so werden die ersten zehn Zeilen<\/strong> dieser Datei ausgegeben:<\/p>\n

head [Dateipfad]\n<\/p>

Die Angabe mehrerer Dateipfade ist möglich – hierbei werden die Ausgaben jeder Datei jeweils von einer Kopfzeile mit dem entsprechenden Dateinamen angeführt. Soll eine andere Anzahl Zeilen ausgegeben werden als die standardmäßigen zehn, so kann ein entsprechender Wert mithilfe der Option -n<\/strong> spezifiziert werden:<\/p>\n

head -n [Anzahl Zeilen] [Dateipfad]\n<\/p>

Die meist benötigten Anwendungen des Befehls sind hiermit abgedeckt. Für weitere Optionen zu diesem Befehl lesen Sie unseren ausführlichen Beitrag head<\/strong><\/a>.<\/p>\n

tail – Ausgabe vom Dateiende<\/h4>\n

Das Gegenstück zu head <\/strong>bildet der Befehl tail<\/strong>, welcher zur Ausgabe eines Teils vom Ende einer Datei verwendet wird. Standardmäßig gibt tail <\/strong>die letzten zehn Zeilen<\/strong> der übergebenen Datei aus:<\/p>\n

tail [Dateipfad]\n<\/p>

Bei Angabe mehrerer Dateien werden auch hier Kopfzeilen ausgegeben. Ähnlich wie bei head <\/strong>kann zudem wieder die Option -n<\/strong> verwendet werden, um eine andere Anzahl Zeilen auszugeben:<\/p>\n

tail -n [Anzahl Zeilen] [Dateipfad]\n<\/p>

tail <\/strong>bietet außerdem noch die Option -f<\/strong>, um bei einer wachsenden Datei jeweils die hinzugekommenen Daten auszugeben. Werden dabei mehrere Dateien angegeben, dann wird immer eine Kopfzeile ausgegeben, wenn in einer anderen Datei etwas hinzugefügt wurde:<\/p>\n

tail -f [Dateipfad]\n<\/p>

Mehr Informationen zu diesem Befehl finden Sie in unserem Beitrag tail<\/strong><\/a>.<\/p>\n

ln – Verknüpfungen erstellen<\/h4>\n

Der Befehl ln<\/strong> (l<\/strong>in<\/strong>k) wird verwendet, um Verknüpfungen (Links) zu Dateien oder Verzeichnissen zu erstellen, wobei zwischen sogenannten Hard-<\/strong> und Softlinks<\/strong> unterschieden wird. Die allgemeine Syntax des Befehls lautet folgendermaßen:<\/p>\n

ln [Optionen] [Ziel] [Verknüpfungsname]\n<\/p>

Neben der allgemeinen Syntax ist zudem noch eine andere Syntax zum Verlinken mehrerer Dateien in ein Verzeichnis zu unterscheiden:<\/p>\n

ln [Optionen] [Ziel(e)] [Linkverzeichnis]\n<\/p>

Standardmäßig erzeugt ln <\/strong>sogenannte Hardlinks <\/strong>– sollen stattdessen Softlinks <\/strong>erzeugt werden, so verwenden Sie die Option -s<\/strong>:<\/p>\n

ln -s [Ziel] [Verknüpfungsname]\n<\/p>

Wenn Sie nähere Informationen zur Unterscheidung zwischen Hard-<\/strong> und Softlinks<\/strong>, den weiteren Optionen des Befehls sowie auch einige Beispielanwendungen benötigen, dann lesen Sie auch unseren Beitrag ln<\/strong><\/a>.<\/p>\n

Suchen in Dateien<\/h3>\n

Die Suche nach verschiedenen Mustern in Dateien ist mithilfe des Befehls grep <\/strong>(“G<\/strong>lobal Search for a R<\/strong>egular E<\/strong>xpression and P<\/strong>rint out matches lines”) möglich. Neben festen Zeichenketten<\/a> können für die Suche auch reguläre Ausdrücke<\/a> verwendet werden. Es folgt die allgemeine Syntax des Befehls grep<\/strong>:<\/p>\n

grep [Optionen] [Muster] [Dateipfad]\n<\/p>

Neben der Angabe eines einzelnen Dateipfades ist auch die Übergabe mehrerer Dateipfade möglich. Die Pfade werden dabei durch Leerzeichen voneinander getrennt. In der Ausgabe kennzeichnet grep <\/strong>dann jeweils am Anfang jedes Suchergebnisses, zu welcher Datei die Suchergebnisse gehören.<\/p>\n

Sollen alle Dateien in einem Verzeichnis sowie rekursiv aus Unterverzeichnissen durchsucht werden, so können Sie auch die Option -R<\/strong> verwenden und den entsprechenden Verzeichnispfad übergeben. Wird kein Verzeichnispfad angegeben, so sucht grep <\/strong>rekursiv im aktuellen Arbeitsverzeichnis:<\/p>\n

grep -R [Muster] [Verzeichnispfad]\n<\/p>

Ebenfalls hilfreich ist die Option -n<\/strong>, welche die Anzeige von Zeilennummern aktiviert. Die Zeilennummern werden dann an den Anfang jeder gefundenen Zeile angehängt:<\/p>\n

grep -n [Muster] [Dateipfad]\n<\/p>

Weitere Informationen zum Befehl grep<\/strong>, seinen Optionen sowie auch einige Anwendungsbeispiele finden Sie im Beitrag grep<\/strong><\/a>.<\/p>\n

Suchen im Dateisystem<\/h3>\n

Eine Suche nach Dateien oder Verzeichnissen lässt sich unter Linux- bzw. UNIX- Systemen leicht mit dem Befehl find <\/strong>durchführen. Sie können dabei von beliebigen Startpunkten aus ganze Verzeichniszweige durchsuchen und die Ergebnisse zudem auch filtern.<\/p>\n

Der Befehl stellt neben den einfachen Such- und Filterfunktionen auch noch einige speziellere Funktionen bereit, die Ihn zu einem mächtigen Universalwerkzeug machen.<\/p>\n

find – Datei-\/Verzeichnissuche<\/h4>\n

find <\/strong>kann mit einer Vielzahl Optionen ausgeführt werden, um verschiedene Daten für die Suche heranzuziehen und die Ergebnisse zusätzlich zu filtern. Die Syntax des Befehls lautet jedoch allgemein:<\/p>\n

find [Startpunkt] [Optionen \/ Ausdruck]\n<\/p>

Filtern nach Name<\/h5>\n

Bei einer einfachen Datei- oder Verzeichnissuche nach einem bestimmten Namen wird die Option -name<\/strong> verwendet. Sie benötigen außerdem den Startpunkt für die Suche, sowie die Suchbedingungen bzw. den exakten Namen der gesuchten Datei \/ des gesuchten Verzeichnisses:<\/p>\n

find [Startpunkt] -name [Datei-\/Verzeichnisname]\n<\/p>

Wenn Sie die Groß- und Kleinschreibung bei der Suche ignorieren wollen, dann können Sie auch die Option -iname<\/strong> verwenden:<\/p>\n

find [Startpunkt] -iname [Datei-\/Verzeichnisname]\n<\/p>

Bei der Angabe von Datei- bzw. Verzeichnisnamen ist es auch möglich, sogenannte Wildcards<\/a> <\/strong>zu verwenden, um eine dynamische Suche nach mehreren Dateien durchzuführen. Eine genaue Kenntnis des Dateinamen ist somit auch nicht nötig.<\/p>\n

Filtern nach Kapazität<\/h5>\n

Die Option -size<\/strong> wird verwendet, um Dateien und Verzeichnisse aufgrund ihrer Kapazität zu filtern. Die Syntax lautet hier:<\/p>\n

find [Startpunkt] -size [+-][Kapazität][ckMG]\n<\/p>

Bei der einfachen Angabe einer Kapazität werden alle Dateien\/Verzeichnisse gesucht, die dieser genau entsprechen. Die Einheit können Sie dabei durch Anhängen der Zeichen ‘c’ für Byte<\/strong>, ‘k’ für Kilobyte<\/strong>, ‘M’ für Megabyte<\/strong> und ‘G’ für Gigabyte<\/strong> festlegen. Wenn Sie keine Einheit angeben, dann bezieht sich die Kapazität auf die Anzahl belegter Blöcke<\/strong> im Dateisystem<\/a>.<\/p>\n

Statt einer genauen Kapazitäts-Angabe können Sie schließlich auch ein Plus ‘+’<\/strong> oder Minus ‘-‘<\/strong> voranstellen. Das ‘+’ steht dann für “größer als”<\/strong>, während das ‘-‘ für “kleiner als”<\/strong> steht.<\/p>\n

Filtern nach Zugriffsrechten<\/h5>\n

Bei der Suche können Sie auch nach Dateien mit bestimmten Zugriffsrechten filtern. Dazu verwenden Sie die Option -perm<\/strong> und geben die Zugriffsrechte als Oktalzahl<\/strong> an:<\/p>\n

find [Startpunkt] -perm [Zugriffsrechte als Oktalzahl]\n<\/p>

Informationen zur Schreibweise als Oktalzahl finden Sie in unserem Beitrag Linux-Berechtigungssystem<\/a>.<\/p>\n

Filtern nach Besitzer<\/h5>\n

Mit der Option -user<\/strong> können Sie auch nach Dateien\/Verzeichnissen mit einem bestimmten Besitzer suchen:<\/p>\n

find [Startpunkt] -user [Benutzername]\n<\/p>

Filtern nach Typ<\/h5>\n

Zuletzt können Sie mit -type<\/strong> auch noch nach Elementen mit bestimmter Typisierung suchen. Die wichtigsten Parameter für die Nutzung mit dieser Option sind ‘f’ für Dateien<\/strong> (f<\/strong>ile), ‘d’ für Verzeichnisse<\/strong> (d<\/strong>irectories) und ‘l’ für symbolische Links<\/strong> (l<\/strong>ink).<\/p>\n

Mehr Informationen zu diesem Befehl finden Sie in unserem Beitrag find<\/strong><\/a>.<\/p>\n

locate – Datei- \/ Verzeichnissuche mit Datenbank<\/h4>\n

Als Alternative zu find <\/strong>wird an dieser Stelle auch einmal kurz der Befehl locate <\/strong>vorgestellt. Dieser greift bei der Suche auf eine oder mehrere Datenbankdateien zurück, welche die Datei- und Verzeichnisnamen des Dateisystems beinhalten. Im Vergleich zum Befehl find <\/strong>bietet locate <\/strong>durch die Suche in einer Datenbank<\/a> eine höhere Suchgeschwindigkeit<\/strong> – Voraussetzung ist jedoch die regelmäßige Aktualisierung der Datenbank(en). Der Befehl ist nicht auf allen Systemen standardmäßig vorinstalliert, kann jedoch mit einem Paketmanager wie apt <\/strong>nachinstalliert werden.<\/p>\n

Bevor eine erste Suche durchgeführt wird, ist es unter Umständen notwendig, die Datenbank zu aktualisieren. Die Aktualisierung erfolgt durch den Cron-Daemon<\/a> standardmäßig einmal täglich automatisch. Mit dem folgenden Befehl wird eine Aktualisierung manuell angestoßen:<\/p>\n

updatedb<\/p>\n

Eine einfache Suche wird mithilfe der folgenden Syntax durchgeführt:<\/p>\n

locate [Suchmuster]\n<\/p>

Neben einfachen Zeichenfolgen können im Suchmuster auch Wildcards <\/strong>(“*”, “?”, “[]”) verwendet werden. Bei Verwendung einfacher Zeichenfolgen gibt locate <\/strong>alle Dateien und Verzeichnisse aus, die diese Zeichenfolge an beliebiger Stelle in ihrem Namen beinhalten. Werden dagegen Wildcards verwendet, so gibt locate nur exakte Übereinstimmungen aus. Weitere Informationen erfahren Sie in unserem Beitrag wildcard<\/strong><\/a>.<\/p>\n

Dieser Abschnitt zeigt lediglich überblicksartig die grundlegendsten Funktionalitäten des Befehls locate<\/strong>. Genauere Informationen, wie beispielsweise zu den Optionen von updatedb <\/strong>und locate<\/strong>, finden Sie in unserem Beitrag locate<\/strong><\/a>.<\/p>\n

Systembefehle<\/h3>\n

shutdown – Herunterfahren \/ Neustart<\/h4>\n

Mit dem Befehl shutdown <\/strong>können Neustarts, das Herunterfahren des Systems eingeleitet und durch bestimmte Optionen sogar zeitlich gesteuert werden.<\/p>\n

Herunterfahren lässt sich das System mit der Option -h<\/strong>. Sie müssen zusätzlich außerdem einen Zeitpunkt festlegen, zu dem der Vorgang gestartet werden soll. Dieser kann entweder in Minuten nach Befehlsausführung oder im 24 Stunden Format “hh:mm”<\/strong> angegeben werden:<\/p>\n

shutdown -h [Zeit]\n<\/p>

Neustarts werden mit der Option -r <\/strong>(reboot) durchgeführt:<\/p>\n

shutdown -r [Zeit]\n<\/p>

Zuletzt gibt es noch die Möglichkeit, ein geplantes Herunterfahren \/ einen Neustart vorzeitig abzubrechen. Dazu verwenden Sie die Option -c<\/strong> (cancel):<\/p>\n

shutdown -c<\/p>\n

Unter Debian 10 Buster kann shutdown<\/strong> aufgrund des vollständigen Wechsels auf systemd<\/a><\/strong> nicht mehr ohne Weiteres eingesetzt werden. Sie können stattdessen auf den Befehl systemctl <\/strong>zurückgreifen, welcher im Folgenden einmal erklärt wird.<\/p>\n

systemctl – Kontrolle des systemd System- und Service-Manager<\/h4>\n
Herunterfahren \/ Neustarten<\/h5>\n

Mit systemctl <\/strong>können Befehle an systemd <\/strong>gesendet werden, um beispielweise das System herunterzufahren oder neuzustarten. Ein Herunterfahren wird mit poweroff <\/strong>eingeleitet:<\/p>\n

systemctl poweroff<\/p>\n

Neustarts können Sie mit reboot <\/strong>durchführen:<\/p>\n

systemctl reboot<\/p>\n

Steuerung von Services \/ Units<\/h5>\n

Neben poweroff <\/strong>und reboot <\/strong>bietet das Befehlszeilenwerkzeug systemctl <\/strong>auch noch Funktionen für die Steuerung von Systemprogrammen, sogenannten Units.<\/p>\n

Zunächst gibt es die beiden Funktionen start <\/strong>und stop<\/strong>, welche zum Starten und Stoppen der Units verwendet werden können:<\/p>\n

systemctl [start \/ stop] [Unit]\n<\/p>

Die Funktion restart <\/strong>wird verwendet, um Units neuzustarten. Dies ist hilfreich, wenn nach einer Änderung beispielsweise die Konfigurationsdateien eines Programms neu eingelesen werden sollen:<\/p>\n

systemctl [restart] [Unit]\n<\/p>

Schließlich gibt es noch die Funktion status<\/strong>, welche, wie der Name schon vermuten lässt, den Status einer Unit im Terminal ausgibt.<\/p>\n

systemctl [status] [Unit]\n<\/p>

Benutzer-\/Gruppenverwaltung<\/h3>\n

In diesem Abschnitt werden Sie einige wichtige Befehle für die Verwaltung von Benutzern und Gruppen unter Linux- bzw. UNIX-Betriebssystemen kennen lernen.<\/p>\n

Wenn Sie Näheres zur Funktionsweise des Benutzer-\/Gruppensystems und den Befehlen erfahren wollen, lesen Sie auch unseren ausführlichen Beitrag Benutzer und Gruppen unter Linux<\/a>. Sie finden dort außerdem Beispielanwendungen für die Befehle.<\/p>\n

Die meisten der folgenden Befehle erfordern für ihre Ausführung die Rechte des root-Benutzers.<\/p>\n

Benutzer<\/h4>\n
adduser – Hinzufügen neuer Benutzer<\/h5>\n

Mit dem Befehl adduser <\/strong>können Sie neue Benutzer erstellen. Der Befehl benötigt dazu lediglich den Namen des zu erstellenden Benutzers, alle anderen notwendigen Daten werden automatisch abgefragt. Dazu gehört das Passwort, der vollständige Name des Benutzers, sowie einige optionale Daten wie  die Zimmernummer, Telefon und Sonstiges.<\/p>\n

adduser [Benutzername]\n<\/p>

Neben dem Benutzer wird auch eine gleichnamige Gruppe und ein entsprechendes Home-Verzeichnis erstellt.<\/p>\n

passwd – Ändern von Passwörtern<\/h5>\n

Das Ändern von Passwörtern ist mit dem Befehl passwd <\/strong>möglich: Der Root-Benutzer hat dabei die Möglichkeit, das Passwort eines jeden Benutzers zu ändern\/aktualisieren. Der jeweilige Benutzername wird dazu einfach als Parameter übergeben. Jeder Benutzer kann außerdem sein eigenes Passwort ändern – dazu ist keine Angabe eines Benutzernamen notwendig.<\/p>\n

passwd [Benutzername]\n<\/p>

Mehr Informationen zu diesem Befehl finden Sie in unserem Beitrag passwd<\/strong><\/a>.<\/p>\n

usermod – Bearbeiten von Benutzerkonten<\/h5>\n

Der Befehl usermod <\/strong>ermöglicht die Bearbeitung von Informationen und Gruppenzugehörigkeiten bereits existierender Benutzerkonten. Dabei kommen verschiedene Optionen zum Einsatz. Zunächst folgt jedoch die allgemeine Syntax des Befehls:<\/p>\n

usermod [Optionen] [Benutzer]\n<\/p>

Mit der Option -l<\/strong> können Sie einen bestehenden Benutzer umbenennen:<\/p>\n

usermod -l [Neuer Benutzername] [Benutzer]\n<\/p>

Benutzer können mit den Optionen -aG<\/strong> in Gruppen hinzugefügt werden:<\/p>\n

usermod -aG [Gruppe\/-n] [Benutzer]\n<\/p>

deluser – Löschen von Benutzern<\/h5>\n

Wollen Sie einen Benutzer wieder löschen, dann kommt der Befehl deluser <\/strong>zum Einsatz. Die Syntax lautet:<\/p>\n

deluser [Optionen] [Benutzer]\n<\/p>

Wenn Sie dem Befehl keine besonderen Optionen übergeben, dann wird zwar der Benutzer gelöscht, das Home-Verzeichnis, sowie alle vom Benutzer erstellten Daten bleiben jedoch erhalten. Wenn Sie das Home-Verzeichnis ebenfalls löschen wollen, dann verwenden Sie daher die Option –remove-home<\/strong>:<\/p>\n

usermod –remove-home [Benutzer]\n<\/p>

Sie können mit der Option –remove-all-files<\/strong> zudem auch alle Dateien des Benutzers löschen:<\/p>\n

usermod –remove-all-files [Benutzer]\n<\/p>

chsh – Wechseln der Login-Shell<\/h5>\n

Die Login-Shell eines Benutzers kann mithilfe des Befehls chsh <\/strong>geändert werden. Da chsh Teil des Pakets passwd <\/strong>ist, ist es auf den meisten Systemen bereits vorinstalliert und kann direkt verwendet werden. Die Syntax von chsh <\/strong>lautet:<\/p>\n

chsh [Optionen] [Benutzer]\n<\/p>

Bei Ausführung ohne jegliche Argumente startet chsh im interaktiven Modus und fragt eine Login-Shell ab, die für den aktuellen Benutzer gesetzt werden soll. Dem Root-Benutzer ist es zudem möglich, einen Benutzernamen übergeben, um die Login-Shell für einen anderen Benutzer zu setzen – auch hier wird standardmäßig im interaktiven Modus gestartet. Es ist zu beachten, dass die jeweils spezifizierte Shell in der Datei \/etc\/shells<\/strong> vorhanden sein muss. Nur der Root-Benutzer darf jeden beliebigen Befehl angeben.<\/p>\n

Die Login-Shell kann auch mit der Option -s<\/strong> spezifiziert werden, wenn eine interaktive Abfrage nicht gewünscht wird:<\/p>\n

chsh -s [Login-Shell] [Benutzer]\n<\/p>

Nähere Informationen zu diesem Befehl finden Sie in unserem Beitrag chsh<\/strong><\/a>.<\/p>\n

id – Benutzer- \/ Gruppeninformationen abfragen<\/h5>\n

Benutzer- und Gruppeninformationen lassen sich mithilfe des Befehls id <\/strong>für bestimmte Benutzer abfragen. Die ausgegebenen Informationen umfassen dann unter anderem die UID<\/strong>, die primäre GID<\/strong> sowie alle weiteren Gruppen<\/strong> des jeweiligen Benutzers. Da id <\/strong>Teil des Pakets coreutils <\/strong>ist, ist es in der Regel bereits vorinstalliert. Es folgt die allgemeine Syntax des Befehls:<\/p>\n

id [Optionen] [Benutzer]\n<\/p>

Wird id <\/strong>ohne Übergabe eines Benutzernamens ausgeführt, so werden die genannten Informationen für den aktuellen Benutzer abgefragt – andernfalls erfolgt die Abfrage für den jeweils angegebenen Benutzer. Die Ausgabe hat dabei das folgende Format:<\/p>\n

uid=[UID]([Benutzername]) gid=[GID]([Gruppenname]) Gruppen=[GID]([Gruppenname]),…<\/p>\n

Durch Angabe verschiedener Optionen ist es möglich, die Ausgabe von id <\/strong>weiter anzupassen. Unter anderem ist so etwa die Ausgabe nur von effektiven<\/strong> oder realen IDs<\/strong> möglich. Nähere Informationen zu diesen Optionen sowie auch Beispiele zur Anwendung des Befehls id <\/strong>können Sie im Beitrag id<\/strong><\/a> <\/strong>nachlesen.<\/p>\n

Gruppen<\/h4>\n
addgroup – Hinzufügen neuer Gruppen<\/h5>\n

Neue Gruppen können Sie mit addgroup <\/strong>erstellen. Sie müssen dabei lediglich den Namen der Gruppe angeben:<\/p>\n

addgroup [Gruppenname]\n<\/p>

groupmod – Bearbeiten von Gruppen<\/h5>\n

Mit dem Tool groupmod <\/strong>können Sie bestehende Gruppen bearbeiten. Die Syntax ist dabei ähnlich wie bei usermod:<\/p>\n

groupmod [Optionen] [Gruppe]\n<\/p>

Sie haben auch hier wieder die Möglichkeit, verschiedene Optionen einzusetzen. Eine der wichtigsten Optionen des Befehls ist –new-name<\/strong>, welche für das Umbenennen von Gruppen verwendet wird:<\/p>\n

groupmod –new-name [Gruppe]\n<\/p>

delgroup – Löschen von Gruppen<\/h5>\n

Schließlich können Sie Gruppen mit delgroup <\/strong>auch wieder löschen:<\/p>\n

delgroup [Optionen] [Gruppe]\n<\/p>

Während Gruppen bei Ausführung ohne zusätzliche Optionen ohne jegliche Rückfrage gelöscht werden, gibt es hier noch die Option –only-if-empty<\/strong>, welche sicherstellt, dass Gruppen nur dann gelöscht werden, wenn sie auch wirklich leer sind – also keine Mitglieder mehr enthalten:<\/p>\n

delgroup –only-if-empty [Gruppe]\n<\/p>

Berechtigungen<\/h3>\n

Unter Linux- bzw- UNIX-Betriebssystemen bekommen sowohl Dateien, als auch Verzeichnisse alle einen Besitzer (user), sowie bestimmte Zugriffsrechte zugeordnet. Grundlegende Kenntnisse zu den verfügbaren Befehlen sind daher äußerst wichtig.<\/p>\n

Sie lernen in diesem Abschnitt die beiden Befehle chmod <\/strong>und chown <\/strong>kennen. Ein detaillierteres Bild zur Funktionsweise des Berechtigungssystems erhalten Sie in unserem Beitrag Das Linux-Berechtigungssystem<\/a>.<\/p>\n

chmod – Anpassen von Zugriffsrechten<\/h4>\n

Der Befehl chmod <\/strong>(ch<\/strong>ange mod<\/strong>e) wird verwendet, um die Zugriffsrechte von Dateien anzupassen. Allgemein lautet die Syntax des Befehls folgendermaßen:<\/p>\n

chmod [Optionen] [Berechtigungen \/ Modus] [Pfad]\n<\/p>

Grundsätzlich gibt es 2 Methoden der Rechtevergabe mit dem Befehl: Die Symbolische- und die Numerische Rechtevergabe, welche nun einmal vorgestellt werden.<\/p>\n

Symbolische Rechtevergabe<\/h5>\n

Bei der symbolischen Vorgehensweise<\/strong> werden die Zugriffsrechte auf Dateien oder Verzeichnisse mit den Zeichen ‘r’<\/strong>, ‘w’ <\/strong>und ‘x’<\/strong> zugeordnet. ‘r’<\/strong> steht dabei für lesenden Zugriff<\/strong> (r<\/strong>ead), ‘w’<\/strong> für die Schreibrechte <\/strong>(w<\/strong>rite) und ‘x’<\/strong> schließlich für das Ausführungsrecht <\/strong>(ex<\/strong>ecute). Die Syntax für die symbolische Rechtevergabe sieht folgendermaßen aus:<\/p>\n

\"Symbolische<\/span><\/p>\n

Zunächst wird die Benutzerkategorie ausgewählt, auf die die neuen Rechte angewendet werden sollen. Zugelassen sind die Kategorien ‘u’ für Benutzer<\/strong> (u<\/strong>ser), ‘g’ für Gruppe<\/strong> (g<\/strong>roup), ‘o’ für Andere<\/strong> (o<\/strong>ther) und zuletzt ‘a’ für alle<\/strong> (a<\/strong>ll). Anschließend folgt der Operator ‘-‘<\/strong> um Rechte zu entfernen, ‘+’<\/strong> um Rechte zu erteilen und ‘=’<\/strong> um Rechte explizit zu setzen. Rechts neben dem Operator stehen dann schließlich die zu erteilenden Rechte in der Form “rwx”.<\/p>\n

Wenn Sie mehrere Änderungen an einer Datei \/ einem Verzeichnis mit einem Befehl vornehmen wollen, dann können Sie diese auch durch Kommata getrennt hintereinander auflisten.<\/p>\n

Numerische Rechtevergabe<\/h5>\n

Bei der numerischen Vorgehensweise<\/strong> werden die Zugriffsrechte in Form einer dreistelligen Oktalzahl angegeben. Jede der drei Ziffern steht dabei für die Rechte einer bestimmten Benutzerkategorie: Die erste Ziffer stellt die Berechtigungen für den Besitzer dar, die zweite für die Gruppe und die dritte für Andere.<\/p>\n

\"Numerische<\/span><\/p>\n

Um die Berechtigungen abzulesen, die durch eine Ziffer dargestellt werden, muss diese in das Dualsystem konvertiert werden. Die resultierende dreistellige Dualzahl stellt die Berechtigungen dar.<\/p>\n

Die erste Ziffer der Dualzahl steht dabei für den lesenden Zugriff, die zweite für das Schreibrecht und die dritte zuletzt für das Ausführungsrecht. Die 1 bedeutet dabei, dass das jeweilige Recht erteilt wurde, während eine 0 bedeutet, dass das Recht nicht erteilt wurde.<\/p>\n

chown – Anpassen von Besitzer und Gruppe<\/h4>\n

Mit dem Befehl chown <\/strong>können Sie den Besitzer bzw. die Gruppe einer Datei oder eines Verzeichnisses festlegen. Die Syntax lautet allgemein:<\/p>\n

chown [Optionen] [Besitzer]:[Gruppe] [Pfad]\n<\/p>

Sie können den Besitzer bzw. die Gruppe auch einzeln zuweisen. Um nur den Benutzer zuzuweisen, lassen Sie den Teil “:[Gruppe]” einfach aus:<\/p>\n

chown [Optionen] [Besitzer] [Pfad]\n<\/p>

Wenn Sie nur eine Zuweisung der Gruppe benötigen, dann können Sie den Teil “[Besitzer]” auslassen. Wichtig dabei ist, dass der Doppelpunkt ‘:’<\/strong> stehen bleibt, da dieser signalisiert, dass es sich um den Gruppennamen, nicht jedoch um den Namen des Besitzers handelt.<\/p>\n

History<\/h3>\n

Die auf einem Linux- \/ UNIX-System mit einem Benutzer ausgeführten Befehle werden in der sogenannten History protokolliert. Mit dem Befehl history <\/strong>ist es möglich, diese Aufzeichnungen auszulesen und Befehle erneut auszuführen. So ist es etwa möglich, in Erfahrung zu bringen, welche Befehle ein Benutzer wann ausgeführt hat.<\/p>\n

Die History ausgeben<\/h4>\n

Die History eines Benutzers kann durch die einfache Eingabe des Befehls history <\/strong>mit diesem Benutzer – ohne Optionen oder Parameter – ausgegeben werden:<\/p>\n

history<\/p>\n

Sollen nur die letzten n Eintragungen der History ausgegeben werden, so kann dem Befehl optional eine entsprechende Ganzzahl n angefügt werden:<\/p>\n

history [Anzahl]\n<\/p>

Befehle ausführen<\/h4>\n

Links neben jeder Eintragung der History finden Sie ihre jeweilige Nummer. Möchten Sie einen Befehl der History erneut ausführen, geben Sie diese Nummer sowie ein vorangestelltes Ausrufungszeichen “!”<\/strong> im Terminal ein. Der Befehl mit der entsprechenden Nummer wird dann ausgeführt, ohne dass eine komplette Neueingabe nötig ist:<\/p>\n

![Nummer]\n<\/p>

Achten Sie bei der Wiederausführung von Befehlen darauf, dass bei relativen Pfadangaben Ihr aktuelles Arbeitsverzeichnis als Startpunkt verwendet wird – nicht das Verzeichnis, in welchem Sie sich bei der ersten Ausführung befanden.<\/p>\n

History löschen<\/h4>\n

Einzelne Befehle können mithilfe der Option -d<\/strong> und durch Angabe ihrer entsprechenden Nummer aus der History gelöscht werden:<\/p>\n

history -d [Nummer]\n<\/p>

Die komplette History ist dagegen mit der Option -c<\/strong> zu löschen:<\/p>\n

history -c<\/p>\n

Mehr Informationen zu diesem Befehl finden Sie in unserem Beitrag history<\/strong><\/a>.<\/p>\n

Befehlsausführung mit watch<\/h3>\n

Mit dem Befehl watch <\/strong>lassen sich unter UNIX- \/ Linux-Betriebssystemen Programme und Befehle in einem bestimmten Intervall ausführen – die Ausgabe wird jeweils an die Standardausgabe stdout <\/strong>weitergegeben und somit standardmäßig im Terminal ausgegeben. Das Programm erlaubt damit insbesondere die Beobachtung von Veränderungen und kann in Kombination mit anderen Werkzeugen beispielsweise zur Überwachung von Logdateien oder der Systemzeit verwendet werden.<\/p>\n

Die allgemeine Syntax von watch <\/strong>lautet:<\/p>\n

watch [Optionen] [Befehl \/ Programm]\n<\/p>

Standardmäßig wird der angegebene Befehl bzw. das Programm alle zwei Sekunden ausgeführt. Möchten Sie jedoch ein anderes Intervall verwenden, dann können Sie dieses mit der Option -n<\/strong> spezifizieren. Die Angabe des Intervalls erfolgt in Sekunden:<\/p>\n

watch -n [Intervall] [Befehl \/ Programm]\n<\/p>

Für weitere Optionen des Befehls sowie einige Beispiele seiner Anwendung lesen Sie auch in unserem Beitrag watch<\/strong><\/a>.<\/p>\n

Datei-\/Verzeichnisinhalte vergleichen<\/h3>\n

diff <\/strong>ermöglicht den Vergleich der Inhalte zweier Dateien oder Verzeichnisse miteinander. Von diff <\/strong>ausgegeben wird, worin sich der Inhalt der ersten angegebenen Datei bzw. des ersten Verzeichnisses mit dem der zweiten angegebenen Datei bzw. des zweiten Verzeichnisses unterscheidet. Die Unterschiede werden also so ausgegeben, wie Sie den Inhalt ersten Datei modifizieren müssten, damit dieser identisch mit dem Inhalt der zweiten Datei ist. Die allgemeine Syntax des Befehls lautet wie folgt:<\/p>\n

diff [Optionen] [Datei 1] [Datei 2]\n<\/p>

Die Ausgabe des Befehls diff <\/strong>lässt sich mithilfe verschiedener Optionen zusätzlich anpassen. Die Option -q<\/strong> sorgt so etwa dafür, dass nur ausgegeben wird, ob sich die Inhalte überhaupt unterscheiden. Sind keine inhaltlichen Unterschiede vorhanden, bleibt die Ausgabe leer:<\/p>\n

diff -q [Datei 1] [Datei 2]\n<\/p>

Wenn dagegen eine Ausgabe erfolgen soll, wenn beide Dateien identisch sind, verwenden Sie die Option -s<\/strong>. Die Option kann beispielsweise auch mit der Option -q<\/strong> kombiniert werden, wenn ausschließlich textuelle Ausgaben zur generellen Gleichheit oder Ungleichheit der Inhalte der Dateien gewünscht sind:<\/p>\n

diff -s [Datei 1] [Datei 2]\n<\/p>

Weitere Informationen zu diesem Befehl und verfügbare Optionen finden Sie in unserem Beitrag diff<\/strong><\/a>.<\/p>\n

Laufzeitmessung mit time<\/h3>\n

Die Laufzeit eines Programms bzw. Befehls lässt sich mithilfe des Befehls time <\/strong>messen. Der Befehl eignet sich so etwa zur Messung der Dauer einer Sicherung oder ähnlichem. Zwei Varianten des Befehls gilt es zu unterscheiden: Einerseits bringt die Bash einen time<\/strong>-Befehl mit, der Laufzeiten messen und diese in einem POSIX-konformen Format ausgeben kann. Andererseits existiert jedoch auch noch ein externes Programm mit diesem Namen, welches auch noch weitere Funktionalitäten anbietet. Hier wird jedoch nur der Bash-Befehl<\/strong>time <\/strong>behandelt. Die allgemeine Syntax lautet folgendermaßen:<\/p>\n

time [Optionen] [Befehl \/ Pipeline]\n<\/p>

Die einzige Option des Befehls ist -p<\/strong> zur Ausgabe der Messergebnisse in einem POSIX-konformen Format. Für die Ausführung kann ein einzelner Befehl, aber auch eine ganze Pipeline (mehrere durch Pipes hintereinander geschaltete Befehle), angegeben werden.<\/p>\n

Informationen zu dem hier nicht behandelten, externen Befehl finden Sie in unserem Beitrag time<\/strong><\/a>.<\/p>\n

Abzweigungen mit tee<\/h3>\n

Die Umleitung einer Ausgabe sowohl in den Standard-Output stdout<\/strong>, als auch in eine Datei, ist mit dem Befehl tee <\/strong>möglich. Konkret leitet der Befehl dazu den Standard-Input stdin <\/strong>an den Standard-Output stdout <\/strong>weiter und schreibt diesen außerdem in eine oder mehrere Dateien. Der Befehl bildet damit eine Art T-Stück, wovon sich auch sein Name ableitet. Die Syntax von tee <\/strong>lautet folgendermaßen:<\/p>\n

tee [Optionen] [Datei(en)]\n<\/p>

Die Angabe von mindestens einer Datei, in die geschrieben werden soll, ist notwendig. Der Inhalt wird standardmäßig überschrieben, jedoch kann die Option -a<\/strong> angehängt werden, um den Standard-Input stdin <\/strong>stets an den bestehenden Inhalt anzuhängen:<\/p>\n

tee -a [Datei(en)]\n<\/p>

Weitere Informationen zu diesem Befehl finden Sie in unserem Beitrag tee<\/strong><\/a>.<\/p>\n

Systemlaufzeit anzeigen<\/h3>\n

Die Laufzeit des Systems seit dem letzten Bootvorgang kann mithilfe des Befehls uptime <\/strong>ausgegeben werden. Neben der Laufzeit können der Ausgabe des Befehls unter anderem auch die Anzahl am System angemeldeter Benutzer sowie  die mittlere Systemlast für die letzte Minute, 5 und 15 Minuten entnommen werden. Der Befehl wird meist ohne Optionen ausgeführt:<\/p>\n

uptime<\/p>\n

Standardmäßig erfolgt die Ausgabe auf einer Zeile: Hintereinander werden dabei die aktuelle Uhrzeit, die Laufzeit, die Benutzeranzahl und schließlich die Systemlast für die genannten drei Zeiträume ausgegeben. Nähere Informationen zum Befehl und seinen Optionen, sowie verschiedene Anwendungsbeispiele, finden Sie in unserem Beitrag uptime<\/strong>.<\/p>\n

Systemadministration<\/h2>\n

Prozessmanagement<\/h3>\n

In diesem Abschnitt “Prozessmanagement” lernen Sie einige der wichtigsten Befehle zur Erkennung und Behebung von Fehlern und System-Instabilitäten. Ist Linux bzw. UNIX zwar ein äußerst stabiles System, so kann es dennoch immer auch zu Fehlern kommen – die hier gezeigten Befehle helfen Systemadministratoren bei der Bewältigung von alltäglichen Problemen.<\/p>\n

Weitere Informationen finden Sie auch in unserem Beitrag Befehle für das Prozessmanagement<\/a>.<\/p>\n

top – Prozessübersicht<\/h4>\n

Mit dem Befehl top<\/strong> können Sie sich eine dynamische Übersicht aller laufenden Prozesse, sowie die Auslastung diverser Systemressourcen anzeigen lassen. Durch Eingabe des folgenden Befehls gelangen Sie zur Übersicht:<\/p>\n

top<\/p>\n

Die erscheinende Übersicht sieht etwa folgendermaßen aus:<\/p>\n

\"befehl-top-ausgabe\"<\/span><\/p>\n

Genauere Informationen zu diesem Befehl finden Sie auch in unserem Beitrag top<\/strong><\/a>.<\/p>\n

ps – Weitere Prozessübersicht<\/h4>\n

Eine Alternative für die Anzeige von Prozessen ist der Befehl ps<\/strong> (processes). Bei Eingabe des Befehls ohne Angabe zusätzlicher Parameter werden dabei die momentan im Terminal geöffneten Prozesse aufgelistet.<\/p>\n

ps<\/p>\n

Eine Übersicht zu allen auf dem System laufenden Prozessen lässt sich durch den zusätzlichen Parameter aux<\/strong> erreichen:<\/p>\n

ps aux<\/p>\n

pstree – Prozesse in einer Baumstruktur anzeigen<\/h4>\n

Mithilfe des Befehls pstree <\/strong>ist es möglich, die auf einem System laufenden Prozesse in einer Baumstruktur darzustellen. Im Vergleich zum Befehl ps <\/strong>wird mithilfe der Baumstruktur eine bessere Übersicht, insbesondere auch über die (Eltern-Kind-)Beziehungen zwischen mehreren Prozessen, erzielt. Die allgemeine Syntax von pstree <\/strong>lautet folgendermaßen:<\/p>\n

pstree [Optionen] [PID|Benutzer]\n<\/p>

Wird pstree <\/strong>ohne Optionen und ohne Angabe einer PID bzw. eines Benutzers ausgeführt, dann gibt der Befehl alle Prozesse mit ihren Namen in einer Baumstruktur aus. Optional kann eine PID angegeben werden, um nur den Prozess mit dieser PID sowie seine Kindprozesse darzustellen. Schließlich kann anstelle einer PID auch ein Benutzer angegeben werden – dann werden alle Prozesse ausgegeben, die von dem entsprechenden Benutzer gestartet wurden.<\/p>\n

Eine nützliche Option von pstree ist -p. Die Option aktiviert die Ausgabe der PIDs als Dezimalzahl (in Klammern) neben dem Namen jedes Prozesses:<\/p>\n

pstree -p [PID|Benutzer]\n<\/p>

Nähere Informationen zu diesem Befehl und seinen Optionen sowie auch Anwendungsbeispiele finden Sie in unserem Beitrag pstree<\/strong><\/a>.<\/p>\n

pgrep – Prozesse suchen<\/h4>\n

Der Befehl pgrep <\/strong>ermöglicht anhand verschiedener Attribute, wie etwa dem Namen – die Suche nach laufenden Prozessen. pgrep <\/strong>eignet sich insbesondere zur Ermittlung von PIDs, da diese in seiner standardmäßigen Ausgabe zu finden sind. Der Befehl benötigt mindestens ein Suchkriterium. Am einfachsten ist die Übergabe eines Suchmusters für den Prozessnamen. Das Suchmuster kann auch ein regulärer Ausdruck sein. Optionen werden nicht zwingend benötigt:<\/p>\n

pgrep [Optionen] [Suchmuster]\n<\/p>

Alternativ oder ergänzend zum Suchmuster ist auch die Filterung von Prozessen nach ihrer realen UID<\/strong> möglich. Hierzu werden die realen UIDs in Form einer Liste an die Option -U<\/strong> übergeben, wobei die UIDs durch Kommata voneinander getrennt werden:<\/p>\n

pgrep -U [UID-Liste] [Suchmuster]\n<\/p>

Die Ausgabe von pgrep <\/strong>umfasst standardmäßig lediglich die PIDs der gefundenen Prozesse. Soll jeweils zusätzlich der Name des Prozesses ausgegeben werden, so verwenden Sie dazu die Option -l<\/strong>:<\/p>\n

pgrep -l [Suchmuster]\n<\/p>

Nähere Informationen zu pgrep <\/strong>und seinen Optionen sowie einige Anwendungsbeispiele, finden Sie in unserem Beitrag pgrep<\/strong><\/a>.<\/p>\n

kill – Prozesse beenden<\/h4>\n

Prozesse, die unerwartet stehen geblieben sind, oder solche, die unerwünscht ausgeführt werden, lassen sich mit dem Befehl kill<\/strong> beenden. Bei der Verwendung des Befehls ist es nötig, neben optionalen Parametern die PID<\/strong> (P<\/strong>rocess I<\/strong>d) des jeweiligen Prozesses anzugeben.<\/p>\n

kill [Optionen] [PID]\n<\/p>

Standardmäßig sendet der Befehl das Signal SIGTERM<\/strong> (15) an den Kernel, um die Ausführung des jeweiligen Prozesses abzuschließen und ihn anschließend zu beenden. Mithilfe der Option -s<\/strong> lässt sich auch explizit festlegen, welches Signal an den Kernel gesendet werden soll:<\/p>\n

kill -s [Signal] [PID]\n<\/p>

Dies ist besonders dann hilfreich, wenn sich ein besonders hartnäckiger Prozess nicht durch das Standardsignal beenden lässt. In solchen Fällen kann der Kernel beispielweise mit einem SIGKILL <\/strong>(9) beauftragt werden, den Prozess hart abzubrechen:<\/p>\n

kill -s SIGKILL [PID]\n<\/p>

Beachten Sie jedoch, dass letztere Option immer nur dann eingesetzt werden sollte, wenn das Standardsignal nicht zum Ziel führt, da der Prozess auf diesem Weg nicht sauber beendet wird.<\/p>\n

jobs – Status von Shell-Prozessen anzeigen<\/h4>\n

Mit dem Befehl jobs<\/strong> können Sie den Status aller in der Shell gestarteten Prozesse einsehen:<\/p>\n

jobs<\/p>\n

Der Befehl wird vor allem dann benötigt, wenn Sie lang laufende Prozesse im Hintergrund ausführen möchten. Ähnlich wie bei den beiden Befehlen top <\/strong>und ps<\/strong> wird neben der Jobnummer <\/strong>der aktuelle Prozessstatus <\/strong>sowie auch der komplette Aufrufbefehl <\/strong>angezeigt. Die Ausgabe sieht dann etwa folgendermaßen aus:<\/p>\n

\"ausgabe-jobs\"<\/span><\/p>\n

& – Prozesse im Hintergrund starten<\/h4>\n

Wenn Sie einen Prozess im Hintergrund starten<\/strong> möchten, dann können Sie dem jeweiligen Befehl ganz einfach ein Kaufmanns-Und &<\/strong> anhängen:<\/p>\n[Befehl] [Optionen] &\n

Nach Eingabe wird im Terminal die zugewiesene Jobnummer <\/strong>und die PID <\/strong>ausgegeben.<\/p>\n

bg – Vordergrundprozess in den Hintergrund verlagern<\/h4>\n

Auch bereits im Vordergrund gestartete Prozesse lassen sich nachträglich in den Hintergrund verlagern. Mit der Tastenkombination [Ctrl+z]<\/strong> muss der laufende Prozess dazu zunächst angehalten werden. Anschließend kann er mit dem folgenden Befehl im Hintergund fortgeführt werden:<\/p>\n

bg %[Jobnummer]\n<\/p>

fg – Hintergrundprozess in den Vordergrund verlagern<\/h4>\n

Hintergrundprozesse können umgekehrt auch in den Vordergrund verlagert werden. Verwenden Sie dazu den Befehl fg<\/strong>:<\/p>\n

fg %[Jobnummer]\n<\/p>

nice – Prozesse mit angepasster Priorität starten<\/h4>\n

Mit nice <\/strong>ist es möglich, Prozesse bzw. Befehle mit einer angepassten Priorität (nice-Wert) zu starten. Der Wertebereich für nice <\/strong>reicht ganzzahlig von -20<\/strong> (niedrigste Priorität) bis 19<\/strong> (höchste Priorität). Standardmäßiger nice-Wert für einen Prozess ist 0. Wird nice <\/strong>ohne jegliche Argumente ausgeführt, so gibt der Befehl den aktuellen nice-Wert aus:<\/p>\n

nice<\/p>\n

Erst durch Übergabe eines Befehls mitsamt seiner Argumente ist es möglich, einen entsprechenden Prozess mit angepasster Priorität zu starten. Die Option -n<\/strong> ermöglicht dabei die Angabe der vorzunehmenden Anpassung des nice-Wertes, wobei der angegebene Wert auf den standardmäßigen nice-Wert aufaddiert wird.<\/p>\n

nice -n [Anpassung] [Befehl [Argument(e)]]\n<\/p>

Die Option -n<\/strong> kann auch weggelassen werden – in diesem Fall addiert nice <\/strong>standardmäßig den ganzzahligen Wert 10<\/strong>:<\/p>\n

nice [Befehl [Argument(e)]]\n<\/p>

Weitere Informationen finden Sie in unserem Beitrag nice<\/strong><\/a>.<\/p>\n

cpulimit – CPU-Zeit eines Prozesses begrenzen<\/h4>\n

Die prozentuale Begrenzung der von einem Prozess inklusive seiner Kindprozesse beanspruchten CPU-Zeit ist mit dem Befehl cpulimit <\/strong>möglich. Die maximal prozentual verfügbare CPU-Zeit beträgt dabei in einem System mit N Prozessoren oder Prozessorkernen N*100 Prozent. Es ist schließlich noch zu beachten, dass zur Begrenzung nicht-eigener Prozesse Root-Berechtigungen erforderlich sind. Da cpulimit<\/strong> nicht standardmäßig auf allen Systemen installiert ist, kann er bei Bedarf mit dem folgenden Befehl mit apt <\/strong>nachinstalliert werden:<\/p>\n

apt-get install cpulimit<\/p>\n

Die allgemeine Syntax von cpulimit <\/strong>lautet nun folgendermaßen:<\/p>\n

cpulimit [Ziel] -l [Max Prozent] [Optionen]\n<\/p>

Der Wertebereich für den maximal zugelassenen Anteil der CPU-Zeit ist 1 und aufsteigend. Das Ziel kann mithilfe verschiedener Optionen angegeben werden, wobei -p<\/strong> zur Angabe einer Prozess-ID die wohl wichtigste Option ist. Soll also ein Prozess mit der Prozess-ID [PID]<\/strong> begrenzt werden, dann kommt folgende Syntax zum Einsatz:<\/p>\n

cpulimit -p [PID] -l [Max Prozent] [Optionen]\n<\/p>

Offensichtlich muss der Prozess mit der angegebenen PID bereits existieren, wenn cpulimit <\/strong>mit der obigen Syntax verwendet wird. Alternativ ist es daher möglich, einen neuen Prozess zu starten und die Begrenzung der CPU-Zeit direkt auf diesem vorzunehmen. Hierzu wird ein auszuführender Befehl mitsamt seinem Argument hinter zwei Anführungszeichen angehängt:<\/p>\n

cpulimit -l [Max Prozent] [Optionen] — [Befehl]\n<\/p>

Nähere Informationen zu Befehl, <\/strong>die weiteren Optionen sowie auch einige Beispiele finden Sie in unserem Beitrag cpulimit<\/strong><\/a>.<\/p>\n

ionice – Prozesse mit angepasster I\/O-Priorität starten<\/h4>\n

ionice <\/strong>ermöglicht Ihnen die Festlegung der Priorität für Prozesse, die das I\/O-Interface des Kernels nutzen. So kann etwa ein Kopierprozess mit geeignet angepasster I\/O-Scheduling-Klasse und -Priorität gestartet werden, damit die Auslastung des Systems durch diesen Prozess möglichst gering bleibt. Wird ionice <\/strong>ohne Argumente ausgeführt, so gibt der Befehl die I\/O-Scheduling-Klasse und -Priorität des aktuellen Prozesses aus:<\/p>\n

ionice<\/p>\n

Durch Übergabe eines Befehls sowie der Optionen -c<\/strong> und -n<\/strong> ist es möglich, diesen Befehl mit angepassten Werten zu starten. Der Option -c<\/strong> kann dabei eine der verfügbaren I\/O-Scheduling-Klassen in ihrer numerischen Form übergeben werden. Die Klassen mit ihren numerischen Werten sind die folgenden: “None” (0)<\/strong>, “Realtime” (1)<\/strong>, “Best-Effort” (2)<\/strong>, “Idle” (3)<\/strong>. Die Priorität (Option -n<\/strong>) kann nur zusammen mit den Klassen “Realtime” und “Best-Effort” verwendet werden – andernfalls wird sie ignoriert. Der Wertebereich der Priorität ist 0-7<\/strong>, wobei 0<\/strong> die höchste Prioritätsstufe darstellt.<\/p>\n

ionice -c [Klasse] -n [Priorität] [Befehl [Argument(e)]]\n<\/p>

Wenn Sie näheres zum diesem Befehl und den I\/O-Scheduling-Klassen erfahren möchten, dann lesen Sie auch unseren Beitrag ionice<\/strong><\/a>.<\/p>\n

chrt – Echtzeit-Scheduling-Attribute auslesen und setzen<\/h4>\n

Der Befehl chrt <\/strong>ermöglicht es Ihnen, die Echtzeit-Scheduling-Attribute<\/strong> von Prozessen auszulesen und zu setzen. Neben der Scheduling-Priorität<\/strong> kann so etwa auch der verwendete Scheduler <\/strong>beeinflusst werden. Bei der Verwendung von chrt <\/strong>werden in der Regel Root-Rechte benötigt. Die allgemeine Syntax, um einen Befehl mit gegebenen Attributen zu starten:<\/p>\n

chrt [Optionen] [Priorität] [Befehl [Argumente]]\n<\/p>

Alternativ können auch die Attribute eines bereits laufenden Prozesses geändert werden. Hierzu wird die PID <\/strong>des Prozesses mithilfe der Option -p<\/strong> spezifiziert. Werden bei dieser Syntax weder Priorität noch sonstige Optionen angegeben, so gibt chrt <\/strong>die aktuell für den Prozess gesetzten Attribute aus:<\/p>\n

chrt [Optionen] -p [Priorität] [PID]\n<\/p>

Die Priorität wird im Wertebereich 0 (niedrig) bis 99 (hoch)<\/strong> angegeben. Die Optionen des Befehls können zur Auswahl eines Schedulers verwendet werden: Verfügbar sind -o<\/strong> (Standardscheduler), -i<\/strong> (Idle-Scheduler), -b<\/strong> (Batch-Scheduler), -f<\/strong> (FIFO-Scheduler) und -r<\/strong> (Round Robin-Scheduler). In unserem Beitrag chrt <\/strong>können Sie weitere Informationen zum Befehl selbst und den verfügbaren Schedulern nachlesen.<\/p>\n

Runlevel<\/h3>\n

Diverse sogenannte Runlevel <\/strong>kontrollieren unter Linux-\/UNIX-Betriebssystemen, welche Prozesse und Services automatisch – beispielsweise beim Systemstart – mitgestartet werden sollen. In diesem Abschnitt lernen Sie den Befehl init<\/strong>, die 7 verfügbaren Runevel, sowie den Standard-Runlevel kennen.<\/p>\n

Beachten Sie, dass die Runlevel in der hier beschriebenen Form nur bei dem init-System<\/strong> bzw. Paket sysvinit <\/strong>zum Einsatz kommen. Das init-System<\/strong> wurde unter Debian seit der Version 8 durch systemd <\/strong>ersetzt.<\/p>\n

init – Runlevel wechseln<\/h4>\n

Der Befehl init<\/strong> wird eingesetzt, um den Runlevel des Systems zur Laufzeit zu wechseln. Die Syntax des Befehls lautet:<\/p>\n

init [Runlevel]\n<\/p>

Die verfügbaren Runlevel, welche sich mit dem init-Befehl einstellen lassen, werden nun einmal kurz beschrieben:<\/p>\n

Die Runlevel sind von 0 bis 6 durchnummeriert und führen jeweils zu unterschiedlichen Betriebsarten des Systems: Der Runlevel 0<\/strong> führt zu einem Systemhalt<\/strong>, kann also eingesetzt werden, um das System zu stoppen. Der Runlevel 1<\/strong> startet den Einzel-Nutzerbetrieb<\/strong> des Systems. Es gibt dabei keine Netzwerkverbindung. Runlevel 2<\/strong> startet den lokalen Multi-Nutzerbetrieb<\/strong>, wobei auch hier wieder die Netzwerkverbindung deaktiviert bleibt. Der dritte Runlevel (3)<\/strong> führt zum Start des vollen Multi-Nutzerbetriebs<\/strong> – hierbei werden sämtliche Services, wie beispielsweise ein Apache Webserver oder Mailserver, ebenfalls gestartet und es besteht eine Netzwerkverbindung. Ähnlich funktioniert auch Runlevel 5<\/strong>, jedoch wird bei diesem auch die grafische Benutzungsoberfläche<\/strong> (KDM \/ XDM \/ GDM) gestartet. Schließlich kann das System mithilfe des letzten Runlevel (6) neugestartet<\/strong> werden.<\/p>\n

Der vierte Runlevel<\/strong> wurde absichtlich übersprungen, da dieser noch nicht belegt<\/strong> ist.<\/p>\n

Standard-Runlevel<\/h4>\n

Der Standard-Runlevel<\/strong>, welcher bei jedem Systemstart eingesetzt wird, wird in der Datei \/etc\/inittab<\/strong> durch den Eintrag initdefault <\/strong>festgelegt. In den meisten Fällen wird hier der volle Multi-Nutzerbetrieb ohne grafische Benutzungsoberfläche (3)<\/strong>, oder der entsprechende Multi-Nutzerbetrieb mit aktivierter grafischer Benutzungsoberfläche (5)<\/strong> verwendet.<\/p>\n

Ein-\/Aushängen mit mount<\/h3>\n

In diesem kurzen Abschnitt soll der Befehl mount<\/strong>, welcher unter UNIX-\/Linux-Betriebssystemen zum Einbinden und Aushängen<\/strong> von Dateisystemen verwendet wird, vorgestellt.<\/p>\n

Dateisysteme anzeigen<\/h4>\n

Zunächst können Sie durch Eingabe des Befehls mount <\/strong>ohne jegliche Optionen alle momentan in das System eingebundenen Dateisysteme ausgeben:<\/p>\n

mount<\/p>\n

Die Ausgabe erfolgt zeilenweise – Am Anfang jeder Zeile steht dabei die Bezeichnung <\/strong>des Dateisystems oder Geräts. Darauf folgt der Pfad, auf welchem<\/span><\/b> das Dateisystem eingehängt wurde. Zum Schluss folgen Informationen zum Typ <\/strong>(t<\/strong>ype) des Dateisystems, beispielsweise ext4<\/strong>, sowie zu verschiedenen festgelegten Einhängeoptionen<\/strong>, wie beispielsweise der GID<\/strong>, UID <\/strong>oder der Dateinamen Enkodierung<\/strong>.<\/p>\n

Mit der Option -l<\/strong> lässt sich am Ende jeder Zeile zusätzlich auch noch ein Label <\/strong>in eckigen Klammern darstellen:<\/p>\n

mount -l<\/p>\n

Dateisystem einhängen<\/h4>\n

Je nachdem, ob es in der sogenannten \/etc\/fstab<\/strong> bereits einen Eintrag gibt, werden unterschiedliche Syntaxen für den mount<\/strong> Befehl benötigt. Die genaue Funktionsweise der \/etc\/fstab finden Sie in unserem Beitrag Die Konfigurationsdatei fstab<\/a>.<\/p>\n

Dem Befehl müssen neben Optionen<\/strong>, das Gerät bzw. Dateisystem<\/strong> sowie der Einhängepunkt (Mountpoint)<\/strong> übergeben werden. Außerdem werden root-Rechte<\/strong> benötigt. Die Syntax lautet damit:<\/p>\n

mount [Optionen] [Gerät \/ Dateisystem] [Mountpoint]\n<\/p>

Für das temporäre <\/strong>Einhängen ohne Eintragung in der \/etc\/fstab<\/strong> können Sie unter [Gerät \/ Dateisystem]<\/strong> eine sogenannte Gerätedatei (device)<\/strong> angeben, welche Sie unter UNIX-\/Linux-Betriebssystemen im Verzeichnis \/dev\/<\/strong> finden. Beispielsweise sind \/dev\/sda1 und \/dev\/sda2 die jeweils erste Partition und zweite Partition eines SCSI Device.<\/p>\n

Als Mountpoint <\/strong>dient ein beliebiger Pfad eines Verzeichnisses<\/strong>, auf dem Sie das neue Gerät einhängen möchten. Das spezifizierte Verzeichnis sollte vorzugsweise leer sein, da jegliche Inhalte nach der Einhängung nicht mehr sichtbar sind – sie werden von dem zweiten Dateisystem überlagert<\/strong>, sind jedoch nach dem Aushängen des zweiten Dateisystems wieder verfügbar.<\/p>\n

Optionen<\/h4>\n

Der mount <\/strong>Befehl besitzt eine Vielzahl Optionen<\/strong>, von denen die wichtigsten einmal kurz in der folgenden Tabelle aufgelistet werden.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
\n

Option<\/strong><\/p>\n<\/th>\n

\n

Funktion<\/p>\n<\/th>\n<\/tr>\n<\/thead>\n

\n

<\/span><\/span><\/span><\/span>-a<\/span><\/span><\/span><\/span><\/p>\n<\/td>\n

\n

Es werden alle Dateisysteme der \/etc\/fstab<\/strong> (der angegebenen Typen<\/strong>) eingebunden, solange diese nicht mit der Einhängeoption <\/strong>noauto <\/strong>versehen wurden. (a<\/strong>ll)<\/p>\n<\/td>\n<\/tr>\n

\n

-U [UUID]\n<\/p><\/td>\n

\n

Es wird das Dateisystem mit der angegebenen UUID <\/strong>eingehängt.<\/p>\n<\/td>\n<\/tr>\n

\n

-L [Label]\n<\/p><\/td>\n

\n

Es wird das Dateisystem mit dem angegebenen Label <\/strong>eingehängt.<\/p>\n<\/td>\n<\/tr>\n

\n

-B<\/p>\n<\/td>\n

\n

Ein bereits gemounteter Teilbaum <\/strong>kann mit dieser Option an einer anderen Position erneut <\/strong>eingehängt <\/strong>werden. Der alte Mountpoint<\/strong> bleibt dabei erhalten, sodass die Inhalte an zwei Orten erscheinen. (B<\/strong>ind)<\/p>\n<\/td>\n<\/tr>\n

\n

-M<\/p>\n<\/td>\n

\n

Ein bereits gemounteter Teilbaum <\/strong>wird an eine andere Position verschoben<\/strong>. (M<\/strong>ove)<\/p>\n<\/td>\n<\/tr>\n

\n

-f<\/p>\n<\/td>\n

\n

Das Einhängen des angegebenen Dateisystems wird lediglich simuliert<\/strong>, also nicht tatsächlich durchgeführt. Durch Zusatz der Option -v<\/strong> können die Aktionen des mount <\/strong>Befehls nachvollzogen werden. (f<\/strong>ake)<\/p>\n<\/td>\n<\/tr>\n

\n

-o [Parameter]\n<\/p><\/td>\n

\n

Wird verwendet, um die Einhängeoptionen <\/strong>festzulegen. Als Parameter übergeben Sie hierbei eine durch Kommata getrennte Liste von Einhängeoptionen<\/strong>. Verfügbare Einhängeoptionen <\/strong>finden Sie im Abschnitt “Einhängeoptionen”<\/strong><\/a>. (o<\/strong>ptions)<\/p>\n<\/td>\n<\/tr>\n

\n

-r<\/p>\n<\/td>\n

\n

Das Dateisystem wird schreibgeschützt <\/strong>eingehängt. Synonym <\/strong>dieser Befehlszeilenoption <\/strong>ist das Hinzufügen der Einhängeoption ro<\/strong> durch -o ro<\/strong>  (r<\/strong>ead o<\/strong>nly)<\/p>\n<\/td>\n<\/tr>\n

\n

-w<\/p>\n<\/td>\n

\n

Das Dateisystem wird les- und schreibbar<\/strong> eingehängt. Es handelt sich hierbei um die Voreinstellung bzw. den Standardwert <\/strong>des Kernels<\/strong>. Auch hier ist -o rw<\/strong> ein Synonym <\/strong>(r<\/strong>ead w<\/strong>rite)<\/p>\n<\/td>\n<\/tr>\n

\n

-t<\/p>\n<\/td>\n

\n

Definiert den Typen <\/strong>des einzuhängenden Dateisystems. Beispielsweise: ext, ext2, ext3, ext4, nfs, iso9660, vfat (=FAT32), ntfs etc. (t<\/strong>ype)<\/p>\n<\/td>\n<\/tr>\n

\n

-v<\/p>\n<\/td>\n

\n

Aktiviert den ausführlichen Modus. (v<\/strong>erbose)<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Mehr Informationen zu diesem Befehl finden Sie in unserem Beitrag mount<\/strong><\/a>.<\/p>\n

Archivierung<\/h3>\n

Hier sollen Ihnen kurz die Grundfunktionen des Befehls tar<\/strong> (t<\/strong>ape a<\/strong>rchiver), welcher unter Linux-\/UNIX-Betriebssystemen für die Erstellung von .tar Archiven<\/strong> sowie die Extraktion <\/strong>diverser archivierter Dateien verwendet wird,vorgestellt werden. Bei der Systemadministration spielt der Befehl oft eine zentrale Rolle, da er beispielsweise auch bei der Durchführung von Backups eingesetzt werden kann.<\/p>\n

Die allgemeine Syntax lautet:<\/p>\n

tar [Optionen] [Datei(en) \/ Verzeichnis(se)]\n<\/p>

Im Folgenden sollen die wichtigsten Optionen zur Erstellung, Auflistung und Extraktion von Archiven kurz genannt werden.<\/p>\n

-c – Archive erstellen<\/h4>\n

Zur Erstellung <\/strong>neuer Archive wird die Option -c<\/strong> des tar <\/strong>Befehls verwendet. Die Syntax lautet:<\/p>\n

tar -c -f [Archivname] [Datei(en) \/ Verzeichnis(se)]\n<\/p>

Benötigt wird hier zusätzlich die vielfach verwendete Option -f <\/strong>(f<\/strong>ile), welche den Namen des zu Erstellenden Archivs festlegt – bestenfalls endet dieser mit der Dateiendung .tar<\/strong>.<\/p>\n

-t – Archivinhalt ausgeben<\/h4>\n

Die Option -t<\/strong> wird verwendet, um Inhalt <\/strong>eines Archivs auszugeben<\/strong>. Grundsätzlich kann auf die Angabe [Datei(en) \/ Verzeichnis(se)]<\/strong> verzichtet werden, wenn ausnahmslos alle Inhalte ausgegeben werden sollen:<\/p>\n

tar -t -f [Archivname]\n<\/p>

Wenn Sie jedoch den Inhalt bestimmter Verzeichnisses des Archivs ausgeben möchten, dann fügen Sie die jeweiligen relativen Pfade<\/strong> einfach zusätzlich an:<\/p>\n

tar -t -f [Archivname] [Datei(en) \/ Verzeichnis(se)]\n<\/p>

-x – Archive extrahieren<\/h4>\n

Mit der Option -x<\/strong> ist es schließlich möglich, Archive auch wieder zu extrahieren <\/strong>– erst dann ist der Zugriff auf die enthaltenen Dateien wieder möglich. Wird bei der Extraktion keine Angabe neben dem Archivnamen gemacht, so wird stets der gesamte <\/strong>Inhalt <\/strong>des jeweiligen Archivs in das aktuelle <\/strong>Arbeitsverzeichnis <\/strong>extrahiert:<\/p>\n

tar -x -f [Archivname]\n<\/p>

Durch Angabe von Dateien und \/ oder Verzeichnissen des Archivs<\/strong> können Sie jedoch auch genau spezifizieren, was extrahiert werden soll:<\/p>\n

tar -x -f [Archivname] [Datei(en) \/ Verzeichnis(se)]\n<\/p>

Schließlich können Sie durch Zusatz der Option -C<\/strong> auch ein Zielverzeichnis <\/strong>für die Extraktion bestimmen:<\/p>\n

tar -x -f [Archivname] -C [Zielverzeichnis] [Datei(en) \/ Verzeichnis(se)]\n<\/p>

Weitere Informationen finden Sie in unserem Beitrag Archivierung mit tar<\/strong><\/a>.<\/p>\n

Systemzeit und Hardware-Uhr<\/h3>\n

Unter Linux\/UNIX gibt es prinzipiell zwei unterschiedliche Uhren: Die Systemzeit und die Hardware-Uhr. Während die Systemzeit von Programmen und Anwendungen zur Laufzeit verwendet wird, läuft die Hardware-Uhr zu jeder Zeit – auch wenn das System herunterfahren ist weiter, um nach dem Systemstart wieder die Systemzeit zu synchronisieren.<\/p>\n

In diesem Beitrag lernen Sie zunächst die wichtigsten Funktionen des Befehls date <\/strong>kennen, welcher zur Ausgabe und Einstellung der Systemzeit verwendet wird. Anschließend wird auch noch auf den Befehl hwclock <\/strong>eingegangen – dieser gibt Ihnen die Möglichkeit, den Wert der Hardware-Uhr auszugeben, sowie diverse Einstellungen vorzunehmen.<\/p>\n

date – Systemzeit<\/h4>\n
Ausgabe der Systemzeit<\/h5>\n

Im Folgenden wird der Befehl date <\/strong>mit seinen wichtigsten Optionen vorgestellt. date <\/strong>lässt sich ohne Angabe jeglicher Optionen einsetzen und gibt dann die Systemzeit (Datum und Uhrzeit) in einem festen Format aus:<\/p>\n

date<\/p>\n

Die Ausgabe der aktuellen Zeit ist durch Anfügen diverser Optionen auch in verschiedenen Formaten möglich. So wird mithilfe der Option -I<\/strong> eine Ausgabe nach ISO<\/a> 8601<\/strong> erreicht. Über das Feld [FMT]<\/strong> können Sie die Genauigkeit der Ausgabe bestimmen: Erkannt werden ‘hours’<\/strong> für Stunden, ‘minutes’<\/strong> für Minuten, ‘seconds’<\/strong> für Sekunden und ‘ns’<\/strong> für Nanosekunden.<\/p>\n

date -I[FMT]\n<\/p>

Weiterhin ist auch die Ausgabe im Format nach RFC<\/a> 2822<\/strong> möglich:<\/p>\n

date -R<\/p>\n

Wenn Sie das Format der Ausgabe selbst bestimmen möchten, dann verwenden Sie den date<\/strong>-Befehl einfach in Kombination mit verschiedenen Formatangaben<\/strong>. Das Format wird in Anführungszeichen <\/strong>und mit einem vorangestellten Plus ‘+’<\/strong> angegeben:<\/p>\n

date “+[Format]”<\/p>\n

Setzen der Systemzeit<\/h5>\n

Mit der Option -s<\/strong> kann die Systemzeit auf einen von Ihnen bestimmten Wert gesetzt werden. Spezifiziert wird die Zeit mithilfe eines sogenannten date-String:<\/p>\n

date -s [String]\n<\/p>

Das Format des date<\/strong>-String kann sehr unterschiedlich aussehen. Hierbei soll nun lediglich ein Format vorgestellt werden, welches für die meisten Anwendungsfälle bestens geeignet ist. Die Syntax des gesamten Befehls lautet dann:<\/p>\n

date -s “YYYY-MM-DD hh:mm:ss [Zeitzone]”<\/p>\n

Welche gültigen Formatangaben es noch gibt, finden Sie in unserem Beitrag date<\/strong><\/a>.<\/p>\n

hwclock – Hardware-Uhr<\/h4>\n
Ausgabe der aktuellen Zeit<\/h5>\n

Die Ausgabe der aktuellen Zeit ist auch bei der Hardware-Uhr leicht durchzuführen: Der Befehl hwclock <\/strong>wird dazu ohne Angabe von Optionen ausgeführt:<\/p>\n

hwclock<\/p>\n

Alternativ kann jedoch auch die Option -r<\/strong> verwendet werden, welche dieselbe Ausgabe liefert:<\/p>\n

hwclock -r<\/p>\n

Die Ausgabe erfolgt immer nach dem Systemgebietsschema<\/strong>, also der lokalen Zeit<\/strong>.<\/p>\n

Hardware-Uhr einstellen<\/h5>\n

Zur Einstellung der Hardware-Uhr stehen Ihnen zwei verschiedene Möglichkeiten zur Verfügung. So können Sie die Systemzeit einerseits mithilfe der Option -w<\/strong> nach der aktuellen Systemzeit stellen:<\/p>\n

hwclock -w<\/p>\n

Andererseits ist es auch möglich, ähnlich wie bei dem date<\/strong>-Befehl, die Uhr auf Grundlage einer Datumszeichenkette <\/strong>(date<\/strong>-String) zu stellen. Verwenden Sie dazu die beiden Optionen –set<\/strong> und –date<\/strong>:<\/p>\n

hwclock –set –date='[String]’<\/p>\n

Das Format <\/strong>der Datumszeichenkette <\/strong>kann beispielsweise die folgende Form annehmen:<\/p>\n

hwclock –set –date=’YYYY-MM-DD hh:mm:ss’<\/p>\n

Weiterführende Optionen <\/strong>und Funktionen <\/strong>zu diesem Befehl finden Sie in unserem Beitrag hwclock<\/strong><\/a>.<\/p>\n

Sicheres Löschen von Daten<\/h3>\n

In dem folgenden Abschnitt wird Ihnen der Befehl shred <\/strong>vorgestellt, mit welchem Sie sicher Daten überschreiben<\/strong> und anschließend löschen können. Einige der wichtigsten Optionen werden zusätzlich aufgelistet.<\/p>\n

Dateien überschreiben<\/h4>\n

Wenn Sie einzelne Dateien mit Zufallsdaten überschreiben möchten, dann übergeben Sie dem Befehl shred <\/strong>einfach die Pfade <\/strong>der jeweiligen Dateien. Mehrere Dateien können durch Leerzeichen getrennt hintereinander angegeben werden. Optionen werden nicht zwingend benötigt.<\/p>\n

shred [Datei(en)]\n<\/p>

Wenn Sie Dateien nach dem Überschreiben auch noch Löschen möchten, dann verwenden Sie zusätzlich die Option -u<\/strong>:<\/p>\n

shred -u [Datei(en)]\n<\/p>

Geräte überschreiben<\/h4>\n

Durch Angabe eines Gerätenamen <\/strong>können Sie auch ganze Blockdevices<\/strong>, wie beispielsweise Partitionen oder Festplatten überschreiben. Auch hier werden wieder keine Optionen benötigt.<\/p>\n

shred [Gerät]\n<\/p>

Durch Hinzufügen der Option -f<\/strong> ist es möglich, den Vorgang des Überschreibens zu erzwingen<\/strong> – die Option ändert Zugriffsberechtigungen automatisch, wenn dies für die Ausführung des Befehls nötig ist. Eingesetzt werden kann die Option bei Verwendung von shred <\/strong>zum Überschreiben von Dateien sowie Geräten.<\/p>\n

shred -f [Gerät \/ Datei(en)]\n<\/p>

Wenn Sie zusätzlich festlegen möchten, wie oft die angegebenen Daten überschrieben werden, dann können Sie mit der Option -n<\/strong> einfach einen entsprechenden numerischen Wert an den Befehl übergeben:<\/p>\n

shred -n [N] [Gerät \/ Datei(en)]\n<\/p>

Standardmäßig werden Dateigrößen von shred <\/strong>auf die nächste volle Blockgröße aufgerundet – dieses Verhalten lässt sich mithilfe der Option -x<\/strong> jedoch auch ausschalten:<\/p>\n

shred -x [Gerät \/ Datei(en)]\n<\/p>

Zur Anzeige des Fortschritts <\/strong>während des Überschreibens geben Sie die Option -v<\/strong> an:<\/p>\n

shred -v [Gerät \/ Datei(en)]\n<\/p>

Für weitere Informationen über diesen Befehl lesen Sie gerne unseren Beitrag shred<\/strong><\/a>.<\/p>\n

Hardware-Informationen<\/h3>\n

In diesem Abschnitt lernen Sie einige nützliche Befehle kennen, welche das Auslesen von Hardware-Informationen auf Linux-\/UNIX-Betriebssystemen ermöglichen.<\/p>\n

Das im Folgenden mehrfach benötigte Paket lshw<\/strong>, welches <\/strong>nicht auf allen Systemen standardmäßig vorinstalliert ist, können Sie mit dem folgenden Befehl nachinstallieren:<\/p>\n

apt-get install lshw<\/p>\n

Überblick zur Hardware-Konfiguration<\/h4>\n

Den Befehl lshw <\/strong>können Sie verwenden, um einen detaillierten Überblick zur gesamten Hardware-Konfiguration<\/strong> eines Systems zu erhalten. Führen Sie ihn dazu ohne jegliche Optionen und Parameter aus:<\/p>\n

lshw<\/p>\n

Zur Ausgabe gehören unter anderem Informationen zu Speicher-Konfiguration<\/strong>, Firmware-Versionen<\/strong>, Mainboard-Konfiguration<\/strong>, CPU<\/strong>, Cache<\/a> <\/strong>und Bus-Geschwindigkeiten<\/strong>.<\/p>\n

CPU-Informationen<\/h4>\n

Mit dem Befehl lscpu <\/strong>können Sie nähere Informationen zur CPU <\/strong>des Systems ausgeben. Es werden verschiedenste Informationen, wie beispielsweise Architektur<\/strong>, Anzahl Kerne<\/strong>, Threads<\/strong>, Hersteller-ID<\/strong>, Modellname <\/strong>und Frequenz<\/strong>, <\/strong>ausgegeben.<\/p>\n

lscpu<\/p>\n

Den schon bekannten Befehl lshw <\/strong>können Sie zusammen mit der Option -C<\/strong> und dem Parameter ‘cpu’<\/strong> verwenden, um eine ähnliche, jedoch etwas unübersichtliche Ausgabe zu erhalten:<\/p>\n

lshw -C cpu<\/p>\n

RAM-Informationen<\/h4>\n

Informationen zum Arbeitsspeicher <\/strong>lassen sich ebenfalls mit lshw <\/strong>ausgeben. Verwenden Sie hierbei die Option -C<\/strong> mit dem Parameter ‘memory’<\/strong>. In der Ausgabe werden für jeden verbauten DIMM <\/strong>einzeln der Typ <\/strong>sowie die Kapazität<\/strong>, Geschwindigkeit <\/strong>und Spannung <\/strong>ausgegeben.<\/p>\n

lshw -C memory<\/p>\n

Laufwerksinformationen<\/h4>\n

Wird der Befehl lshw <\/strong>mit der Option -C<\/strong> und dem Parameter ‘disk’<\/strong> ausgeführt, so gibt er Informationen zu allen Laufwerken <\/strong>des Systems aus:<\/p>\n

lshw -C disk<\/p>\n

Informationen zu USB- und PCI-Geräten<\/h4>\n

Weiterhin können Informationen zu USB-<\/strong> und PCI-Bussen<\/strong> eines Systems ausgegeben werden. Verwenden Sie dazu die Befehle lsusb <\/strong>und lspci<\/strong>.<\/p>\n

Zur Ausgabe aller per USB <\/strong>an das System angeschlossenen Geräte führen Sie den Befehl lsusb <\/strong>einfach ohne jegliche Optionen und Parameter aus. Die Ausgabe erfolgt dann zeilenweise, wobei der Bus<\/strong>, die Hardware-ID<\/strong> und ein Namensteil <\/strong>aus Vendor-<\/strong> und Product-ID<\/strong> enthalten sind.<\/p>\n

lsusb<\/p>\n

Mit lspci <\/strong>werden Ihnen Informationen zu den PCI-Bussen<\/strong> und angeschlossenen Geräten angezeigt:<\/p>\n

lspci<\/p>\n

Informationen zu Netzwerkgeräten<\/h4>\n

Zur Anzeige von Informationen zu Netzwerkschnittstellen<\/strong>, wie beispielsweise der Bezeichnung<\/strong>, dem Herstellernamen<\/strong>, Bus<\/strong>, Kapazitäten <\/strong>und Frequenzen<\/strong>, verwenden Sie den Befehl lshw <\/strong>mit der Option -C<\/strong> und dem Parameter ‘network’<\/strong>:<\/p>\n

lshw -C network<\/p>\n

Erfahren Sie mehr zu diesem Befehl in unserem Beitrag lshw<\/strong><\/a>.<\/p>\n

Festplattenpartitionierung<\/h3>\n

In diesem Abschnitt zur Festplattenpartitionierung lernen Sie den Befehl fdisk <\/strong>kennen, welcher zum Erstellen<\/strong>, Anzeigen<\/strong>, Bearbeiten <\/strong>und Löschen <\/strong>von Partitionen <\/strong>verwendet werden kann. Das Werkzeug unterstützt eine Vielzahl von Partitionstypen, wie beispielsweise DOS<\/strong>, Linux<\/strong>, FAT32<\/strong> oder NTFS <\/strong>– GPT<\/strong>–Partitionstabellen <\/strong>werden dagegen nicht unterstützt.<\/p>\n

Da fdisk <\/strong>Teil des Standard-Softwarepakets utils-linux-ng<\/strong> ist, muss es bei den meisten Linux Distributionen nicht nachinstalliert werden.<\/p>\n

Partitionstabellen auflisten<\/h4>\n

Mit der Option -l<\/strong> des Befehls ist es möglich, die Partitionstabelle <\/strong>von Geräten auszugeben. Die Ausgabe aller unter \/proc\/partitions<\/strong> aufgelisteten Geräte mitsamt ihrer Partitionstabelle erfolgt bei Verwendung von fdisk <\/strong>und der Option -l<\/strong> ohne jegliche zusätzliche Parameter:<\/p>\n

fdisk -l<\/p>\n

Wird jedoch ein Gerät <\/strong>als Parameter angegeben, so gibt fdisk <\/strong>die Partitionstabelle für genau dieses Gerät aus:<\/p>\n

fdisk -l [Gerät]\n<\/p>

Partitionstabellen bearbeiten<\/h4>\n

Die Bearbeitung <\/strong>der Partitionstabelle <\/strong>eines Geräts ist mithilfe des menügesteuerten Bereichs von fdisk <\/strong>möglich. Dieser ist durch Eingabe von fdisk <\/strong>mit dem jeweiligen Gerätenamen <\/strong>möglich:<\/p>\n

fdisk [Gerät]\n<\/p>

Im folgenden werden die wichtigsten Kommandos <\/strong>für die Bearbeitung <\/strong>von Partitionstabellen <\/strong>genannt – einen vollständigen Überblick zu allen verfügbaren Kommandos können Sie sich durch Eingabe von ‘m’<\/strong> ausgeben lassen.<\/p>\n

p – Print<\/h5>\n

Mit dem Kommando ‘p’<\/strong> lässt sich die Partitionstabelle <\/strong>des aktuellen Geräts ausgeben. Die Ausgabe erfolgt ähnlich wie auch bei der direkten Verwendung der Option -l<\/strong> mit fdisk<\/strong>.<\/p>\n

o – Overwrite<\/h5>\n

Eine neue <\/strong>leere <\/strong>DOS<\/strong>– bzw. MBR<\/strong>–Partitionstabelle<\/strong> lässt sich mit dem Kommando ‘o’<\/strong> anlegen. Beachten Sie, dass die neue Partitionstabelle eine bereits existierende Tabelle bei Bestätigung der Änderung überschreibt<\/strong>.<\/p>\n

n – New<\/h5>\n

Das Kommando ‘n’<\/strong> wird verwendet, um neue <\/strong>Partitionen <\/strong>auf dem aktuellen Gerät zu erstellen. Ein Assistent führt Sie dabei durch die erforderlichen Schritte.<\/p>\n

d – Delete<\/h5>\n

Eine Partition <\/strong>kann mithilfe von ‘d’<\/strong> wieder aus der Partitionstabelle eines Geräts gelöscht <\/strong>werden.<\/p>\n

a – Active<\/h5>\n

Bei DOS<\/strong>– bzw. MBR<\/strong>–Partitionstabellen <\/strong>lässt sich das Kommando ‘a’<\/strong> verwenden, um das Boot-Flag<\/strong> einer Partition zu setzen.<\/p>\n

w – Write<\/h5>\n

Die Änderungen <\/strong>an der Partitionstabelle <\/strong>eines Geräts werden von fdisk <\/strong>erst bei Verwendung des Kommandos ‘w’ <\/strong>geschrieben und damit wirksam<\/strong>. Nach Eingabe des Kommandos werden alle Änderungen auf das Gerät geschrieben und fdisk <\/strong>beendet.<\/p>\n

Mehr Informationen zu diesem Befehl finden Sie in unserem Beitrag fdisk<\/strong><\/a>.<\/p>\n

Aliase definieren \/ löschen<\/h3>\n

Mit dem Befehl alias <\/strong>lassen sich alternative Aufrufnamen (Aliase) für Befehlsaufrufe definieren. In diesem Abschnitt soll der Befehl in seiner grundlegenden Anwendung vorgestellt werden.<\/p>\n

Alias definieren<\/h4>\n

Die allgemeine Syntax zur Definition eines neuen Alias<\/strong> lautet folgendermaßen:<\/p>\n

alias [Aliasname]='[Befehl]’<\/p>\n

Der auf diese Weise definierte Alias wird mit [Aliasname]<\/strong> aufgerufen und führt dann den Befehl [Befehl]<\/strong> aus.<\/p>\n

Aliase anzeigen<\/h4>\n

Ein mit alias <\/strong>erzeugter Alias kann auch ausgegeben<\/strong> werden, um Einsicht in den für ihn festgelegten Befehl zu erlangen. Dazu wird dem Befehl alias <\/strong>einfach der jeweilige Aliasname<\/strong> übergeben:<\/p>\n

alias [Aliasname]\n<\/p>

Die Ausgabe <\/strong>dieses Befehls hat dann die Form: [Aliasname]='[Befehl]’<\/strong>. Schließlich ist es auch möglich, alle <\/strong>bereits definierten Aliase auszugeben. Hierzu wird der Befehl alias <\/strong>ohne jegliche Parameter oder Optionen verwendet:<\/p>\n

alias<\/p>\n

Alias löschen<\/h4>\n

Zwar existieren so gesetzte Aliase nur bis zur Beendigung der Shell<\/strong>, in welcher sie definiert wurden, so ist es dennoch möglich sie auch ausdrücklich zu löschen<\/strong>. Hierzu wird der Befehl unalias <\/strong>eingesetzt:<\/p>\n

unalias [Aliasname]\n<\/p>

Wie Sie einen dauerhaften Alias definieren<\/strong>, erfahren Sie in unserem Beitrag alias<\/a>.<\/p>\n

Extended Arguments<\/h3>\n

Der in diesem Abschnitt beschriebene Befehl xargs <\/strong>(ex<\/strong>tended arg<\/strong>uments<\/strong>) kann in verschiedenen Situationen eingesetzt werden, um etwa große Argumentlisten mit einem beliebigen Befehl zu verarbeiten, oder sogar um eine parallelisierte Abarbeitung zugunsten einer höheren Performance zu erreichen.<\/p>\n

Es sollen hier nur die wichtigsten Anwendungen von xargs <\/strong>vorgestellt werden. Für nähere Informationen zu den <\/strong>verfügbaren Optionen sowie verschiedene praktische Beispiele des Befehls lesen Sie auch unseren Beitrag xargs<\/strong><\/a>.<\/p>\n

Der Befehl xargs <\/strong>lässt sich allgemein ohne jegliche Optionen einsetzen, um eine vom Standard-Input stdin<\/strong> eingelesene Liste von Argumenten in eine oder mehrere Kommandozeilen umzuwandeln und diese auszuführen. Standardmäßig werden dabei so viele Argumente wie möglich an das Ende des xargs’<\/strong> übergebenen Befehls sowie seiner initialen Argumente gehängt.<\/p>\n

xargs [Optionen] [Befehl [Initiale Argumente]]\n<\/p>

Der Standard-Output stdout<\/strong> eines Befehls (z.B. ls<\/strong>) ließe sich so etwa per Pipe an xargs <\/strong>übergeben, um dort weitere Aktionen mit den Argumenten durchzuführen:<\/p>\n[Befehl] | xargs [Optionen] [Befehl [Initiale Argumente]]\n

Anzahl Argumente<\/h4>\n

Möchten Sie lediglich ein Argument pro Kommandozeile verwenden, so können Sie dies mit der Option -n<\/strong> und dem Parameter 1 spezifizieren. Jedes Argument erhält so eine eigene Kommandozeile – dies ist besonders dann wichtig, wenn der mit xargs <\/strong>verwendete Befehl selbst nicht die Angabe einer Argumentliste unterstützt.<\/p>\n

xargs -n 1 [Befehl [Initiale Argumente]]\n<\/p>

Platzhalter ersetzen<\/h4>\n

Wenn die eingelesenen Argumente nicht an das Ende des Befehls angehängt werden sollen und stattdessen an anderer Stelle eingefügt werden müssen, so ist die Verwendung eines Platzhalters zur Ersetzung möglich. Der Platzhalter wird mit der Option -I<\/strong> angegeben und vor der Ausführung der Kommandozeilen jeweils durch die Argumente ersetzt. Diese Option findet etwa bei dem Kopieren vieler einzelner Dateien in ein bestimmtes Zielverzeichnis mit dem Befehl cp<\/strong> Anwendung.<\/p>\n

In diesem Fall wird die Zeichenkette “{}”<\/strong> zur Ersetzung verwendet und durch die Option -n<\/strong> mit dem Parameter 1 jeweils ein Argument eingesetzt:<\/p>\n

xargs -I {} [Befehl [Initiale Argumente]] {} […]\n<\/p>

Parallelisierung<\/h4>\n

Schließlich kann xargs <\/strong>die Ausführung von Befehlen bzw. die Abarbeitung von Aufgaben parallelisieren: Hierbei kommt die Option -P<\/strong> zum Einsatz, welche eine maximale Anzahl Prozesse definiert, die xargs <\/strong>zu einem Zeitpunkt gleichzeitig ausführen darf. Anwendung findet diese Option etwa zur Parallelisierung von rsync<\/strong> bei der Übertragung vieler kleiner Dateien zwischen zwei Systemen, oder dem Download vieler kleiner Dateien aus dem Internet mit wget<\/strong>.<\/p>\n

In vielen Fällen ist es sinnvoll hier die maximale Anzahl Argumente pro ausgeführter Kommandozeile bzw. ausgeführtem Prozess zu beschränken – unter Umständen wird andernfalls nur ein Prozess mit allen Argumenten auf einer Kommandozeile gestartet. Im untenstehenden Befehl wird daher die Option -n<\/strong> zusätzlich eingesetzt:<\/p>\n

xargs -n 1 -P [Anzahl Prozesse] [Befehl [Initiale Argumente]]\n<\/p>

Anmeldungen anzeigen<\/h3>\n

Dieser Abschnitt gibt eine kurze Einführung in die grundlegende Anwendung der Befehle users<\/strong> und last <\/strong>zur Ausgabe von Benutzeranmeldungen <\/strong>am System. Der Befehl users <\/strong>kann ohne Argumente aufgerufen werden und liefert eine schnelle Übersicht zu den aktuell am System angemeldeten Benutzern – auf einer Zeile:<\/p>\n

users<\/p>\n

Weitere Informationen zu diesem Befehl finden Sie in unserem Beitrag users<\/strong>. Mit dem Befehl last <\/strong>stehen Ihnen dagegen viele weitere Möglichkeiten offen. So können Sie beispielsweise auch vergangene Benutzeranmeldungen einsehen. Allgemein wird der Befehl last <\/strong>mithilfe der folgenden Syntax aufgerufen:<\/p>\n

last [Optionen] [Benutzername]\n<\/p>

Zeitraum einschränken<\/h4>\n

Mithilfe zusätzlicher Optionen lässt sich der Zeitraum einschränken, für welchen Anmeldungen ausgegeben werden. Die Option -t<\/strong> wird so etwa verwendet, um einen Bis-Zeitpunkt<\/strong> zu spezifizieren:<\/p>\n

last -t [Zeit] [Benutzername]\n<\/p>

Weiterhin kann auch ein Von-Zeitpunkt<\/strong> spezifiziert werden, welcher als Startzeitpunkt für auszugebende Anmeldungen dienen soll. Hier wird die Option -s<\/strong> verwendet:<\/p>\n

last -s [Zeit] [Benutzername]\n<\/p>

Beide Optionen können kombiniert werden, um sowohl eine Unter- und als auch eine Obergrenze für die Ausgabe festzulegen. Bei den Zeitangaben <\/strong>werden viele Formate <\/strong>unterstützt, welche im Folgenden aufgelistet sind:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
\n

Datumsformat<\/strong><\/p>\n<\/th>\n

\n

Funktion u. Beispiele<\/p>\n<\/th>\n<\/tr>\n<\/thead>\n

\n

YYYYMMDDhhmmss<\/p>\n<\/td>\n

\n

20210222150533<\/p>\n<\/td>\n<\/tr>\n

\n

YYYY-MM-DD hh:mm:ss<\/p>\n<\/td>\n

\n

2021-02-22 15:05:33<\/p>\n<\/td>\n<\/tr>\n

\n

YYYY-MM-DD hh:mm<\/p>\n<\/td>\n

\n

2021-02-22 15:05, verwendete Sekunden 00<\/p>\n<\/td>\n<\/tr>\n

\n

YYYY-MM-DD<\/p>\n<\/td>\n

\n

2021-02-22, verwendete Zeit 00:00<\/p>\n<\/td>\n<\/tr>\n

\n

hh:mm:ss<\/p>\n<\/td>\n

\n

15:05:33, verwendeter tag “today”<\/p>\n<\/td>\n<\/tr>\n

\n

hh:mm<\/p>\n<\/td>\n

\n

15:05, verwendeter tag “today” u. Sekunden 00<\/p>\n<\/td>\n<\/tr>\n

\n

now<\/p>\n<\/td>\n

\n

Zeit der Maschine<\/p>\n<\/td>\n<\/tr>\n

\n

yesterday<\/p>\n<\/td>\n

\n

Gestern, mit der Uhrzeit 00:00:00<\/p>\n<\/td>\n<\/tr>\n

\n

today<\/p>\n<\/td>\n

\n

Heute, mit der Uhrzeit 00:00:00<\/p>\n<\/td>\n<\/tr>\n

\n

tomorrow<\/p>\n<\/td>\n

\n

Morgen, mit der Uhrzeit 00:00:00<\/p>\n<\/td>\n<\/tr>\n

\n

+5min<\/p>\n<\/td>\n

\n

Abweichung in Minuten<\/p>\n<\/td>\n<\/tr>\n

\n

-days<\/p>\n<\/td>\n

\n

Abweichung in Tagen<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

Ausführlichere Informationen mitsamt Beispielen zu diesem Befehl finden Sie in unserem Beitrag last<\/strong><\/a>.<\/p>\n

Metadaten anzeigen<\/h3>\n

Mit dem Befehl stat<\/strong>, welcher in diesem Abschnitt kurz eingeführt wird, können Sie sich verschiedene Metadaten von Dateien und Verzeichnissen anzeigen lassen – beispielsweise Zeitstempel, Berechtigungen, Besitzer, Gruppe und Dateityp. Der Befehl wird im Folgenden kurz, zusammen mit seinen wichtigsten Optionen, vorgestellt.<\/p>\n

Allgemein lässt sich der Befehl folgendermaßen – ohne <\/strong>zusätzliche <\/strong>Optionen <\/strong>– aufrufen:<\/p>\n

stat [Datei- \/ Verzeichnis]\n<\/p>

stat <\/strong>gibt hierbei viele verschiedene Informationen aus. Dazu gehören Name, Größe, Blöcke, EA Block, Typ, Gerät, Inode, Verknüpfungen, Berechtigungen sowie Zugriffs- \/ Modifizierungs- \/ Änderungs- und Erstellungszeitstempel des spezifizierten Elements.<\/p>\n

Wird die Option -t<\/strong> zusätzlich angegeben, so kann eine Ausgabe in Kurzform<\/strong> durchgeführt werden. Die Informationen zur spezifizierten Datei bzw. dem Verzeichnis werden dann auf einer Zeile durch Leerzeichen getrennt ausgegeben. <\/p>\n

stat -t [Datei- \/ Verzeichnis]\n<\/p>

Die Ausgabe<\/strong> der Option -t<\/strong> zeigt die folgenden Informationen in der angegebenen Reihenfolge: Name, Blockgröße, gesamte Datenblöcke im Dateisystem, freie Blöcke im Dateisystem, Benutzer-ID des Besitzers, Gruppen-ID des Besitzers, Gerätenummer (hexadezimal), Dateisystem-ID (hexadezimal), Anzahl harter Verknüpfungen, Major-Gerätetyp (hexadezimal), Minor-Gerätetyp (hexadezimal), letzte Zugriffszeit, letzte Daten-Modifizierungszeit, letzte Status-Änderungszeit, Erstellungszeit (jeweils in Sekunden nach der UNIX-Epoche) und schließlich ein Hinweis auf die optimale I\/O-Übertragungsgröße.<\/p>\n

Schließlich können Sie das Format <\/strong>der stat <\/strong>Ausgabe mithilfe der Option –printf<\/strong> auch selbst festlegen. Die Angabe des Formats erfolgt, in Anführungszeichen eingefasst, direkt hinter der Option. Maskierungen mit dem Rückschrägstrich “” <\/strong>werden von stat <\/strong>interpretiert – so können mit “n” etwa Zeilenumbrüche eingefügt werden. <\/p>\n

stat –printf [Format] [Datei- \/ Verzeichnis]\n<\/p>

Im Format können verschiedene Formatangaben<\/strong>, in der Regel ein Prozentzeichen “%”<\/strong> mit einem Buchstaben<\/strong>, verwendet werden, welche von stat<\/strong> später durch tatsächlich ausgelesene Metainformationen ersetzt werden. Ein “%n”<\/strong> wird so etwa zur Ausgabe des Datei- bzw. Verzeichnisnamen verwendet. Nähere Informationen zu den verfügbaren Formatangaben und weiteren Optionen des Befehls finden Sie in unserem Beitrag stat<\/strong><\/a>.<\/p>\n

Software-RAID verwalten<\/h3>\n

Die Verwaltung – also das Erstellen, Konfigurieren, Überwachen und Löschen – von Software-RAIDs ist unter Linux \/ UNIX mit dem Befehl mdadm <\/strong>möglich. Dieser Abschnitt soll kurz die grundlegenden Anwendungen des Befehls zeigen.<\/p>\n

Der Befehl mdadm <\/strong>muss, wenn er auf Ihrem System nicht bereits installiert ist, erst aus den Repositories installiert werden. Dies können Sie mit dem folgenden Befehl tun:<\/p>\n

apt-get install mdadm<\/p>\n

Die allgemeine Syntax von mdadm <\/strong>sieht wie folgt aus:<\/p>\n

mdadm [Modus] [RAID-Device] [Optionen] [Component-Device(s)]\n<\/p>

Der verwendete Modus gibt an, welche Aktion durchgeführt werden soll. So ist es möglich, mit dem Modus “Create”<\/strong>, welcher mit der Option –create<\/strong> aufgerufen wird, Software-RAIDs zu erstellen:<\/p>\n

mdadm –create [Label \/ Gerätename] –level=[RAID-Level] –raid-devices=[Anzahl Partitionen] [Component-Devices]\n<\/p>

Der Option –create<\/strong> kann dabei optional ein Label für das neue RAID-Device übergeben werden. Zudem werden mit –level<\/strong> einer der RAID-Level 0, 1, 4, 5, 6 oder 10 angegeben sowie mit der Option –raid-devices=<\/strong> die Anzahl der physischen Partitionen und darauffolgend deren Gerätenamen spezifiziert.<\/p>\n

Ein RAID-Verbund kann mit den beiden Optionen –detail<\/strong> und –examine<\/strong> aufgelistet werden, wobei –detail<\/strong> sich auf den gesamten RAID-Verbund und –examine<\/strong> sich auf ein bestimmtes Component-Device bezieht:<\/p>\n

mdadm –detail [RAID-Device]\n<\/p>

mdadm –examine [Component-Device]\n<\/p>

Der Status eines konfigurierten RAID-Device lässt sich unter \/proc\/mdstat<\/strong> auslesen – beispielsweise mit cat<\/strong>:<\/p>\n

cat \/proc\/mdstat<\/p>\n

Mit der Option –stop<\/strong> kann ein bestehendes RAID-Device schließlich deaktiviert und verwendete Ressourcen freigegeben werden – physisch bleibt es dabei weiter bestehen:<\/p>\n

mdadm –stop [RAID-Device]\n<\/p>

Soll ein RAID komplett entfernt werden, so müssen für alle beteiligten Component-Devices mit der Option –zero-superblock<\/strong> die Superblöcke nullgesetzt werden:<\/p>\n

mdadm –zero-superblock [Component-Device]\n<\/p>

Nähere Informationen zu Software-RAIDs, weiteren Optionen des Befehls <\/strong>sowie seiner Anwendung finden Sie in unserem Beitrag Software RAID MDADM<\/a>.<\/p>\n

Festplattenformatierung<\/h3>\n

Bei der Formatierung wird das Dateisystem eines Datenträgers festgelegt, wobei zuvor in der Regel mindestens eine Partition angelegt werden muss. In diesem Abschnitt lernen Sie hierzu den Befehl mkfs <\/strong>kennen, welcher unter UNIX \/ Linux pro Dateisystem in einer eigenen Version existiert. Die Befehle beginnen dabei alle mit dem Präfix “mkfs.”<\/strong> und sind gefolgt von dem Namen des Dateisystems. Für die Formatierung mit ext4 <\/strong>wird so etwa der Befehl “mkfs.ext4”<\/strong> verwendet.<\/p>\n

Die Syntax ist für alle mkfs-Befehle<\/strong> grundsätzlich gleich:<\/p>\n

mkfs.[Dateisystemname] [Optionen] [Gerät]\n<\/p>

Während in den meisten Fällen keine zusätzlichen Optionen angegeben werden müssen, da die Standardwerte bereits sinnvoll eingestellt sind, ist die Angabe des zu formatierenden Geräts zwingend notwendig. Beispielhaft könnte die erste Partition eines Datenträgers mit dem Gerätenamen “\/dev\/sdb”<\/strong> wie folgt mit einem ext3-Dateisystem<\/strong> formatiert werden:<\/p>\n

mkfs.ext3 \/dev\/sdb1<\/p>\n

Wenn benötigt, sind der Manpage <\/strong>des jeweiligen mkfs-Befehls<\/strong> dateisystemspezifisch verfügbare Optionen zu entnehmen.<\/p>\n

Mehr Informationen zu dem Befehl finden Sie in unserem Beitrag mke2fs<\/strong><\/a>.<\/p>\n

Datei-\/Verzeichniskapazitäten anzeigen<\/h3>\n

Die Anzeige der Kapazität gegebener Dateien oder Verzeichnisse ist mit dem Befehl du <\/strong>möglich. Die allgemeine Syntax des Befehls lautet:<\/p>\n

du [Optionen] [Verzeichnis(se) \/ Datei(en)]\n<\/p>

Wird der Befehl alleinstehend, ohne Angabe von Dateien oder Verzeichnissen, ausgeführt, dann werden rekursiv die Kapazitäten der Unterverzeichnisse des aktuellen Arbeitsverzeichnisses ausgegeben. Analog erfolgt die Ausgabe der Unterverzeichnisse eines oder mehrerer spezifizierter Verzeichnisse. Werden Dateien angegeben, dann gibt du <\/strong>die Kapazitäten von diesen aus.<\/p>\n

Sollen neben den Kapazitäten von Unterverzeichnissen auch solche von enthaltenen Dateien ausgegeben werden, dann verwenden Sie die Option -a<\/strong>:<\/p>\n

du -a [Verzeichnis(se) \/ Datei(en)]\n<\/p>

Benötigen Sie die Gesamtsumme aller von du <\/strong>ausgegebenen Dateien bzw. Verzeichnisse, dann können Sie diese unter Verwendung der Option -c<\/strong> zusätzlich von du <\/strong>berechnen und am Ende (unter der Bezeichnung “insgesamt”<\/strong>) ausgeben lassen:<\/p>\n

du -c [Verzeichnis(se) \/ Datei(en)]\n<\/p>

Schließlich ist es möglich, die Kapazitäten in menschenlesbarem Format – beispielsweise 4K, 2M oder 4,9G auszugeben:<\/p>\n

du -h [Verzeichnis(se) \/ Datei(en)]\n<\/p>

Wenn Sie nähere Informationen zum diesem Befehl, seinen weiteren Optionen und zu seiner Anwendung benötigen, dann lesen Sie auch unseren Beitrag du<\/strong><\/a>.<\/p>\n

Dateisystemkapazitäten anzeigen<\/h3>\n

Mit dem Befehl df <\/strong>ist es möglich, die verfügbaren und belegten Kapazitäten von eingehängten Dateisystemen anzuzeigen. Allgemein wird der Befehl wie folgt angewandt:<\/p>\n

df [Optionen] [Verzeichnis(se) \/ Datei(en)]\n<\/p>

Die Angabe von Verzeichnissen bzw. Dateien ist optional – standardmäßig, also wenn keine Verzeichnisse oder Dateien übergeben wurden, werden die Kapazitäten aller derzeit eingehängten Dateisysteme angezeigt. Wurden jedoch Verzeichnisse bzw. Dateien angegeben, dann werden jeweils die Kapazitäten der Dateisysteme ausgegeben, die die übergebenen Elemente enthalten.<\/p>\n

Die Ausgabe hat das Format einer Tabelle mit den Spalten “Dateisystem”<\/strong>, “1K-Blöcke”<\/strong>, “Benutzt”<\/strong>, “Verfügbar”<\/strong>, “Verw%”<\/strong> und “Eingehängt auf”<\/strong>. Es werden also pro Dateisystem die Gesamtgröße (“1K-Blöcke”<\/strong>), der belegte (“Benutzt”<\/strong>) und verfügbare Platz sowie auch der Einhängepunkt ausgegeben. Der Platz wird dabei standardmäßig in 1K-Blöcken ausgegeben.<\/p>\n

Da die Anzeige in 1K-Blöcken für einen Menschen eher umständlich lesbar ist, kann mit der Option -h<\/strong> auch auf ein besser lesbares Format (je nach Größe beispielsweise mit den Einheiten Mebibyte (M) oder Gibibyte (G)) umgestellt werden:<\/p>\n

df -h [Verzeichnis(se) \/ Datei(en)]\n<\/p>

Eine weitere nützliche Option <\/strong>ist -T<\/strong>. Diese führt dazu, dass df <\/strong>die Dateisystemtypen (z.B.: “ext3”<\/strong>, “ext4”<\/strong>) jeweils in einer zusätzlichen Spalte ausgibt:<\/p>\n

df -T [Verzeichnis(se) \/ Datei(en)]\n<\/p>

Weitere Informationen zum diesem Befehl finden Sie in unserem Beitrag df<\/strong><\/a>.<\/p>\n

Dateisysteme erstellen<\/h3>\n

Der Befehl mke2fs <\/strong>ermöglicht die Erstellung von ext2-<\/strong>, ext3-<\/strong> oder ext4-Dateisystemen<\/strong> – üblicherweise auf einer Festplattenpartition. Beim Aufruf von mke2fs <\/strong>ist die Angabe eines Geräts<\/strong>, auf dem das Dateisystem angelegt werden soll, notwendig:<\/p>\n

mke2fs [Optionen] [Gerät]\n<\/p>

Werden keine Optionen übergeben, so verwendet mke2fs <\/strong>die in der Konfigurationsdatei \/etc\/mke2fs.conf<\/strong> festgelegten Standardwerte für das neue Dateisystem. Eine der wichtigsten Optionen des Befehls ist -t<\/strong>. Diese wird verwendet, um “ext2”<\/strong>, “ext3”<\/strong> oder “ext4”<\/strong> als Dateisystemtyp für das neue Dateisystem festzulegen:<\/p>\n

mke2fs -t [ext2|ext3|ext4] [Gerät]\n<\/p>

Soll das Dateisystem mit einem ext3-Journal<\/strong> erstellt werden, so geben Sie die Option -j<\/strong> an. Wenn nicht anderweitig spezifiziert nutzt mke2fs <\/strong>dann Standard-Journal-Parameter für die Erstellung des Journals.<\/p>\n

mke2fs -j [Gerät]\n<\/p>

Schließlich sei hier noch die Option -b<\/strong> genannt, welche die Festlegung der Blockgröße <\/strong>des neuen Dateisystems erlaubt. Gültige Werte sind 1024<\/strong>, 2048 <\/strong>und 4096 <\/strong>Bytes pro Block. Wird die Option nicht verwendet, dann bestimmt mke2fs <\/strong>die Blockgröße heuristisch auf Grundlage der Dateisystemgröße sowie der erwarteten Nutzung.<\/p>\n

mke2fs -b [Blockgröße] [Gerät]\n<\/p>

Möchten Sie mehr zu diesem Befehl erfahren, lesen Sie gerne auch unseren Beitrag mke2fs<\/strong><\/a>.<\/p>\n

Dateien aufteilen<\/h3>\n

Dateien lassen sich mithilfe des Befehls split <\/strong>beliebig in kleinere Dateien aufteilen – etwa um die Verarbeitung von großen Dateien in mehrere gleich große “Blöcke” aufzuteilen. Auch bei der Datensicherung \/ Verteilung könnten Dateien mit split <\/strong>aufgeteilt und zu einem späteren Zeitpunkt wieder zusammengesetzt werden – dies ist beispielsweise dann wichtig, wenn die Größe einer Datei die maximale Dateigröße eines Zieldateisystems überschreitet. Allgemein wird der Befehl wie folgt verwendet:<\/p>\n

split [Optionen] [Datei [Präfix]]\n<\/p>

split <\/strong>teilt die übergebene Datei standardmäßig so auf, dass jede Teildatei maximal 1000 Zeilen bzw. Datensätze beinhaltet. Benannt werden die Dateien automatisch nach dem Schema “[Präfix]aa”<\/strong>, “[Präfix]ab”<\/strong>, “[Präfix]ac”<\/strong> etc. Der zweistellige Suffix wird also inkrementiert, als handele es sich um ein Stellenwertsystem zur Basis 26. Der Standard-Präfix ist “x”<\/strong>. Sollen numerische Suffixe verwendet werden, so spezifizieren Sie zusätzlich die Option –d<\/strong>:<\/p>\n

split –d [Datei [Präfix]]\n<\/p>

Möchten Sie anstelle der standardmäßigen 1000 Zeilen \/ Datensätze pro Teildatei eine andere Anzahl spezifizieren, so können Sie dies mit der Option -l<\/strong> tun:<\/p>\n

split -l [Anzahl] [Datei [Präfix]]\n<\/p>

Wird die Option -b<\/strong> angegeben, so trennt split <\/strong>nicht anhand der Anzahl Zeilen \/ Datensätze pro Teildatei, sondern mithilfe der Anzahl Bytes. Es wird ein Integer angegeben, welcher die maximale Anzahl Bytes pro Teildatei, also die jeweilige Größe in Bytes, festlegt:<\/p>\n

split -b [Größe] [Datei [Präfix]]\n<\/p>

Informationen zu den weiteren verfügbaren Optionen und Beispiele zu diesem Befehl finden Sie in unserem Beitrag split<\/strong><\/a>.<\/p>\n

ATA-Laufwerksparameter auslesen<\/h3>\n

Dieser Abschnitt gibt eine kurze Einführung in die Anwendung des Befehls hdparm <\/strong>zum Lesen von Parametern von ATA-Laufwerken. Es ist zu beachten, dass es sich um einen Befehl für fortgeschrittene Benutzer handelt, da er bei unsachgemäßer Verwendung auch zu Instabilitäten und unumkehrbaren Schäden an den Laufwerken führen kann. Die Syntax des Befehls lautet allgemein folgendermaßen:<\/p>\n

hdparm [Optionen] [Gerät(e)]\n<\/p>

Bei Ausführung ohne jegliche Optionen gibt hdparm <\/strong>grundlegende Daten zum angegebenen Laufwerk aus. Dazu gehören etwa DMA<\/strong>, multiple-sector-count<\/strong>, read-only<\/strong>, read-ahead<\/strong> und die Geometrie<\/strong>.<\/p>\n

Detailliertere Informationen, die zur Boot- bzw. Konfigurationszeit von den Kernel-Treibern gespeichert wurden, lassen sich mit der Option -i<\/strong> ausgeben. Es werden somit viele weitere Parameter, wie beispielsweise die Modell-Bezeichnung<\/strong>, Firmware-Version<\/strong>, Seriennummer<\/strong> und die Kapazität des Laufwerkscache ausgegeben:<\/p>\n

hdparm -i [Gerät(e)]\n<\/p>

Schließlich ist die Ausgabe noch detaillierterer Informationen, welche bei Befehlsausführung direkt aus dem Laufwerk ausgelesen werden, mit der Option -I<\/strong> möglich. Die Ausgabe ist in Abschnitte eingeteilt und beinhaltet unter anderem Informationen zum ATA-Gerät<\/strong> selbst, zu Standards<\/strong>, der Konfiguration <\/strong>(Configuration), Kapazitäten <\/strong>(Capabilities) und zu aktivierten bzw. deaktivierten Funktionen <\/strong>(Commands\/features):<\/p>\n

hdparm -I [Gerät(e)]\n<\/p>

Weitere Informationen, welche etwa auch die Anwendung des Befehls zur Durchführung von System-Cache-Tests umfassen, finden Sie in unserem Beitrag hdparm<\/strong><\/a>.<\/p>\n

Kernel-Meldungen auslesen<\/h3>\n

Mithilfe des Befehls dmesg <\/strong>können Meldungen aus dem Kernel-Ringpuffer ausgelesen werden. Der Befehl hilft so bei der Fehlersuche im System – beispielsweise wenn neue Hardware nicht korrekt erkannt wurde. Die allgemeine Syntax lautet folgendermaßen:<\/p>\n

dmesg [Optionen]\n<\/p>

Bei Ausführung ohne jegliche Optionen gibt der Befehl die Meldungen des Kernel-Ringpuffers standardmäßig ungefiltert und voll umfänglich aus. Zum Extrahieren der jeweils wichtigen Informationen ist es daher sinnvoll, dmesg <\/strong>mithilfe einer Pipe mit einem anderen Befehl zu kombinieren (beispielsweise mit grep<\/strong>), oder die Ausgabe mit Optionen zu beschränken.<\/p>\n

Verfügbare Optionen zu diesem Befehl sowie auch einige Beispiele zur Anwendung finden Sie in unserem Beitrag dmesg<\/strong><\/a>.<\/p>\n

Angeschlossene Partitionen auslesen<\/h3>\n

Informationen zu den an einem System angeschlossenen Partitionen lassen sich mit dem Befehl blkid <\/strong>auslesen. Unter anderem können mit blkid <\/strong>Gerätedatei<\/strong>, UUID<\/strong>, Name <\/strong>und Dateisystemtyp <\/strong>ermittelt werden. Es werden dabei Root-Rechte<\/strong> benötigt. Die allgemeine Syntax von blkid <\/strong>lautet:<\/p>\n

blkid [Optionen] [Gerätedatei]\n<\/p>

Bei Ausführung ohne jegliche Optionen sowie ohne Angabe einer Gerätedatei gibt blkid <\/strong>alle angeschlossenen Partitionen mitsamt der entsprechenden Informationen zeilenweise aus. Wird dagegen die Gerätedatei einer Partition angegeben, so zeigt blkid <\/strong>nur die Informationen dieser Partition.<\/p>\n

Weitere Informationen zu diesem Befehl finden Sie in unserem Beitrag blkid<\/strong><\/a>.<\/p>\n

Dateikomprimierung<\/h3>\n

Dateien lassen sich mit verschiedenen Werkzeugen komprimieren: Ein unter UNIX- \/ Linux-Betriebssystemen weit verbreitetes Programm hierfür ist gzip<\/strong>. Der Befehl ermöglicht die Komprimierung einzelner Dateien in sogenannte .gz-Archive<\/strong>, wobei Dateiattribute erhalten bleiben. Allgemein lässt sich gzip <\/strong>folgendermaßen aufrufen:<\/p>\n

gzip [Optionen] [Datei(en)]\n<\/p>

Mehrere Dateien können angegeben werden, werden von gzip <\/strong>dann jedoch jeweils in ein eigenes Archiv komprimiert. Die Originaldatei wird nach dem Komprimieren gelöscht und durch das komprimierte Archiv ersetzt. Der Dateiname letzteren Archivs entspricht dabei dem Namen der Originaldatei, ergänzt mit der Endung “.gz”<\/strong>. Anstelle von Dateinamen kann dem Befehl auch ein Minuszeichen “-“<\/strong> übergeben werden, um den Standard-Input stdin <\/strong>zu komprimieren und an den Standard-Output stdout<\/strong> weiterzugeben.<\/p>\n

Möchten Sie die Originaldateien entgegen des Standardverhaltens von gzip <\/strong>behalten, so können Sie zusätzlich die Option -k<\/strong> spezifizieren:<\/p>\n

gzip -k [Datei(en)]\n<\/p>

Schließlich ist es natürlich auch möglich, eine mit gzip <\/strong>komprimierte Datei wieder zu entpacken. Hierzu wird die Option -d<\/strong> spezifiziert und die entsprechende Archivdatei übergeben. Es können auch mehrere Archivdateien im Rahmen eines Befehlsaufrufs entpackt werden:<\/p>\n

gzip -d [Datei(en)]\n<\/p>

Nähere Informationen zu gzip <\/strong>selbst, sowie weitere Optionen – etwa zur Einstellung der Komprimierungsstufe <\/strong>oder zum rekursiven Komprimieren<\/strong> aller in Verzeichnissen enthaltenen Dateien – können Sie in unserem Beitrag gzip<\/strong><\/a> <\/strong>nachlesen.<\/p>\n

SHA-Prüfsummen bilden<\/h3>\n

SHA-Prüfsummen<\/strong>, die etwa zur Überprüfung der Integrität einer Datei verwendet werden, können Sie mit dem Befehl shasum <\/strong>berechnen. Der Befehl bietet dabei die Wahl zwischen den Algorithmen SHA-1, SHA-224, SHA-256, SHA-384 und SHA-512. Die allgemeine Syntax lautet:<\/p>\n

shasum [Optionen] [Datei(en)]\n<\/p>

Standardmäßig berechnet shasum <\/strong>die SHA-1-Prüfsumme der übergebenen Datei. Es können auch mehrere Dateien übergeben werden – die Prüfsummen werden dann jeweils untereinander ausgegeben. Alternativ ist es auch möglich, den Befehl vom Standard-Input stdin <\/strong>lesen zu lassen. Dazu wird entweder keine Datei oder ein Minus-Zeichen “-” übergeben. Die Ausgabe der berechneten Prüfsummen erfolgt jeweils pro Datei auf einer Zeile und beinhaltet hintereinander die Prüfsumme selbst sowie den entsprechenden Dateinamen.<\/p>\n

Wie bereits zu Beginn angekündigt unterstützt shasum <\/strong>noch viele weitere Algorithmen. Diese können mithilfe der Option -a<\/strong> ausgewählt werden. Der Algorithmus wird jeweils ohne den Präfix “SHA-” übergeben, sodass die Wahl zwischen “1”<\/strong> (SHA-1), “224”<\/strong> (SHA-224), “256”<\/strong> (SHA-256), “384”<\/strong> (SHA-384) und “512”<\/strong> (SHA-512) besteht:<\/p>\n

shasum -c [Algorithmus] [Datei(en)]\n<\/p>

Nähere Informationen zu diesem Befehl, seinen übrigen Optionen und insbesondere der Möglichkeit zum Abgleich von Prüfsummen, entnehmen Sie unserem Beitrag shasum<\/strong>.<\/p>\n

Wurzelverzeichnis wechseln<\/h3>\n

Wenn Sie einen Befehl oder eine interaktive Shell mit einem bestimmten anderen Wurzelverzeichnis <\/strong>ausführen möchten, dann können Sie dazu den Befehl chroot <\/strong>verwenden. Der Befehl eignet sich so beispielsweise für den Wechsel in die Bash eines anderen, eingehängten Systems, um eine Neuinstallation des GRUB-Bootloaders durchzuführen. Die allgemeine Syntax von chroot <\/strong>lautet folgendermaßen:<\/p>\n

chroot [Wurzelverzeichnis] [Befehl [Argument(e)]]\n<\/p>

Während die Angabe eines Wurzelverzeichnisses notwendig ist, ist die Übergabe eines auszuführenden Befehls optional. Bei Ausführung von chroot <\/strong>ohne einen Befehl, wird eine interaktive Shell mit dem spezifizierten Wurzelverzeichnis gestartet. Es ist zu beachten, dass für die Nutzung von chroot<\/strong> standardmäßig root-Berechtigungen<\/strong> erforderlich sind.<\/p>\n

Optionen werden in den meisten Anwendungsfällen von chroot <\/strong>nicht benötigt. Wenn Sie jedoch näheres zum Befehl und seinen Optionen erfahren möchten, dann lesen Sie auch unseren Beitrag chroot<\/strong><\/a>.<\/p>\n

Speichermedien und Partitionen anzeigen<\/h3>\n

Informationen zu den am System angeschlossenen Speichermedien und Partitionen können mithilfe des Befehls blkid <\/strong>abgerufen werden. Auszulesen sind so etwa die Gerätedatei, die UUID, der Name und der Dateisystemtyp. Nützlich ist der Befehl beispielsweise zur Ermittlung des Gerätedateinamens einer Partition, wenn diese mit dem Befehl mount<\/a> eingehängt werden soll. Die Auflistung aller angeschlossenen Geräte ist durch Aufruf des Befehls ohne jegliche Argumente möglich:<\/p>\n

blkid<\/p>\n

Alternativ kann auch eine Gerätedatei übergeben werden, um Informationen nur für ein bestimmtes Gerät auszugeben:<\/p>\n

blkid [Gerätedatei]\n<\/p>

Der Befehl bietet auch eine Reihe an Optionen an, um die Ausgabe weiter zu beeinflussen. Nähere Informationen zum Befehl sowie einigen der wichtigsten dieser Optionen finden Sie in unserem Beitrag blkid<\/strong><\/a>.<\/p>\n

Netzwerke<\/h2>\n

Konfiguration und Statistiken<\/h3>\n

In diesem Abschnitt lernen Sie einige der wichtigsten Befehle für die Konfiguration von Netzwerken sowie für die Ausgabe relevanter Informationen bezüglich Erreichbarkeit etc. kennen.<\/p>\n

ip – Befehl für die Netzwerkkonfiguration<\/h4>\n

Der Befehl ip <\/strong>ist Teil des Pakets iproute2 <\/strong>und ersetzt den ifconfig<\/strong>-Befehl der net-tools<\/strong>.<\/p>\n

ip [Optionen]\n<\/p>

Der Befehl kann mit vielen verschiedenen Optionen ausgeführt werden, um Netzwerkschnittstellen <\/strong>abzufragen <\/strong>oder zu konfigurieren<\/strong>.<\/p>\n

Mit der Option link<\/strong> ist es möglich, den Status aller Schnittstellen<\/strong> abzufragen:<\/p>\n

ip link<\/p>\n

Wollen Sie den Status der Schnittstellen<\/strong> genauso abfragen, wie dies mit ifconfig <\/strong>möglich war, fügen Sie einfach die Option -s<\/strong> zusätzlich mit an:<\/p>\n

ip -s link<\/p>\n

Weiterhin können mit link <\/strong>Einstellungen <\/strong>auf Ethernet-Ebene<\/strong> geändert werden. Mit dem folgenden Befehl können Sie die MAC-Adresse ändern<\/strong>:<\/p>\n

ip link set dev [Gerät] address [MAC-Adresse]\n<\/p>

Außerdem können Sie eine Schnittstelle <\/strong>aktivieren (up) <\/strong>bzw. deaktivieren (down)<\/strong>:<\/p>\n

ip link set [up\/down] [Gerät]\n<\/p>

Mit der Option addr<\/strong> können Sie alle verfügbaren Netzwerkschnittstellen <\/strong>mitsamt ihrer IP-Adressen<\/strong>abfragen<\/strong>, anzeigen und neue IP-Adressen hinzufügen<\/strong>. Mit addr show<\/strong> werden Ihnen die Daten übersichtlich ausgegeben:<\/p>\n

ip addr show<\/p>\n

Zudem können Sie mit addr add<\/strong> IP-Adressen zuweisen<\/strong>:<\/p>\n

ip addr add [IP-Adresse] dev [Gerät]\n<\/p>

Mit del<\/strong> können Sie eine IP-Adresse wieder entfernen<\/strong>:<\/p>\n

ip addr del [IP-Adresse] dev [Gerät]\n<\/p>

ping – Erreichbarkeit überprüfen<\/h4>\n

Mit dem Befehl ping <\/strong>können Sie die Erreichbarkeit <\/strong>einer Netzwerkschnittstelle überprüfen. Die Syntax lautet:<\/p>\n

ping [Optionen] [Adresse]\n<\/p>

Der Befehl sendet bei Ausführung Anfragen an die “angepingte” Netzwerkschnittstelle, welche diese bei Eingang beantwortet. Mit der Tastenkombination [Ctrl+c]<\/strong> können Sie die Ausführung des Befehls wieder beenden.<\/p>\n

nslookup – DNS-Abfragen durchführen<\/h4>\n

Der Befehl nslookup <\/strong>wird verwendet, um DNS-Abfragen<\/strong> durchzuführen. Das Werkzeug ist nicht unter allen Linux-Distributionen standardmäßig vorinstalliert. Unter Debian erfolgt die Installation<\/strong> des hierfür benötigten Pakets “dnsutils”<\/strong> folgendermaßen:<\/p>\n

apt-get install dnsutils<\/p>\n

nslookup <\/strong>kann sowohl in einem interaktiven<\/strong>, als auch in einem nicht-interaktiven Modus<\/strong> verwendet werden. Im Folgenden wird der nicht-interaktive Modus<\/strong> eingesetzt:<\/p>\n

Zum Auflösen der IP-Adresse eines Domainnamen<\/strong> wird der folgende Befehl verwendet:<\/p>\n

nslookup [Domainname]\n<\/p>

Eine sogenannte Reverse-Lookup-Abfrage<\/strong> ist dagegen durch Angabe einer IP-Adresse<\/strong> möglich:<\/p>\n

nslookup [IP-Adresse]\n<\/p>

Der MX-Eintrag<\/strong> einer Domain wird durch Hinzufügen der Option -query<\/strong> mit dem Parameter “mx”<\/strong> ausgegeben. Analog können auch der NS-Eintrag (“ns”)<\/strong>, der SOA-Eintrag (“soa”)<\/strong>, oder alle Informationen<\/strong> zu einer Domain (“any”)<\/strong> angezeigt werden.<\/p>\n

nslookup -query=mx [Domainname]\n<\/p>

nslookup -query=ns [Domainname]\n<\/p>

nslookup -query=soa [Domainname]\n<\/p>

nslookup -query=any [Domainname]\n<\/p>

traceroute – Datenpaket verfolgen<\/h4>\n

traceroute <\/strong>ermöglicht Ihnen die Nachverfolgung eines Datenpakets<\/strong> auf allen seinen Zwischenstationen. Dazu werden kleine Datenpakete an den gewünschten Host gesendet. Die Syntax des Befehls lautet folgendermaßen:<\/p>\n

traceroute [Optionen] [Adresse]\n<\/p>

Optionen werden nicht benötigt.<\/p>\n

ss – Socket Statistiken anzeigen<\/h4>\n

Mit ss <\/strong>können Sie Statistiken zu PACKET<\/strong>-, TCP<\/a><\/strong>-, UDP<\/a><\/strong>-, DCCP<\/strong>-, RAW<\/strong>– und Unix-Domain-Sockets<\/strong> anzeigen:<\/p>\n

ss [Optionen]\n<\/p>

Die verschiedenen verfügbaren Optionen dienen der Anzeige diverser Informationen. Die Option -l<\/strong> (l<\/strong>istening) wird beispielsweise verwendet, um nur “horchende” Sockets<\/strong> anzuzeigen:<\/p>\n

ss -l<\/p>\n

Die Option -t (T<\/strong>CP) zeigt alle TCP Verbindungen<\/strong> an:<\/p>\n

ss -t<\/p>\n

-u<\/strong> (U<\/strong>DP) zeigt ausschließlich UDP Verbindungen<\/strong> an:<\/p>\n

ss -u<\/p>\n

Schließlich werden mit der Option -x<\/strong> (UNIX<\/strong>) nur UNIX Verbindungen<\/strong> angezeigt:<\/p>\n

ss -x<\/p>\n

Weitere Informationen finden Sie auf unserem Beitrag Die wichtigsten Netzwerkbefehle für Anfänger<\/a>.<\/p>\n

SSH<\/h3>\n

Der in diesem Abschnitt beschriebene Befehl ssh<\/a> <\/strong>kann auf fast allen Linux-\/UNIX-Betriebssystemen für den sicheren Zugriff auf einen SSH-Server oder ein Remote-System eingesetzt werden. Der Befehl wird für die Anmeldung sowie die Ausführung von Befehlen verwendet.<\/p>\n

Login<\/h4>\n

Der Login, welcher zum Verbindungsaufbau mit einer Remote-Maschine erforderlich ist, erfolgt zunächst ganz einfach durch Eingabe des Befehls ssh <\/strong>mit der Adresse des jeweiligen Systems:<\/p>\n

ssh [Adresse]\n<\/p>

Wenn Sie bei der Anmeldung einen Benutzer <\/strong>spezifizieren <\/strong>möchten, dann können Sie den Benutzernamen <\/strong>einfach als Präfix <\/strong>und durch ein ‘@’<\/strong> von der Adresse getrennt anhängen:<\/p>\n

ssh [Benutzer]@[Adresse]\n<\/p>

Auch die Verwendung der Option -l<\/strong> ist hier möglich:<\/p>\n

ssh -l [Benutzer] [Adresse]\n<\/p>

Es ist zu beachten, dass bei dem ersten Verbindungsaufbau zu einem SSH Server<\/strong> eine besondere Abfrage stattfindet, bei welcher der Server <\/strong>und ein sogenannter Host-Schlüssel<\/strong> von Ihnen bestätigt werden müssen. Beides wird nach Ihrer Bestätigung in eine Liste bekannter <\/strong>Hosts <\/strong>unter “~\/.ssh\/known_hosts”<\/strong> abgelegt. Aus diesem Grund müssen Sie diese Bestätigung auch nur bei dem ersten Verbindungsaufbau<\/strong> durchführen – wird der Schlüssel ein weiteres Mal abgefragt, sollten Sie sicher sein, dass der Schlüssel serverseitig entsprechend geändert wurde. <\/p>\n

Befehle ausführen<\/h4>\n

Wenn Sie einen Befehl <\/strong>auf einer Remote-Maschine ausführen möchten, können Sie diesen auch direkt dem ssh <\/strong>Befehl übergeben:<\/p>\n

ssh [Adresse] [Befehl]\n<\/p>

Bei einer solchen Verwendung des ssh <\/strong>Befehls wird nach der Authentifizierung<\/a> <\/strong>lediglich der Befehl <\/strong>auf der Remote-Maschine ausgeführt und die Ausgaben in der lokalen Befehlszeile<\/strong> ausgegeben. Im Anschluss bleibt der Nutzer nicht angemeldet – die SSH-Sitzung<\/strong> wird stattdessen sofort nach Befehlsausführung beendet<\/strong>.<\/p>\n

Mehr Informationen zu diesem Befehl finden Sie auf unserem Beitrag ssh<\/strong><\/a>.<\/p>\n

SCP<\/h3>\n

Der Befehl scp<\/a> <\/strong>kann auf Linux-\/UNIX-Betriebssystemen verwendet, um Dateien über eine sichere, verschlüsselte Netzwerkverbindung zu kopieren. Neben einem SCP-Client<\/strong> ist dazu – ähnlich wie bei SSH <\/strong>– auch ein entsprechender Server <\/strong>notwendig.<\/p>\n

Dateien kopieren<\/h4>\n

Zum Kopieren von Dateien<\/strong> mit dem Befehl scp <\/strong>wird grundsätzlich die folgende Syntax verwendet:<\/p>\n

scp [Optionen] [Pfad Quelle] [Pfad Ziel]\n<\/p>

Bei den Pfadangaben <\/strong>sind im Falle lokaler Pfade<\/strong> keine Besonderheiten zu beachten. Lediglich bei Pfadangaben <\/strong>auf Remote-Maschinen<\/strong> muss eine spezielle Syntax berücksichtigt werden. Der jeweilige Hostname <\/strong>wird durch einen Doppelpunkt ‘:’<\/strong> getrennt links an den Pfad angehängt. Die Angabe eines Benutzernamen <\/strong>ist optional <\/strong>ebenfalls möglich, indem dieser mit einem ‘@’<\/strong> getrennt links an den Hostnamen <\/strong>angehängt wird. SCP ermöglicht zudem auch das Kopieren zwischen zwei Remote-Hosts. Die resultierende Syntax lautet:<\/p>\n

scp [Optionen] [Benutzer]@[Host 1]:[Pfad] [Benutzer]@[Host 2]:[Pfad]\n<\/p>

Im Folgenden werden einige wichtige Optionen des Befehls scp <\/strong>kurz beschrieben.<\/p>\n

-3 – Lokaler Rechner als Zwischenstation<\/h4>\n

Mit der Option -3<\/strong> wird die Standardeinstellung, dass Daten beim Kopieren zwischen zwei Hosts<\/strong>direkt <\/strong>zwischen diesen versendet werden, überschrieben. Der Kopiervorgang findet somit über den lokalen Rechner<\/strong> statt.<\/p>\n

scp -3 [Benutzer]@[Host 1]:[Pfad] [Benutzer]@[Host 2]:[Pfad]\n<\/p>

-l – Bandbreite limitieren<\/h4>\n

Die Bandbreite <\/strong>einer Datenübertragung mit dem Befehl scp <\/strong>kann mithilfe der Option -l<\/strong> limitiert werden. Die Angabe erfolgt in KBit\/s<\/strong>:<\/p>\n

scp -l [Benutzer]@[Host 1]:[Pfad] [Benutzer]@[Host 2]:[Pfad]\n<\/p>

-P – Port festlegen<\/h4>\n

Der verwendete Port, welcher bei scp <\/strong>standardmäßig Port <\/strong>22 <\/strong>ist, kann mit der Option -P<\/strong> beliebig spezifiziert werden:<\/p>\n

scp -P [Portnummer] [Benutzer]@[Host 1]:[Pfad] [Benutzer]@[Host 2]:[Pfad]\n<\/p>

-r – Verzeichnisse rekursiv kopieren<\/h4>\n

Zum rekursiven Kopieren<\/strong> von Verzeichnissen, verwenden Sie die Option -r<\/strong>:<\/p>\n

scp -r [Benutzer]@[Host 1]:[Pfad] [Benutzer]@[Host 2]:[Pfad]\n<\/p>

-v – Debugging<\/h4>\n

Die Option -v<\/strong> kann schließlich bei der Fehlerbehebung <\/strong>helfen – sie sorgt dafür, dass jegliche auftretende Debugging-Nachrichten<\/strong> in die Ausgabe <\/strong>geschrieben werden:<\/p>\n

scp -v [Benutzer]@[Host 1]:[Pfad] [Benutzer]@[Host 2]:[Pfad]\n<\/p>

Weitere Informationen, wie Sie beispielsweise den scp-Server installieren können, finden Sie auf unserem Beitrag scp<\/strong><\/a>.<\/p>\n

FTP- \/ HTTP-Download<\/h3>\n

Für den Download von Dateien<\/strong> direkt von FTP-<\/strong> oder HTTP <\/strong>bzw. HTTPS-Servern<\/strong> wird Ihnen in diesem Abschnitt der Befehl wget <\/strong>vorgestellt. Der Befehl kann neben der einfachen Verwendung als Downloadmanager auch in Shell-Skripten verwendet, oder ohne Benutzerinteraktion im Hintergrund ausgeführt werden.<\/p>\n

Die allgemeine Syntax für das Herunterladen von Dateien lautet folgendermaßen:<\/p>\n

wget [Optionen] [URL(s)]\n<\/p>

Wird der Befehl ohne zusätzliche Optionen verwendet, so werden die angegebenen URLs heruntergeladen und im aktuellen Arbeitsverzeichnis abgelegt.<\/p>\n

Einige wichtige Optionen werden im Folgenden kurz vorgestellt.<\/p>\n

-t – Anzahl Versuche spezifizieren<\/h4>\n

Kommt es während des Herunterladens zu Verbindungsabbrüchen<\/strong>, versucht wget <\/strong>standardmäßig bis zu 20<\/strong> Mal, die Verbindung wiederherzustellen. Wird diese maximale Anzahl der Versuche überschritten, so wird der Vorgang abgebrochen.<\/p>\n

Mit der Option -t<\/strong> können Sie genau festlegen, wie oft wget <\/strong>versuchen soll, die Verbindung wiederherzustellen:<\/p>\n

wget -t [Anzahl Versuche] [URL(s)]\n<\/p>

-c – Download fortsetzen<\/h4>\n

Wurde ein Download aus jeglichen Gründen abgebrochen<\/strong>, und sind die lokalen Dateien<\/strong> des ersten Vorgangs sind noch auf dem Dateisystem vorhanden, so kann der Download <\/strong>mit der Option -c<\/strong>fortgesetzt <\/strong>werden:<\/p>\n

wget -c [URL(s)]\n<\/p>

-i – URLs aus Datei auslesen<\/h4>\n

Neben der direkten Eingabe von URLs als Befehlsparameter unterstützt wget <\/strong>auch das Auslesen von URLs<\/strong> aus einer lokalen <\/strong>oder externen <\/strong>Datei<\/strong>:<\/p>\n

wget -i [Dateipfad] [URL(s)]\n<\/p>

Die URLs werden in der Datei untereinander aufgelistet, sodass für jede URL eine Zeile<\/strong> verwendet wird. Der Option kann auch der Parameter “-“<\/strong> übergeben werden, um die URLs aus dem Standard-Input<\/strong> (stdin) zu lesen. Die Angabe von URLs direkt in der Befehlszeile ist gleichzeitig möglich – in diesem Fall werden zunächst die URLs der Befehlszeile und anschließend die in der übergebenen Datei befindlichen URLs heruntergeladen.<\/p>\n

-O – Ausgabedatei spezifizieren<\/h4>\n

Bei Angabe einer Ausgabedatei <\/strong>mithilfe der Option -O<\/strong> werden die Inhalte der heruntergeladenen Dateien miteinander konkateniert<\/a> <\/strong>und anschließend in eine gemeinsame Datei<\/strong> mit dem von Ihnen festgelegten Namen\/Pfad<\/strong> geschrieben:<\/p>\n

wget -O [Dateipfad] [URLs]\n<\/p>

Durch Angabe des Parameters “-“<\/strong> ist es möglich, die Inhalte im Standard-Output<\/strong> (stdout) auszugeben.<\/p>\n

-P – Ausgabeverzeichnis spezifizieren<\/h4>\n

Mithilfe der Option -P<\/strong> lässt sich das Verzeichnis-Präfix<\/strong> auf den angegebenen Pfad <\/strong>festlegen, um alle heruntergeladenen Dateien unter diesem abzulegen.<\/p>\n

wget -P [Verzeichnispfad] [URLs]\n<\/p>

Der Standardwert “.”<\/strong> gibt das aktuelle <\/strong>Arbeitsverzeichnis <\/strong>an.<\/p>\n

-b – Hintergrundausführung<\/h4>\n

Schließlich kann wget <\/strong>mithilfe der Option -b<\/strong> im Hintergrund <\/strong>ausgeführt werden. Nach Ausführung wird die Befehlszeile wieder freigegeben und die Ausführung anderer Aufgaben ist möglich. Alle erzeugten Ausgaben <\/strong>werden in die sogenannte wget-Log<\/strong>umgeleitet<\/strong>.<\/p>\n

wget -b [URL(s)]\n<\/p>

Mehr Informationen zu diesem Befehl finden Sie auf unserem Beitrag wget<\/strong><\/a>.<\/p>\n

Rsync<\/h3>\n

Der Befehl rsync<\/strong>, welcher zum Kopieren von Dateien dient, wird in diesem Abschnitt für einen kleinen Überblick vorgestellt. Ein Kopiervorgang ist sowohl lokal, als auch auf ein anderes System bzw. von einem anderen System möglich. Besonderheit des Befehls ist sein Delta-Transfer-Algorithmus, welcher nur die Unterschiede zwischen Quelldateien und vorhandenen Zieldateien überträgt – der Befehl ist damit gut für “Backups” und “Spiegelungen” geeignet. Die allgemeine Syntax des Befehls lautet folgendermaßen:<\/p>\n

rsync [Optionen] [Quell-Verzeichnis(se)] [Ziel-Verzeichnis]\n<\/p>

Wird nur ein Parameter ohne Optionen übergeben, also nur das Ziel-Verzeichnis, dann wird das aktuelle Arbeitsverzeichnis als Quellverzeichnis verwendet. Meist wird rsync <\/strong>zumindest zusammen mit der Option -a<\/strong> verwendet, um unter anderem Rechte und Eigentümer der Quelldateien zu übernehmen. Letztlich fasst die Option mehrere Einzeloptionen zusammen (-r, -l, -p, -t, -g, -o, -D)<\/strong>:<\/p>\n

rsync -a [Quell-Verzeichnis(se)] [Ziel-Verzeichnis]\n<\/p>

Sollen Dateien übersprungen werden, die in der Quelle neuer sind als im Ziel, so muss die Option -u<\/strong> spezifiziert werden:<\/p>\n

rsync -u [Quell-Verzeichnis(se)] [Ziel-Verzeichnis]\n<\/p>

Wenn Sie möchten, dass Dateien im Ziel gelöscht werden, nachdem diese in der Quelle gelöscht wurden, dann verwenden Sie zusätzlich die Option –delete<\/strong>:<\/p>\n

rsync –delete [Quell-Verzeichnis(se)] [Ziel-Verzeichnis]\n<\/p>

Wie Sie die Vielseitigkeit dieses Befehls als Kopierwerkzeug nutzen können, erfahren Sie in unserem Beitrag rsync<\/strong><\/a>.<\/p>\n

Routing-Tabelle verwalten<\/h3>\n

Dieser Abschnitt stellt den Befehl route <\/strong>für die Anzeige und Bearbeitung der Routing-Tabelle unter Linux \/ UNIX kurz vor. Der Befehl ist Teil des Pakets net-tools<\/strong>, welches nicht auf allen Linux- \/ UNIX-Betriebssystemen standardmäßig installiert ist, und muss daher gegebenenfalls nachinstalliert werden. Folgender Befehl zeigt die Installation des Pakets mit apt<\/strong>:<\/p>\n

apt-get install net-tools<\/p>\n

Routing-Tabelle anzeigen<\/h4>\n

Die Anzeige der Routing-Tabelle erfolgt durch Ausführung des Befehls route ohne jegliche Optionen und Parameter. Die ausgegebene Routing-Tabelle hat dann die Spalten Ziel (Destination)<\/strong>, Router (Gateway)<\/strong>, Genmask<\/strong>, Flags<\/strong>, Metric<\/strong>, Ref<\/strong>, Use <\/strong>und Iface<\/strong>.<\/p>\n

route<\/p>\n

Alternativ kann auch die Option -n<\/strong> angefügt werden, wenn die Auflösung von IP-Adressen in symbolische Hostnamen deaktiviert werden soll:<\/p>\n

route -n<\/p>\n

Routing-Tabelle bearbeiten<\/h4>\n

Die Bearbeitung der Routing-Tabelle erfolgt mit “route add”<\/strong> und “route del”<\/strong>.<\/p>\n

Im Folgenden ist zunächst die Syntax von “route add”<\/strong> gezeigt. Es müssen das Ziel, eine Netzmaske sowie die Adresse des Routers (Gateway), über den das Ziel erreicht werden soll, angegeben werden. Je nachdem ob es sich bei dem Ziel um einen einzelnen Rechner handelt, oder ein ganzes Netzwerk, wird zudem eine der beiden Optionen -host<\/strong> (Einzelner Rechner) bzw. -net<\/strong> (Ganzes Netzwerk) gewählt.<\/p>\n

route add -[host|net] [Ziel] netmask [Netzmaske] gw [Gateway]\n<\/p>

Soll ein Eintrag aus der Routing-Tabelle gelöscht werden, so ist die Syntax sehr ähnlich. Lediglich “add”<\/strong> wird nun zu “del”<\/strong>. Für die Parameter werden jeweils die Werte des zu löschenden Eintrags verwendet:<\/p>\n

route del -[host|net] [Ziel] netmask [Netzmaske] gw [Gateway]\n<\/p>

Weitere Informationen zu diesem Befehl finden Sie in unserem Beitrag route<\/strong><\/a>.<\/p>\n

Linux Befehle PDF downloaden<\/h2>\n","protected":false},"excerpt":{"rendered":"

Viele allt\u00e4gliche Aufgaben lassen sich unter UNIX- bzw. Linux- Betriebssystemen mithilfe von verschiedenen Befehlen schnell und einfach erledigen – Der sichere Umgang mit dem Terminal ist daher eine besonders wichtige F\u00e4higkeit f\u00fcr jeden Linux-\/UNIX-Benutzer.   In diesem Beitrag werden Sie einen umfassenden \u00dcberblick zu den wichtigsten dieser Befehle f\u00fcr UNIX \/ Linux erhalten. Die hier […]<\/p>\n","protected":false},"author":2,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"narrow-page.php","meta":{"_seopress_robots_primary_cat":"","_seopress_titles_title":" %%post_title%% %%sep%% %%sitetitle%%","_seopress_titles_desc":"Linux Befehle in EINEM (PDF) - das w\u00e4re doch super! Ein umfassender \u00dcberblick zu wichtigen Befehlen f\u00fcr Linux und UNIX. Erhalten Sie unsere Linux Befehle PDF!!!","_seopress_robots_index":"","footnotes":""},"class_list":["post-14006","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/pages\/14006","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/comments?post=14006"}],"version-history":[{"count":102,"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/pages\/14006\/revisions"}],"predecessor-version":[{"id":14687,"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/pages\/14006\/revisions\/14687"}],"wp:attachment":[{"href":"https:\/\/profi-tutorials.de\/linux\/wp-json\/wp\/v2\/media?parent=14006"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}