Inhalt
Vorwort
Wozu das Ganze?
Die unterschiedlichen Shells
Nützliche Tipps und Tricks
Aufbau der Befehle
Einige Befehle in der Anwendung- Dateien und Ordner
- Wildcards
- Ausgabe umleiten
- Pipes
- Rechte
- Archivieren und Komprimieren
- Benutzer
- Systemüberwachung
- Paketverwaltung
- Software selbst kompilieren
- Suchen & finden
- Zusammenfassung
Vorwort
Dieses Tutorial erhebt keinen Anspruch auf Vollständigkeit, noch darauf, dass ihr danach ein Shellprofi seid. Es soll lediglich eine kleine Einführung sein um gerade umsteigern auf Linux ein Gefühl für die Shell zu vermitteln.
Trotzdem bin ich natürlich für (konstruktive) Kritik offen
.
Wozu das Ganze?
Sicherlich hat die Shell auf Desktoprechnern seit der Einführung der grafischen Desktop-Umgebungen wie Gnome und KDE (um nur mal die zwei bekanntesten zu nennen) an Bedeutung verloren, doch wer einen Server administrieren möchte, kommt um die Shell kaum rum. Aber auch auf dem Dekstop bietet die Shell doch einiges an Zeitersparnis im Vergleich zur grafischen Lösung. So ist zum Beispiel ein Prozess aus der Shell heraus schneller beendet als durch den Systemmonitor.
Die unterschiedlichen Shells
Im laufe der Zeit gab es einige Shellentwicklungen für unterschiedliche Systeme, da wir von einem GNU/Linux System ausgehen sind für uns aber nur bash und sh wichtig.
Nützliche Tipps und Tricks
Einige kleine Befehle und Tastenkürzel erleichtern die tägliche Arbeit mit der Shell:
$ Strg+D ausloggen
$ Strg+Umschalt+T Neuen Tab im Terminal öffnen
$ Pfeiltasten hoch/runter History durchblättern
$ Tab Auto vervollständigen
$ su <Benutzer> Benutzer wechseln, gebt ihr keinen an werdet ihr root.
$ who Zeigt euch wer eingeloggt ist.
$ uptime Zeigt wie lange das System läuft, sowie durchschnittliche Auslastung.
$ man Gibt euch die Hanbuchseite zum Befehl aus. (Sehr ausführlich)
$--help Zeigt euch die zur Verfügung stehenden Parameter an.
Linktipp:
[
Link nur für registrierte Mitglieder sichtbar. Bitte einloggen oder neu registrieren ]
Aufbau der Befehle
Ein Shellbefehl ist grundsätzlich so aufgebaut:
'Befehl' -'Parameter'
Als konkretes Beispiel:
(ls listet euch den Verzeichnisinhalt auf, der Parameter a listet auch versteckte Dateien auf und l erzeugt eine detailiertere Anzeige (Liste mit Dateigröge, Dateiberechtigungen usw.)).
Sucht ihr nach einer Erklärung zur Syntax eines Befehls, was der Befehl überhaupt macht oder welche Parameter ihr zur Auswahl habt, können die manpages (englisch für Handbuchseiten) eine große Hilfe sein. Um euch eine manpage anzeigen zu lassen tippt ihr in den Terminal man 'Befehl', um bei unserem Beispiel zu bleiben also
man ls .
Einige Befehle in der Anwendung
In diesem Abschnitt werdet ihr einige Befehle kennenlernen, Grundsätzlich habt ihr am Anfang eine Auflistung aller befehle mit einer kurzen Beschreibung was der Befehl macht.
Dateien und Ordnern
$ cd [pfad] (..)
Mit cd wechseln wir in ein Verzeichnis (mit .. in das darüber liegende), wer schonmal mit DOS gearbeitet hat wird den Befehl kennen.
$ mkdir <Verzeichnis>
Erzeugt ein Verzeichnis.
$ rm (-r) [pfad]
rm löscht eine Datei mit der erweiterung -r können wir Verzeichnisse löschen.
$ cp [Quelle] [Ziel]
Kopiert eine Datei.
$ mv [Quelle] [Ziel]
Verschiebt eine Datei.
$ tail [Datei]
Zeigt uns den Inhalt einer Datei an.
Beispiel:
Wir haben zwei Dateien namens test.txt und test1.txt auf unserem Desktop und wollen diese zum Beispiel in den Ordner test auf unseren Desktop verschieben bzw kopieren und danach die Dateien und den Ordner wieder löschen.
Dazu wechseln wir mit:
auf den Desktop. ~/ steht für den Ordner des Benutzers im /home verzeichnis.
Jetzt kopieren wir unsere Datei mit:
in unseren Ordner test.
Hier seht ihr auch gleichzeitig die Syntax des cp Befehls: cp <Quelldatei> <Zielverzeichnis>
Jetzt wollen wir unsere Datei test1.txt in den Ordner test verschieben.
Danach wechseln wir mit cd in den Ordner test.
Jetzt wollen wir unsere beiden Dateien löschen. Dazu verwenden wir:
Code:
rm test.txt test1.txt
Jetzt wollen wir schließlich noch unseren Ordner löschen dazu wechseln wir mit:
In das darüber liegende Verzeichnis, also auf den Desktop und löschen schließlich mit:
Wildcards
Wildcards (auf Deutsch Joker) sind im Grunde Platzhalter. Wenn wir uns zum Beispiel alle .txt Dateien anzeigen lassen wollen, verwenden wir den ls Befehl aber ersetzen den Dateinamen durch eine Wildcard:
Damit bekommen wir alle .txt Dateien angezeigt.
Wir können uns mit Wildcards auch Dateien mit unterschiedlichen Endungen anzeigen lassen, wenn wir zum Beispiel alle .txt und .jpg Dateien sehen wollen verwenden wir:
Ausgabe umleiten
$[Befehl> > [Datei]
Ausgabe von [Befehl] in [Datei] umleiten.
Wenn wir uns zum Beispiel eine Datei erstellen wollen, welche unsere komplette Musiksammlung auflistet haben wir mit der Ausgabeumleitung ein praktisches Werkzeug:
Code:
ls *.mp3 > musik.txt
Damit wird die Ausgabe nicht wie sonst auf dem Bildschirm erzeugt sondern direkt in die Datei musik.txt geschrieben.
Analo dazu gibt es auch die Eingabe Umleitung die dann mit < funktioniert. Dafür gibt es allerdings sehr wenige Anwendungsfälle.
Pipes
Pipes sind auch eine Form der Ausgabeumleitung allerdings ist diese nicht wie > auf eine Datei beschränkt sondern wir können die ausgabe eines Befehls an einen anderen weiterleiten.. Wenn wir zum Beispiel die Version des Messengers Pidgin checken wollen:
Code:
rpm -qa | grep pidgin
Mit rpm -qa würden wir normalerweise alle Installierten Pakete angezeigt bekommen allerdings übergeben wir die Ausgabe mittels der Pipe | an den befehl grep, dieser filtert uns dann die Pakete raus in denen das Wort pidgin vorkommt.
Rechte
$ chown [benutzer:gruppe] [Datei]
Ändert den Besitzer einer Datei
$ chmod
Ändert die Zugriffsrechte von bestimmten Usern/Gruppen/allen andere
Auf Linux Systemen haben Dateien Rechte und Besitzer, also gibt es auch Befehle um diese zu ändern, wir gehen mal wieder von einer Datei namens test.txt aus:
Zunächst setzen wir mit:
Code:
chown test:test test.txt
den Benutzer test, der sich in der Gruppe test befindet als Besitzer der Datei test.txt fest. Jetzt geben wir der Gruppe mit:
Schreibrechte. Das g steht in diesem Fall für group, wir können es aber auch durch ein u für user oder o für owner ersetzen je nach dem wem wir welche Rechte geben wollen. Generell fügt ein + Rechte hinzu und ein - entfernt diese dann wieder.
w steht dabei für write (schreiben), r für read (lesen), x für execude (ausführen).
chmod könnt ihr für jede Datei benutzen, deren Besitzer ihr seid. Nur root kann chmod auf alle Dateien ausführen.
Rechte lassen sich auch über Zahlenkombinationen setzen.
Um das zu verstehen schauen wir uns erstmal die Rechte einer Datei an, indem wir uns den Verzeichnisinhalt indem sich die Datei befindet mittels ls -a (wir erinniern uns) anzeigen lassen.
rw-r--r--. 1 root root 246 20. Nov 2004 a.gif
Teilen wir den 1. Teil in 3er Gruppen erhält man:
rw- r-- r--
Die 1. Gruppe steht für den Besitzer, die 2. für die Gruppe, die 3. für alle anderen.
Jetzt hat jeder Buchstabe einen eigenen Wert.
r (read) 4
w (write) 2
x (execute) 1
- (keine Berechtigung) 0
Daraus ergibt sich für die 1. Gruppe der Wert 6 für die 2.und 3. 4.
Also 644.
Also können wir mit chmod 644 <Datei> der Datei die oben genannten Rechte geben.
sudo
$ sudo <Option ><Befehl>
Sudo ermöglicht es euch einen Befehl als ein anderer Benutzer auszuführen, meistens wird sudo dafür genommen um einen Befehl als root auszuführen.
So könnt ihr aus eurem Terminal heraus zum Beispiel Systemdateien editieren.
Anmerkung:Auf die Optionen soll nicht weiter eingegangen werden, da ihre Anwendung weniger oft vorkommt. Die Optionen lassen sich der Manpage entnehmen.
Auf vielen Systeme ist euer Benutzer nicht von Anfang an als "Sudoer" eingetragen (Benutzer der einen Befehl als anderen Benutzer ausführen darf). Hier müsst ihr euch dann wie
oben beschrieben als root einloggen und mit dem Befehl visudo euren Benutzer unter der Zeile 'root ALL=(ALL) ALL' eintragen.
su
su <Option> (<Benutzer>) '<Befehl>'
Su ermöglicht es euch eine Shell als anderen Nutzer auszuführen, und kann deshalb auch zum Ausführen von Befehlen als root verwendet werden.
Dafür sieht der Befehl dann so aus:
Bzw als ein konkretes Beispiel:
Code:
su -c 'vi /etc/hosts'
Hier passiert folgendes: Wir teilen der Shell mit das wir ein Kommando in der Shell eines anderen Benutzers ausführen möchten (in diesem Fall root), Das Kommando steht danach in ' '. Der Benutzer wird in diesem Fall nicht benannt und ist damit automatisch root (vergleiche Benutzer wechsel). In diesem Fall würden wir im Editor vi die datei hosts in /etc öffnen.
Anmerkung: su hat natürlich noch weitaus mehrere Optionen aber auch diese werden eher seltener benötigt. Außerdem wird in den Securitymanuals vieler Distributionen geraten su zu deaktivieren, da es möglichen Angreifern ein nützliches Werkzeug in die Hand gibt, wie das im einzelnen geht ist der Dokumentation zu entehmen.
Archivieren und Komprimieren
$ tar cf
Erzeugt ein .tar Archiv
$ tar xf
Entpackt ein .tar Archiv
$ tar xzf
Entpackt ein .tar.gz Archiv
$ gzip
Komprimiert eine Datei (.tar ist für gzip eine Datei!)
$ gunzip
Dekomprimiert eine Datei
Das gängiste Format für Archivierung und Komprimierung dürfte wohl .tar.gz sein. tar archiviert unsere Dateien, das bedeutet es erhält die Dateirechte, Besitzer usw. und gz komprimiert unser Archiv.
Um ein solches Archiv aus der Datei test.txt zu erstellen verwenden wir den Befehl:
Code:
tar cf test.tar test.txt
Wer aufgepasst hat, hat eventuell bemerkt, das wir bei den Parametern cf nicht wie sonst üblich ein - brauchen!
Damit haben wir also das Archiv test.tar, jetzt wollen wir das Archiv noch komprimieren:
Damit erhalten wir das Format test.tar.gz .
Jetzt haben wir einmal die Möglichkeit das Archiv Schritt für Schritt auszupacken, dafür gehen wir von rechts nach links vor. Also entpacken wir es zunächst aus der .gz Komprimierung:
Damit haben wir Jetzt nur noch das Archiv test.tar, dieses können wir dann mit:
entpacken.
Natürlich gibt es auch die Möglichkeit das Komplette Archiv auf einmal zu entpacken:
Code:
tar xzf test.tar.gz
Benutzer
$ useradd [Benutzer]
Fügt einen Benutzer mit dem namen <Benutzer> hinzu
$ passwd [Benutzer]
Setzt das von uns eingegebene Passwort für <Benutzer>
$ userdel [Benutzer]
Löscht [Benutzer]
Auch benutzer lassen sich über die Shell anlegen. Um einen Neuen Benutzer zu erstellen benutzen wir:
Code:
useradd -mc "Test Test" test
Mit -m legen wir gleichzeitig das Homeverzeichnis für den User an, -c ermöglicht es uns einen Kommentar zum User test hinzuzufügen. Wollt ihr nur einen user anlegen reicht natürlich auch nur useradd.
Als nächstes erstellen wir ein Passwort für den user test:
Dann werden wir dazu aufgefordert das gewünschte Passwort für test einzugeben (Die eingabe wird euch nicht angezeigt, nichtmal in Form von Sternchen).
Und zum Schluss löschen wir test wieder:
Damit ist unser Benutzer test gelöscht, durch -r auch gleich sein Homeverzeichnis.
Analog dazu gibt es natürlich auch groupadd, usermod, groupdel, groupmod, newgrp und chsh.
Systemüberwachung
$df (-m)
Zeigt euch die Festplatten belegung in Blöcken ( -m in Megabyte) an.
$ps ax
Zeigt euch alle Laufenden Prozesse an. Die Erste Spalte ist die PID ID die ihr zusammen mit dem befehl kill benötigt.
$kill [PID ID]
Beendet den Prozess [PID ID]
$killall [Prozessname]
Beendet den Prozess [Prozessname]
$free
Zeigt euch die Arbeitsspeicher Belegung an.
Wollen wir also einen Amoklaufenden Prozess beenden lassen wir uns erstmal mit
die Prozesse auflisten und suchen uns die PID ID des Prozess‘. Jetzt können wir den Prozess mit:
wird hinter kill kein Parameter angegeben wird immer das signal SIGTERM an den Prozess gesendet, das entspricht einem Stop befehl. Wir können aber den Prozess auch mit Gewalt beenden:
Das sendet das Signal SIGKILL an den Prozess. Alle Signale könnt ihr euch mit:
anzeigen lassen.
Paketverwaltung
Hinter vielen Linuxdistributionen steht eine Paketquelle (Repository) aus welcher sich Software installieren lässt die Beiden weit verbreiteten Paketverwaltungssysteme sind DEB und RPM notwendig. Um diese zu verwenden gibt es YUM und u.a APT für diese gibt es mittlerweile auch grafische Lösungen, doch hier soll die Verwendung in der Shell beschrieben werden.
Bevor wir uns aber mit den einzelen Paketmanagersystemen beschäftigen, ist es gut zu wissen, das die beiden weit verbreiteten Paketformate .deb (Debian Pakete, installation mittels APT) und .rpm (von Red Heat entwickelt installation mittels YUM)
YUM
Geschichte:
Die Ursprüngliche Version von YUM stammt aus Yellow Dog Linux und hatte den namen YUP. YUP war aber sehr langsam da es immer alle Pakete herunterlud und nicht nur die Kopfzeilen der Pakete.
Seth Vidal schrieb deshalb eine neue Version von YUP und nannte diese yellowdog update modified, kurz YUM.
Heute wird YUM auf den Distributionen Red Hat, CentOS und Fedora eingesetzt, bzw auf darauf basierenden Distributionen.
Funktionsweise:
Die grundsätzliche Konfiguration wird in /etc/yum.conf vorgenommen, die Paketquellen sind in /etc/yum.repos.d/ enthalten. Als Quellen können HTTP- und FTP-Server sowie lokale CDs verwendet werden.
Wird yum aufgerufen werden zunächst die Kopfzeilen aller Pakete in den Paketquellen heruntergeladen. Diese Kopfzeilen enthalten zum Beispiel Abhängigkeiten, enthaltene Dateien und Version.
Als nächstes wird die eingegebene Option abgearbeitet zum Beispiel install danach wird in den Kopfzeilen nach dem Packet nach dem Kommando install gesucht zum Beispiel wird bei yum install emacs in den Kopfzeilen nach emacs (einem Texteditor) gesucht und die entsprechenden Pakete samt deren Abhängigkeiten herungergeladen.
Plugins:
YUM ist im gegensatz zu APT mit dem Plugin fastestmirror dazu in der Lage auf den schnellsten Server zuzugreifen und bei ausfall auf einen anderen Server zu wechseln.
Mit dem Plugin presto lassen sich sogenannte DeltaRPMs runterladen, diese sind im Grunde nur die Dateien die sich seit der Version des installierten Pakets geändert haben, daraus wird dann ein neues, aktuelles Paket erstellt, dies senkt die Menge der runterzuladenden Dateien erheblich.
Anwendung:
Die Verwendung von yum ist grundsätzlich:
$yum [Optionen] [Kommando] [Pakete ...]
Wichtige Befehle:
$yum install <Paket>
Suchst in den Kopfzeilen nach dem <Paket> und installiert das Paket. Paketnamen werden immer zusammen geschrieben, durch das Trennen der Paketnamen mit einer Leertaste können mehrere Pakete installiert werden.
$yum remove <Paket>
Löscht das <Paket>.
$yum localinstall <rpmdatei>
Hin und wieder auch mal ganz nützlich, wenn entwickler ihre Software als fertige Pakete anbieten und diese nicht in den Paketquellen sind, können die Pakete mit localinstall installiert werden.
$yum update / yum upgrade
Beide Befehle aktualisieren das System und machen solange ihr nichts anderes in die yum.conf eingetragen habt. Es wäre möglich mit update als "obsolet" gekennzeichnete Pakete zu behalten und mit upgrade diese zu entfernen und gegen vorgeschlagene Alternativen zu ersetzen.
$yum search <Suchbegriff>
Mit Search kann nach Paketen gesucht werden. So gibt zum Beispiel yum search editor eine Liste von Editoren in den Paketquellen aus.
APT
Allgemeines:
APT (Advanced Package Tool) ist ein Paketverwaltungssystem das im Berreich der Distribution Debian entstanden ist und auch in allen darauf basierenden Distributionen eingesetzt wird.
Funktionsweise:
Die grundsätzliche Konfiguration wird in /etc/apt/apt.conf vorgenommen, die Paketquellen werden unter /etc/apt/sources.list eingetragen.
Anwendung:
Die Verwendung von apt ist ähnlich der von yum:
$apt-get [Optionen] [Kommando] [Pakete ...]
Wichtige Befehle:
$apt-get install <Paket>
Installiert das <Paket>.
$apt-get remove <Paket>
Entfernt das <Paket>.
Im Unterschied zu YUM suchen wir mit APT ein Paket mit:
$apt-cache search <Suchbegriff>
Im Unterschied zu YUM können wir mit APT kein Paket lokal installieren, dafür brauchen wir dpkg mit der Option -i für install.
$dpkg -i <paket.deb>
$apt-get update
Liest die sources.list neu ein.
Anmerkungen: Es gibt natürlich noch weitere Paketmanger wie zum Beispiel OpenSuses YAST und Archs pacman. Auf diese soll hier aber nicht eingegangen werden, da diese weniger verbreitet sind als YUM und APT.
Software selbst kompilieren
Wie oben beschrieben gibt es für die meiste Software ein zur Distribution passendes Paket, anderereseits gibt es auch eine Menge Software, die es noch nicht in die Paketquellen geschafft hat, dies hängt unter anderem mit den (teilweise) strengen Richtlinien für Software die für eine Distribution zulässig sind oder auch mit den Aufglagen die ein Paket erfüllen muss, zusammen. Diese Richtlinen könnt ihr meistens der Dokumentation eurer Distribution entehmen.
Dieser Teil soll euch zeigen wie ihr Quellcode selbst kompilieren könnt.
Dazu kommt der "berühmte" Dreischritt zum Einsatz.
$./configure
$make
$sudo make Install
Nachdem die Software runtergeladen und entpackt (siehe oben) ist wechseln man mit dem berreits bekanntem cd befehl ins das entsprechende Verzeichnis.
Mit ./ führt man prinzipiell Dateien aus, in diesem Fall ist es das configures*****.
Schritt 1:
Das Configure S***** überprüft Abhängigkeiten, also zum Beispiel ob ein C Compiler wie gcc installiert ist.
Das S***** liefert als Output einige Fragen die jeweils mit yes/no beantwortet werden. Hier mal ein Beispiel für die Ausgabe eines configures*****s:
checking for memset... yes
checking for strtoul... yes
checking for gettimeofday... yes
checking for uint_t... no
checking for parallel device... /dev/parport0
checking for serial device... /dev/ttyS0
checking if gcc accepts -Wno-pointer-sign ... yes
configure: creating ./config.status
config.status: creating doc/Makefile
config.status: creating windows/Makefile
config.status: creating avrdude.spec
config.status: creating Makefile
config.status: creating avrdude.conf.tmp
config.status: creating ac_cfg.h
config.status: ac_cfg.h is unchanged
config.status: executing depfiles commands
Die entscheidende Zeile und auch gleichzeitig die wichtigste Aufgabe des configures*****s ist:
config.status: creating Makefile
Das configure s*****, schreibt, je nach dem wie die einzelnen Tests ausgingen, die notwendigen Schritte zur Installation der Software in das Makefile.
Schritt 2:
Make ist ein Tool welches wahrscheinlich auf allen Linuxsystemen Vorhanden ist, um den Befehl make auszuführen ist ein Makefile in dem Verzeichnis notwendig indem wir den make befehl ausführen.
Make verwendent die im makefile angegebenen Schritte die dazu notwendig sind die einzelnen Komponenten/Unterprogramme zu erstellen.
Grundsätzlich kompiliert make (~übersetzen des Quellcodes in für den Computer verständliche Maschinensprache) den Quellcode und erstellt die auführbaren Dateien. Aus dem make befehl entsteht u.a der Eintrag install im Makefile was wichtig für den nächsten Schritt ist.
Schritt 3:
make install
Wenn wir make mit der Ergänzung install aufrufen durchsucht make das Makefile nach dem Eintrag install. Darin ist enthalten, in welche Verzeichnise der kompilierte Code verschoben werden soll. Zum Beispiel werden die Auführbaren Dateien die der User selbst ausführt nach /usr/local/bin kopiert damit alle User des Systems die Software benutzen können.
Anmerkung: Dies stellt nur die grundsätzliche Vorgehensweise da, unter umständen muss z.B. Configure noch mit genaueren Parametern versorgt werden.
Suchen & finden
In der Shell lassen sich auch Programme Dateien und Informationen finden.
whereis
whereis durchsucht das System nach Binärdateien, Source und manpages für einen Befehl
Generell wird whereis so verwendet
$whereis [Option] [Befehl]
Optionen:
-b Sucht nur nach Binärdateien
-m Sucht nur nach Manpages
-s Sucht nur nach der Quelle
Ein praktisches Anwendungsbeispiel wäre, ihr wollt ein Pythonprogramm schreiben und kennt nicht den genauen Pfad der Python Installation. Also tippt ihr ein:
Output:
python: /usr/bin/python [...]
So wisst ihr, python befindet sich unter /usr/bin/python.
Anmerkung: in diesem Fall können wir die Suche mit -b eingrenzen da wir nur den Pfad der Binärdatei suchen.
apropos
"apropos" durchsucht eine Reihe von Datenbank-Dateien, unter anderem auch die Whatis-Datenbank, nach einem Begriff.
Im Gegensatz zu "find", stützt sich "apropos" bei der Suche auf fest vordefinierten Zielen, wie z.B. der Whatis-Datenbank.
Beispiel: Durch das Absetzen des Kommandos "apropos cups" werden die gesamten Elemente betreffend dem freien Drucksystem Cups angezeigt - alle Cups-relevanten Konfigurationsprogramme und .conf-Dateien inkl. kleiner Beschreibung
(Danke@haze303)
Zusammenfassung
Wir haben gelernt wie man einfache Administrationsaufgaben, Datei Operationen, Rechte Verwaltung, Archivierung, Systemüberwachung und die Softwareverwaltung in der Shell ausführen kann. Ich hoffe ich konnte dem ein oderen Anderen die „Angst“ vor der Shell nehmen und wünsche euch nochviel Spaß beim entdecken dieses mächtigen Tools.
Teil2
Im zweiten Teil des Shelltutorials werden wir uns mit den Texteditoren Nano und Vi, der Crontab und Shells*****en beschäftigen.
Auch hier bleibe ich wieder bei den einfachen Grundlagen, da man über die einzelnen Kapitel ganze Bücher schreiben könnte (bzw
es auch welche darüber gibt
).
Inhalt- Editoren
- -Nano
- -Vi
- Shells*****e
- -Vorwort
- -Schnittstelle
- -Shebang
- -S*****e ausführbar machen
- -S*****e automatisch aufrufen (Crontab)
- Grundelemente
- -Umleitung
- -Pipes
- -Variablen
- -Lokale Variablen
- -Datum und Zeit
- -Abfragen
- -Schleifen
- -Strings vergleichen und rechnen
- -Funktionen
Editoren
Bevor wir uns den Shells*****en zuwenden, werfen wir einen Blick auf zwei terminalbasierte Editoren, auf dem Desktopgibt es natürlich grafische Editoren und auch die Eclipse lässt sich mittels Plugin sogar zur Shell-IDE erweitern, allerdings hat man auf Systemen ohne Grafische Oberfläche logischerweise nur Terminaleditoren zur Verfügung deshalb (und weil die terminalbasierten, wenn man ihre Bedienung beherrschst, wesentlich mächtiger sind) ist es sinnvoll mit diesen umgehen zu können.
Die drei bekanntesten dürften Vi, Nano und Joe sein. Auf Vi und Nano werde ich im Folgenden eingehen.
Nano
Nano ist der von Einsteigern bevorzugte, weil einfachere Editor, aber vom Funktionsumfang her liegt er deutlich hinter Vi. Nano wird grundsätzlich mit dem Befehl nano <Pfad> aufgerufen, also z.B. nano /home/user/shells*****.sh . man nano bzw nano -h geben Auskunft über mögliche Parameter.
Ist Nano geöffnet werden unten die Wichtigsten Tastenkombinationen angezeigt, diese werden jeweils mit Strg+<Buchstabe> aufgerufen. Diese sind soweit eigentlich selbsterklärend.
Vi
Wenden wir uns nun dem Vi zu.
Grundsätzlich ist bei Vi folgendes zu bedeken:
Vi unterscheidet zwischen zwei unterschiedlichen Modi.
1.Commandmodus, hier habt ihr die Möglichkeite Befehle einzugeben um den Text zu bearbeiten, diese werden meistens durch Tastenkürzel eingegeben. Später werde ich noch Standartbefehle wie Kopieren einfügen löschen etc. auflisten.
2.Insertmodus, hier geht alles was ihr auf der Tastatur eingebt direkt in die Datei. Mit der Eingabe von :i gefolgt von Enter gelangt ihr in den Instertmodus.
Öffnen
Vi öffnen wir ähnlich wi Nano mit vi <Pfad>, auch hier geben -h und die Manpage weitere Infos über zusätzliche Parameter.
Schließen und Speichern
Um Vi zu verlassen muss man im Commandmodus sein, um in diesen zu wechseln drückt man Escape. Der Befehl um Vi zu schließen ist :q , sollte die Datei verändert worden sein wird Vi euch davor warenen, wollt ihr Vi trotzdem schließen lautet der Befehl :q! . Wenn ihr vor dem Schließen speichern wollt lautet der Befehl :wq . Natürlich lässt sich :w auch alleine verwenden, wollt ihr die Datei zum Beispiel unter einem anderen Namen speichern so wäre der Befehl :w <Dateiname> gefolgt von Enter.
Kommandos im Commandmodus eingeben
Wie Berreits oben beschrieben gibt es eine Vielzahl von Kommandos um in Vi Text zu bearbeiten. Die Struktur der Befehle in Vi ist folgende:
Code:
[Wiederholung] Befehle [Position]
Wiederholung gibt an wie oft ein Befehl ausgeführt wird, so würde der Befehl 4x 4 Buchstaben löschen. Position wird nur von manchen Befehlen verwedent, zum Beispiel zum Positionieren des Cursors.
Im Folgenden eine Auflistung der wichtigsten Befehle. Diese müssen wie oben beschrieben im Commandmodus eingegeben werden.
R -> Ersetzen ersetzt den Cursor mit den eingegebenen Buchstaben, die Eingabe der Buchstaben wird mit Escape beendetZeichen.
u -> Rückgängig machen, durch erneute Eingabe von u wird die Änderung rückgängig gemacht.
x -> löschen, durch [Widerholung] wird die Anzahl der zu löschenden Zeichen angegeben.
d^ -> schneidet, von der momentanen Cursorposition aus bis zum Anfang(!) der Zeile, aus.
d$ -> schneidet, von der momentanen Cursorposition aus bis zum Ende der Zeile, aus.
dw -> scheidet, von der momentanen Cursorposition aus bis zum Ende des Worts, aus.
3dd -> scheidet, von der momentanen Cursorposition aus drei Zeilen nach unten, aus.
Analog dazu funktioniert der befehl y für Yank=Kopieren.
p -> einfügen
D -> löscht, von der momentanen Cursorposition aus, bis zum ende der Zeile.
Shells*****e
Vorwort
Immer wieder kommende Aufgaben sind nicht nur monoton und nervtötent, sie gehen auch gerne mal vergessen, damit das nicht passiert sind Shells*****e eine große Arbeitserleichterung. In diesem Abschnitt möchte ich (vor erst) eine kleine Einführung in die Grundlagen der Shells*****e geben. Auch hier gillt dass ich die Themen nur anschneiden werde und will und keine komplette übersicht geben kann und es deshalb auch keine Garantie auf Vollständigkeit gibt.
Schnittstelle
Bevor wir uns mit den Grundlagen beschäftigen möchte ich darauf hinweisen dass die Elemente die ich vorstellen werde nichts besonderes sind. Der Vorzug der Shell ergibt sich erst durch die "Terminal Schnittstelle" der Programme, deshalb ist es erst möglich mächtige Shells*****e zu schreiben. Ein Blick in die Manpage des jeweiligen Programms zeigen euch die Programmaufruf, Option, Parameter usw. Erst durch die Verknüpfung der Grundelemente mit den jeweiligen Programmen ergeben sich umfangreiche Shells*****e.
Shebang
Die 1. (und äußerst wichtige) Zeile eines Shells*****s ist die Shebang (auch Hashbang) genannte Zeile.
Eine Shebang sieht z.B so aus:
Damit wird mitgeteilt, dass wir den Inhalt der jetzt folgt der bash in /bin übergeben wollen.
Deshalb gillt es herauszufinden wo sich unsere Shellinstallation befindet, um unnötige Fehler die durch das Übertragen zustande kommen zu vermeiden, verwende ich immer folgenden Befehl:
which bash > s*****.sh & nano s*****.sh
Der Befehl which gibt den Pfad der Shellinstallation aus und schreibt ihn durch > in die Datei s*****.sh (ist diese nicht vorhanden wird sie angelegt) und öffnet dann, durch &, im Editor Nano die Datei s*****.sh (Nano ist zwar nicht der mächtigste Editor für Linuxeinsteiger aber einfacher , deshalb werden wir ihn hier verwenden.).
Jetzt müsstet ihr einen Editor haben der die Zeile
enthält, hier fügen wir noch ein #! davor.
S*****e ausführbar machen
Soll eine Datei ausgeführt werden muss sie dazu die nötigen Rechte haben, beachte dazu auch den Abschnitt über Rechte im 1. Teil Das setzen der notwendigen Dateiberechtigung geht über den Befehl:
S*****e aufrufen
Der Befehl dazu ist einfach:
S*****e automatisch aufrufen (Crontab)
In den meisten Fällen sollen S*****e dann auch automatisch an einem bestimmten Zeitpunkt starten, dazu gibt es Cron. Cron ist die Jobsteuerung Unixoider Systeme. Editiert wird die Crontab mit dem Befehl crontab -e
Die Struktur einer Crontab ist folgende
* * * * * Befehl
1. * Wochentag (O-7) (Sonntag=0 oder =7)
2. * Monat (1-12)
3. * Tag (1-31)
4. * Stunde (0-23)
5. * Minute (0-59)
(Numerierung von links nach rechts).
Ein Beispiel für einen solchen Eintrag wäre:
1 * * 16 30 /home/user/s*****.sh
Der Cronjob wäre also auf jeden Montag um 16:30 datiert, und würde das S***** s*****.sh welches sich in /home/user befindet starten.
In den meisten Linux-Distributionen ist allerdings folgende Crontab üblich:
0 * * * * <user> run-parts /etc/cron.hourly
0 9 * * * <user> run-parts /etc/cron.daily
0 9 * * 3 <user> run-parts /etc/cron.weekly
0 9 1 * * <user> run-parts /etc/cron.monthly
Die Cronjobs werden also auf die Verzeichnisse cron.hourly bzw. cron.daily bzw. cron.weekly bzw cron.monthly ausgelagert. Die * Haben den Selben Stellenwert wie oben, ein frei bleibender Stern ist eine wildcard. So würde die 4. Zeile wenn es der
1. des Monats und 09:00 Uhr ist die S*****e in /etc/cron.monthly ausführen. Als <user> wird üblichweise root gesetzt. Die Auslagerung auf cron. Verzeichnisse hat den Vorteil dass der Crontab nur einmal editiert werden muss und alle S*****e
die im Laufe der Zeit hinzukommen einfach in das entsprechende cron. Verzeichnis abgelegt werden können.
Grundelemente
Im folgenden werde ich einige Grundelemente beschreiben, das sind bei weitem natürlich nicht alle aber häufig verwendete.
Umleitung
Im 1. Teil bin ich ja schon einmal auf Umleitung eingegangen, dies soll jetzt hier noch etwas vertieft werden.
Grudnsätlich gibt es drei Kanäle in der Bash
1) Standardeingabe stdin, Nr.: 0, stdin liest in den meisten Fällen Eingaben von der Tastatur.
2) Standardausgage stout, Nr.: 1, stout gibt stdout Ausgaben auf dem Bildschirm aus.
3) Fehlerkanal stderr, Nr.: 3, stderr gibt stderr Ausgaben (sprich Fehlermeldungen) auf dem Bildschirm aus.
Grundsätzlich gibt es 7 möglichkeiten umzuleiten diese sind:
1) stdout in eine Datei
2) stderr in eine Datei
3) stdout nach stderr
4) stderr nach stdout
5) stderr und stdout in eine Datei
6) stderr und stdout nach stdout (Wird nicht weiter erläutert)
7) stderr und stdout nach stderr (Wird nicht weiter erläutert)
Beispiele:
1) stdout in eine Datei
Aufbau: [Befel] > [Ausgabedatei]
2) stderr in eine Datei
Aufbau: [Befel] 2> [Ausgabedatei]
3)stdout nach stderr
Aufbau: [Befehl] 1>&2
4)stderr nach stdout
Aufbau: [Befehl] 2>&1
5) stderr und stdout in eine Datei
Aufbau: [Befehl] &>
Pipes
Hier möchte ich auf den Abschnitt in Teil 1 hinweisen, Pipes sind weiterführend doch recht komplex, evtl. werde ich dassin einer späteren Fassung ausarbeiten.
Variablen
Eine Variable wird in der Shell so deklariert:
String
STRING="MeinString!!"
Allgemein: <Name>="Inhalt"
Man kann einer Variable auch einen Wert zuweisen:
ZAEHLER=10
Allgemein: <Name>=<Wert>
Um den String aufzurufen verwenden wir das $-Zeichen, also z.B:
In einem Backups***** könnte das ganze dann so aussehen:
Code:
IF=/home/Benutzer
OF=/mein_Backup.tar.gz
tar -czf $OF $IF
Lokale Variablen
Lokale Variablen werden in einer Funktion mit dem Wort local deklariert. z.B:
Code:
function beispiel{ local HALLO=Welt
echo $Hallo}
(Auf Funktionen werde ich später noch etwas genauer eingehen)
Datum und Zeit
Soll z.B. in einen Dateinamen die Uhrzeit und das Datum eingefügt werden (bei Backups z.B), gibt es den Befehl date.
Um auf das Beispiel oben zurückzukommen würde das so aussehen:
Code:
IF=/home/Benutzer
OF=/mein_Backup_$(date +%Y%m%d%H%M).tar.gz
tar -czf $OF $IF
So würde das Archiv das Datum und die Uhrzeit im Dateinamen enthalten. 'man date' gibt weitere Infos über weitere Optionen.
Abfragen
Grundlagen:
Im Prinzip gibt es drei mögliche Abfragen
1)if <bedingung> then <befehl> . Wobei <befehl> nur ausgeführt wird, wenn <bedingung> wahr ist. (z.B. 2>1; 1=1)
2)if <bedingung> then <befehl1> else <befehl2> . Hier wird geprüft ob <bedingung> wahr ist, wenn ja dann <befehl1> ausgeführt, ansonsten <befehl2>
3)if <bedingung1> then <befehl1> else if <bedingung2> then <befehl2> else <befehl3> . Wenn bedingung1 erfüllt ist, dann befehl1 ansonsten wird überprüft ob bedingung2 erfüllt ist, wenn ja <befehl2> ausgefürt wenn nicht <befehl3>.
Ausgeführt würde das so aussehen:
Code:
if [ "test"="test" ]; then
echo ja
else
echo nein
fi
Schleifen
Hier gibt es auch wieder drei unterschiedliche schleifen
for: Die Forschleife ist in der Bash etwas anderst als in anderen Programmiersprachen siehe dazu das Beispiel.
while: while führt Code aus wenn eine Bedinung wahr ist und stopt erst wenn diese falsch ist
until: until funktioniert genau anderst herum als while.
For
Code:
for
for i in $( ls ); do
echo Datei: $i
done
In der ersten Zeile sagen wir dass i die Werte enthält die aus $( ls ) kommen. Mit do geben wir an, dass jetzt der Teil kommt in dem mit der Variable gearbeitet wird.
In der zweiten Zeile geben wir diesen wert einfach aus. Die Ausgabe ist im Grunde nichts anderes als wenn ihr nur den Befehl ls eingeben würdet. Eine sinnvollere Anwendung wäre zum Beispiel, wenn ihr zum Beispiel alle .jpg Dateien einlesen würdet und diese mittels dem Grafikprogramm Gimp alle auf eine Größe skalieren würdet.
Done beendet die Schleife .
While
Code:
ZAEHLER=0
while [ $ZAEHLER -lt 5 ]; do
echo Der Zaehler ist bei $ZAEHLER
let ZAEHLER=ZAEHLER+1
done
In der ersten Zeile setzen wir den Startwert.
In der zweiten Zeile geben wir die Abbruchbedingung (5) an.
In der dritten Zeile haben wir eine Einfache ausgabe die den Zählerstand ausgibt.
In der vierten Zeile wird der Wert von ZAEHLER um 1 erhöht.
Done ist wieder das Ende der Schleife
Until
Code:
ZAEHLER=6
until [ $ZAEHLER -lt 3 ]; do
echo ZAEHLER ist bei $ZAEHLER
let ZAEHLER-=1
done
Ähnlich wie in der While Schleife nur das wir jetzt den Zaehler mit -=1, bei jedem Schleifendurchklauf um 1 runterzählen, ist die Bedingung, dass ZAEHLER=3 ist erfüllt, wird die Schleife beendet.
Eingaben Einlesen
Mit dem Befehl read ist es möglich Tastatureingaben einzulesen und in eine Variable zu speichern:
Code:
echo "Bitte, gib etwas ein"
read EINGABE
echo "Du hast $EINGABE eingegeben"
Natürlich können auch mehrere Werte eingegeben werden, diese werden dann einfach aneinander gereit:
read EINGABEA EINGABEB EINGABEC
Strings vergleichen und rechnen
Strings können mit folgenden Operatoren verglichen werden:
1) s1 = s2 (s1 ist gleich s2)
2) s1 != s2 (s1 ist ungleich s2)
3) s1 < s2 (s1 ist kleiner s2)
4) s1 > s2 (s1 ist größer s2)
5) -n s1 (s1 ist nicht null, enthält also einen oder mehr Zeichen)
6) -z s1 (s1 ist null, enthält also kein Zeichen)
Angewendet würde das also so aussehen
Code:
s1='string'
s2='stringa'
if [ "$s1"="$s2" ];
then
echo "s1 ('$s1') ist ungleich s2 ('$s2')"
fi
Um in der Shell zu rechnen werden ganz einfach die bekannten Operatoren verwendet:
+
-
*
/
% (Rest)
Auch hier habt ihr die Möglichkeit zu vergleichen:
-lt (< kleiner)
-gt (> größer)
-le (<= kleiner-gleich)
-ge (>= größer-gleich)
-eq (== ist gleich)
-ne (!= ist nicht gleich)
Rechnen
Um zu rechnen könnt ihr im einfachsten Fall direkt den Befehl echo verwenden hier gillt es allerdings zu beachten, das dazu [] Klammern bzw doppelte (()) Klammern notwendig sind:
echo $[1+1]
bzw.
echo $((1+1))
Funktionen
Nimmt ein S***** eine gewisse größe an oder kommen Aufgaben immer wieder ist es für die Effektivität und die Übersicht sinnvoll funktionen zu verwenden.
Der Aufbau von Funktionen ist folgender:
function <name> {code}
Aufgerufen wird die Funktion einfach durch ihren namen <namen>.
Es ist auch möglich Funktionen eine Variable zuzuweisen und den Wert beim Funktionsaufruf an die Funktion zu geben:
Beispiel:
Code:
function sage {
echo $S1
}
sage Hallo
sage Welt
Damit sind wir mit den Grundlagen am Ende, natürlich sind die einzelnen Themen nur grob angerissen worden aber ich denke es sollte euch einen ganz guten Überblick geben. Wenn ihr Fehler findet, glaubt dass ich etwas wichtiges Vergessen habe, sonstiges Feedback geben wollt schreibt einen Kommentar
.
~~~Changelog~~~
21.12 Paketverwaltung und Software kompilieren hinzugefügt.
22.12 Rechteverwaltung erweitert, Suchen & finden eingefügt
18.02 Teil 2.
[TUTORIAL] Einstieg in die Linux Shell UPDATE v2.0
Linear-Darstellung
