1 Allgemein

Nutzen Sie unsere langjährige Erfahrung in der Vermittlung von Knowhow in den Bereichen Linux, OpenBSD und Open Source Software sowie Software-Entwicklung für die folgenden Systeme:

• SuSE-, Ubuntu-, Debian- und RedHat-Linux
• OpenBSD
• SUN-Solaris

Zu Terminen und Konditionen unserer Kurse und Workshops nehmen Sie bitte Kontakt mit uns auf (per Telefon, Fax oder E-Mail).

1.1 Beratung

• die mit dem Kurs beabsichtigten Ziele,
• die gewünschte Themenauswahl und
• die Vorkenntnisse der Kursteilnehmer.

1.2 Workshops

• Sie lernen die Vorgehensweise zur Problemlösung kennen.
• Sie profitieren von unseren Erfahrungen (erhalten neue Ideen, vermeiden Irrwege).
• Sie können anschließend selbst Änderungen und Erweiterungen durchführen.

1.3 Rahmenbedingungen

• Maximal 6-10 Teilnehmer bei Kursen in unseren Seminarräumen
  (bei Inhouse-Schulungen maximal 10-12 Teilnehmer empfohlen)
• Ein PC-Arbeitsplatz pro Teilnehmer
  (Sie können gerne auch Ihren eigenen Notebook mitbringen)
• Schnelle DSL-Anbindung an das Internet
• Wireless LAN und Netzwerk-Kabelanschluss
• Foliensatz und/oder Kursskript in gedruckter Form
• Musterlösungen für die Übungen in elektronischer/gedruckter Form
• Die im Kurs erstellten Dokumente in elektronischer/gedruckter Form
• Verpflegung in Form von Mittagessen, Snacks und Getränken
• Kostenloser Support zu den Kursthemen für die Teilnehmer nach einem Kurs
  (per Telefon, Fax, E-Mail)
• Kurs-Zertifikat zu den behandelten Themen

1.4 Kursunterlagen

Weitere Kursunterlagen von uns finden Sie unter Beschreibungen und Zusammenfassungen.

1.5 Weitere Angebote

• Wir halten die Kurse gerne auch in englischer Sprache ab.
• Wir führen die Kurse gerne auch mit 2 Trainern durch.
  Der 2. Trainer macht z.B. Recherchen zu Spezialfragen, dokumentiert spezielle Themen, betreut Teilnehmer im Falle eines hartnäckigen Fehlers oder während der Übungen. Oder er führt bei heterogenem Teilnehmerfeld einen Teilnehmer wieder an den Kurs heran, während der Kurs — aus Rücksicht auf die anderen Teilnehmer — normal weiterläuft.
• Wir setzen gerne auch Bücher oder Herdt-Skripte als (zusätzliche) Kursunterlagen ein.

1.6 Windows

Beim Samba-Kurs wird eine "gemischte" Umgebung aus Linux- und Windows-Rechnern verwendet.

2 Kursprogramm

2.1 Linux/UNIX-Kurse

2.1.1 Grundlagen

• Linux/UNIX Grundlagen [3 Tage]
• Linux/UNIX Aufbau [2-3 Tage]
• Reguläre Ausdrücke [1-2 Tage]
• Vi/Vim-Editor [1 Tag]
• Vim-Editor Erweiterungen (gegenüber Vi) [1 Tag]

2.1.2 Netzwerk

• C für Linux/UNIX-Netzwerk-Programmierung [2-3 Tage]
• Linux/UNIX Netzwerk-Administration I (Intranet) [3-5 Tage]
• Linux/UNIX Netzwerk-Administration II (Internet) [3-5 Tage]
• Linux/UNIX Security [4-5 Tage]
• Nagios/Icinga/Shinken System- und Netzwerküberwachung [5 Tage]
• Perl Netzwerk-Programmierung [2-3 Tage]

2.1.3 Serveradministration

• Apache (Webserver) [2-3 Tage]
• OpenLDAP (Verzeichnisdienst-Server) [2-3 Tage]
• Postfix/Sendmail/Exim-Administration (Mail-Server) [2 Tage]
• MySQL-Administration (Datenbankserver) [5 Tage]
• PostgreSQL-Administration (Datenbankserver) [5 Tage]
• Samba (Windows Anmelde-, File- und Print-Server) [3 Tage]

2.1.4 Skripting

• Reguläre Ausdrücke [1-2 Tage]
• Sed/Awk-Programmierung (inkl. Reguläre Ausdrücke) [2-3 Tage]
• Shell-Programmierung [3 Tage]

2.1.5 System-Administration

• C für Linux/UNIX-System-Programmierung [2-3 Tage]
• Linux/UNIX Systemadministration [3-5 Tage]
• Perl für Systemadministration [3-5 Tage]
• Shell-Programmierung [3 Tage]

2.2 Software-Entwicklung

2.2.1 Allgemein Programmierung

• Perl Best/Pest Practices (guter Programmierstil) [2-3 Tage]
• Programmierpraxis — Programmierkunst [3-5 Tage]
• Programmierwerkzeuge unter Linux [2-3 Tage]
• SQL Grundlagen und Datenbankdesign [2-3 Tage]
• Vi/Vim-Editor [1 Tag]
• Vim-Editor Erweiterungen (gegenüber Vi) [1 Tag]

2.2.2 C

• C-Programmierung Einführung [3-5 Tage]
• C-Programmierung Aufbau [3-5 Tage]
• C-Programmierung unter Linux/UNIX [2-3 Tage]
• C für Linux/UNIX-System-Programmierung [2-3 Tage]
• C für Linux/UNIX-Netzwerk-Programmierung [2-3 Tage]
• C für parallele Prozesse unter Linux/UNIX [2-3 Tage]

2.2.3 Datenbank

• MySQL-Administration (Datenbankserver) [5 Tage]
• PostgreSQL-Administration (Datenbankserver) [5 Tage]
• Perl DBI (Datenbank-Programmierung) [1-2 Tage]
• SQL Grundlagen und Datenbankdesign [2-3 Tage]

2.2.4 Perl

• Perl-Einführung [3-5 Tage]
• Perl-Aufbau [3-4 Tage]
• Perl objektorientiert [2 Tage]
• Perl-CGI [2 Tage]
• Perl für Systemadministration [3-5 Tage]
• Perl Best/Pest Practices (guter Programmierstil) [2-3 Tage]
• Perl DBI (Datenbank-Programmierung) [1-2 Tage]
• Perl Netzwerk-Programmierung [2-3 Tage]
• Perl/Tk-Programmierung (Grafische Oberflächen) [2-3 Tage]

2.2.5 Python

• Python-Einführung [4-5 Tage]
• Python-Aufbau [4-5 Tage]

2.2.6 Shell-Skript

• Reguläre Ausdrücke [1-2 Tage]
• Sed/Awk-Programmierung (inkl. Reguläre Ausdrücke) [2-3 Tage]
• Shell-Programmierung [3 Tage]

2.2.7 Tcl/Tk und Expect

• Tcl/Tk und Expect [2-3 Tage]

2.2.8 Web

• CSS (Casading Style Sheets) [2-3 Tage]
• HTML/XHTML-Webseitenerstellung [2-3 Tage]
• JavaScript und DHTML (Dynamic HTML) [2-3 Tage]
• XAMPP (Linux/Windows, Apache, MySQL, PHP/Perl) [5 Tage]
• Perl-CGI [2 Tage]
• XML (eXtensible Markup Language) [2-3 Tage]

2.3 Serveradministration

• Apache (Webserver) [2-3 Tage]
• MySQL-Administration (Datenbankserver) [5 Tage]
• PostgreSQL-Administration (Datenbankserver) [5 Tage]
• OpenLDAP (Verzeichnisdienst-Server) [2-3 Tage]
• Postfix/Sendmail/Exim-Administration (Mail-Server) [2 Tage]
• Samba (Windows Anmelde-, File- und Print-Server) [3 Tage]

2.4 Dokumenterstellung

• LaTeX/TeX-Dokument-Erstellung [2-3 Tage]
• Vi/Vim-Editor [1 Tag]
• Vim-Editor Erweiterungen (gegenüber Vi) [1 Tag]

2.5 Weitere Kurse

Falls Sie Bedarf an Kursen haben, die nicht in obiger Themenpalette zu finden sind, oder die auf ganz spezielle Aspekte eines der obigen Kurse eingehen sollen, können Sie sich gerne an uns wenden. Wir führen auf Wunsch auch Kurse oder Workshops zu folgenden Themen durch:

• Firewalls unter Linux/OpenBSD
• Linux from Scratch (LFS)
• OpenBSD
• Portable GUI-Programmierung (Qt, GTK, GKT+)
• Speziell angepasstes Linux/OpenBSD-System (z.B. auf CompactFlash)
• VPN mit Linux/OpenBSD

2.6 Vermittlung

• C++
• C#/.Net
• Corba
• CPython (C-Implementierung von Python — Referenzimplementtion)
• Cython (Python-Compiler nach C)
• DocBook
• Expect (Tcl/Tk)
• IronPython (C#/.NET/CLI-Implementierung von Python)
• Java
• Jython (Java-Implementierung von Python)
• Lua
• OOP (Objektorientierte Programmierung)
• OOA + OOD (Objektorientierte Analyse + Design)
• PyPy (Interpreter für Python in Python geschrieben)
• REST (Representational State Transfer)
• Ruby
• Ruby on Rails (RoR)
• SOAP, RDF, UDDI, WSDL, XMI
• Stackless Python (Nebenläufigkeit besser, Implementierung der virtuellen Maschine komplexer)
• UML 1.x/2.0

3 Linux/UNIX-Wissens-Katalog

3.1 Grafische Oberfläche

Die Bedienung der unter Linux/UNIX/OpenBSD vorhandenen grafischen Oberflächen (z.B. KDE, GNOME) und grafischen Anwendungen (z.B. Office-Paket, Web-Browser, Mail-Clients, Media-Player, …) lässt sich leicht aus dem vorhandenen Windows-Wissen ableiten. Das Arbeiten mit der Maus funktioniert sehr ähnlich, z.B. ist zu jedem Objekt auf der grafischen Oberfläche mit der rechten Maustaste ein kontextsensitives Menü erreichbar.

Abweichungen gibt es beim Aussehen, bei Programmnamen (z.B. "Konqueror" statt "Explorer"), Menüs, Bezeichnungen (z.B. "Symbolischer Link" statt "Verknüpfung"), Hotkeys, Funktionstastenbelegungen, der Bedienung des Zwischenspeichers und dem Einfach/Doppel-Mausklick (sowie der Farbe von Verzeichnissen im "Windows Explorer" verglichen mit "Konqueror/Nautilus/..." ;-).

3.2 Kommandozeile im Terminal

Die kommandozeilen-orientierte Bedienung von Linux/UNIX erklärt sich hingegen nicht von selbst. Ihr Analogon CMD-Fenster/DOS-Box unter Windows wird wenig verwendet (obwohl auch dort sinnvoll und teilweise sogar notwendig). Daher ist häufig zu wenig Vorwissen in diesem Bereich vorhanden, um die Linux/UNIX-Kommandozeile effizient nutzen zu können.

Linux/UNIX-Kommandos umfassen eine kleine, begrenzte, genau definierte Funktionalität und sind durch viele Standard-Mechanismen der Shell (z.B. Pipe, Umlenkung, Kommando-Substitution) leicht kombinierbar. Erst hierdurch entfalten sie ihre ganze Kraft und Eleganz.

Unter Linux/UNIX ist diese Art der Bedienung im Bereich der (professionellen) System-Administration enorm wichtig. Aber auch reine Anwender können von ihr profitieren, da viele Aufgaben per Tastatur einfacher, schneller und fehlerfreier zu erledigen sind.

3.3 Wissens-Katalog

Bitte prüfen Sie anhand der folgenden vier Wissens-Kataloge

• Teil 1 – Grundlagen-Wissen
• Teil 2 – Aufbau-Wissen
• Teil 3 – Shell-Programmierungs-Wissen
• Teil 4 – System-Administrations-Wissen

ob Ihre Kenntnisse für den effizienten Umgang mit Linux, UNIX und OpenBSD ausreichen (das ist etwas anderes als für den prinzipiellen Umgang ;-). Nach unserer Erfahrung wird hier oft zuwenig in die Ausbildung investiert und das Arbeiten so unnötig erschwert, verlangsamt und fehleranfällig.

Falls Sie mit einigen der Begriffe nichts anfangen können, sehen Sie bitte im Vergleich Windows versus Linux nach. Dort wird das meiste erklärt und in den Kontext zu Windows gestellt.

Sie sollten allerdings nicht versuchen, dieses Wissen (etwa 10-15 Schulungstage) auf einen Schlag zu erwerben. Stattdessen ist es sinnvoll, sich dieses Wissen stückweise anzueignen und es jeweils erst im praktischen Einsatz zu vertiefen bevor Sie den nächsten Kurs besuchen.

• Als Anwender sollten Sie sich mit Teil 1 – Grundlagen-Wissen vertraut machen (z.B. in unserem Kurs Linux/UNIX-Einführung).

• Als System-Administrator sollten Sie sich mit Teil 1 – Grundlagen-Wissen und Teil 4 – System-Administration vertraut machen (z.B. in unseren Kursen Linux/UNIX-Einführung und Linux/UNIX-System-Administration).

  Langfristig sollten Sie sich auch mit Teil 3 – Shell-Programmierung vertraut machen (z.B. in unserem Kurs Shell-Programmierung).

• Als Software-Entwickler oder Daten-Verarbeiter sollten Sie sich mit Teil 1 – Grundlagen-Wissen vertraut machen (z.B. in unserem Kurs Linux/UNIX-Einführung).

  Langfristig sollten Sie sich auch mit Teil 3 – Shell-Programmierung vertraut machen (z.B. in unserem Kurs Shell-Programmierung).

• Egal ob Sie Anwender, System-Administrator, Software-Entwickler oder Daten-Verarbeiter sind (der immer wieder große Mengen an Daten manuell oder automatisiert verarbeiten und analysieren muss, z.B. Kundendaten, Logdateien, Transferdaten, Quellcode) oder ob Sie einfach effizienter unter Linux/UNIX arbeiten wollen.

  Dann sollten Sie sich mit Teil 2 – Aufbau-Wissen vertraut machen (z.B. in unserem Kurs Linux/UNIX-Aufbau). Gerade in der Shell-Programmierung werden viele der darin besprochenen Werkzeuge gerne eingesetzt, da die Shell selbst nicht viel kann, sondern letzten Endes nur ein "Framework" für den Aufruf von Kommandos ist.

3.3.1 Teil 1 – Grundlagen-Wissen

Folgende Themen sind als sinnvolle Voraussetzung für die Nutzung der Kommandozeile eines Linux/UNIX-Systems und den Besuch eines Linux/UNIX-System-Administrations- oder -Netzwerk-Kurses zu betrachten (werden im Kurs Linux/UNIX-Einführung vermittelt):

• Grafische Oberfläche
  • KDE/GNOME (Überblick)
  • X Window System (xdm/kdm/gdm, startx, xhost, XF86Config, $DISPLAY, …)
• Hilfesystem (Usage-Meldung, man, info, whatis, apropos, help, Howto, README, …)
• Dateien anzeigen (more, less, cat)
  • Bedienung (<SPACE>, <RETURN>, /<SEARCHTEXT>, n)ext, q)uit, …)
• Terminal
  • Konfiguration
  • Steuerung
• Benutzer und Gruppen
  • Benutzer-Typen (root, Verwaltungsbenutzer, normale Benutzer)
  • Anmeldung/Abmeldung (login, passwd, su, exit, newgrp)
  • Home/Heimat-Verzeichnis (/home/<USER>, /root)
  • Benutzer- und Gruppen-Kommandos (chown, chgrp)
• Dateisystem
  • Hierarchische Struktur
    • Wurzel-Verzeichnis (/)
    • Basisverz. und ihre Bedeutung (/bin, /boot, /cdrom, /dev, /etc, /home, /lib, /lib64, /lost+found, /media, /mnt, /opt, /proc, /root, /run, /sbin, /srv, /snap, /sys, /tmp, /usr, /var, …)
    • Home/Heimat-Verzeichnis (~, /home/<USER>)
    • Aktuelles Verzeichnis (.)
    • Eltern-Verzeichnis (..)
    • Absoluter Pfadname (/usr/bin/ls)
    • Relativer Pfadname (ls, bin/ls, ./ls, ../../ls)
  • Kommandos (cd, pwd, ls, ls -l, touch, cp, mv, rm, mkdir, rmdir, …)
  • Versteckte Dateien (.profile, .bashrc, .alias, .config/*, …)
  • Geräte-Dateien (/dev/{hda,sda,mouse,zero,null}, …)
  • System-Information (/proc, /sys, /run)
• Zugriffsrechte
  • Standard-Zugriffsrechte (rwx=read/write/execute, ugoa=user/group/other/all)
  • Kommandos (chmod, umask)
• Prozess-System
  • Kommandos (ps, <Ctrl-C>, kill, pkill, killall, top, pstree, /proc, …)
  • Signale (HUP, INT, QUIT, KILL, TERM, …)
• Shell-Funktionalitäten
  • Standard-Ein/Ausgabe (stdin, stdout, stderr, stdlog)
  • Datei-Umlenkung (<, >, 2>, >>, 2>>, 1>&2, 2>&1, …)
  • Pipes (|)
  • Dateinamen-Expansion (Wildcard/Joker: ~, *, ?, [...], [!...], {...})
  • Shell-Konfigurationsdateien (/etc/profile, .profile, .bashrc, .alias, .config/*, …)
  • Shell- und Umgebungsvariablen (set, env, export, unset, $HOME, $TERM, …)
  • Suchpfad ($PATH)
  • Quotierung ("...", '...', \<CHAR>)
  • Namens-Vervollständigung (<TAB>, <TAB> <TAB> bzw. <Ctrl-D>, …)
  • History (history, !, <Ctrl-R>, …)
  • Aliase (alias, unalias, …)
  • Prompt-Definition ($PS1, $prompt, …)
• Editoren (vi/vim, nano/pico, emacs, …)
  • Modi
  • Aufruf/Verlassen
  • Bewegen
  • Editieren
  • Suchen/Ersetzen
  • Optionen
  • Konfiguration
• Such-Kommandos (type/which/whence, file, grep, find, locate, whatis, …)
• Remote-Kommandos (ssh, scp, sftp, ftp, telnet, …)

3.3.2 Teil 2 – Aufbau-Wissen

• Spezielle Themen
  • Hardlinks und symbolische Links (Inode, ln, ln -s, rm, …)
  • Sonder-Zugriffsrechte (s=SetUID/SetGID, t=Sticky)
  • Hintergrund-Prozesse (<CMD> &, <Ctrl-Z>, fg, bg, jobs, …)
  • Kommando-Substitution (`...`, $(...))
• Linux/UNIX-Standard-Werkzeuge
  • strings, od
  • more, less, tee
  • head, tail
  • sort, uniq
  • wc, nl, tr
  • cut, paste
  • split, cat
  • join
  • cmp, diff
  • Weitere Werkzeuge (column, csplit, diff3, expand, fmt, fold, m4, pr, …)
• Reguläre Ausdrücke
  • Universelle, leistungsfähige und performante Methode zur Textsuche + Textersetzung
  • Varianten: BRE (Basic), ERE (Extended) und PCRE (Perl Compatible Regular Expressions)
  • Normale Zeichen (Literal: a-z, A-Z, 0-9, …) und Metazeichen (\ * ? + [ ] ^ $ …)
  • Schützen von Metazeichen (\*, \^, \\, …)
  • Escape-Sequenz (\f, \n, \r, \t, \v, …)
  • Zeichenklasse (., [...], [^...], [:alpha:], \d, \D, \s, \S, \w, \W, …)
  • Quantifizierer (*, +, ?, {N,M})
  • Anker (^, $, \<, \>, \b, \B, \a, \z, \Z)
  • Gruppierung/Klammern/Merken + Backreference ((...), \(...\), \1, \2, …)
  • Alternative (|)
  • Left-most sowie greedy/lazy/possessive Matching (*?, +?, ??, {N,M}?, *+, ++, ?+, {N,M}+
  • Positiver/Negativer Look-ahead/behind ((?=, (?!, (?<=, (?<!)
• Programmierbare Datenverarbeitungs-Tools
  • Textsuche mit grep, egrep, fgrep
  • Editor ed/ex
  • Stream-Editor sed
  • Daten- und Textverarbeitungssprache awk

3.3.3 Teil 3 – Shell-Programmierung

Ein Shell-Skript zwingt zum gründlichen Nachdenken, erlaubt Abläufe zu reproduzieren, reduziert die Fehlermöglichkeiten und stellt gleichzeitig eine Dokumentation dar. Seine Erstellung lohnt sich sowohl für häufig als auch für selten durchgeführte Aufgaben (im ersten Fall aufgrund der Zeitersparnis und der Vermeidung von Flüchtigkeitsfehlern; im zweiten Fall aufgrund der Dokumentation der Tätigkeit und der reduzierten Fehlermöglichkeiten).

Folgende Themen sind für die Shell-Programmierung relevant (werden im Kurs Shell-Programmierung vermittelt):

• Wiederholung Grundlagen
  • Standard-Ein/Ausgabe (stdin, stdout, stderr, stdlog)
  • Datei-Umlenkung (<, >, 2>, >>, 2>>, 1>&2, 2>&1, …)
  • Pipes (|)
  • Dateinamen-Expansion (~, *, ?, [...], [!...], {...})
  • Shell-Konfigurationsdateien (/etc/profile, .profile, .bashrc, .alias, .config/*, …)
  • Quotierung ("...", '...', \<CHAR>)
  • Editoren (vi/vim, nano/pico, emacs, …)
• Skript-Aufruf
  • Ausführungs-Recht (chmod a+x <FILE>)
  • Suchpfad ($PATH)
  • Shee-Bang-Zeile (#!/bin/bash)
• Variablen
  • Shell- und Umgebungsvariablen (set, env, export, unset, $HOME, $TERM, …)
  • Parameter (shift, $*, $@, $#, $1, $2, $3, …, $9, ${10}, …)
  • Spezialvariablen ($0, $?, $$, $!, $-, …)
• Kontrollstrukturen
  • Tests (test, [...], [[...]], -e, -f, -d, -L, -s, -z, -n, …)
  • Verzweigung (if, then, elif, else, fi, switch, case, break, default, esac)
  • Schleife (for, while, until, do, done)
  • Abbruch (break, continue, exit)
  • Funktionen (function, typeset -f, return, …)
• Sonstiges
  • Exit-Status (exit, $?, $status, …)
  • Kindprozesse (&, exec, wait, …)
  • Kommando-Kombination ((...), {...}, ||, &&, ;)
  • Kommando-Substitution (`...`, $(...))
  • Mehrfach-Auswertung (eval)
  • Signale abfangen (trap)
  • Rechnen (expr, $((...)), $[...], let, declare -i, dc, bc)
  • Here-Dokument (<<)
  • Quellcode einlesen (source .)
  • Bedingte Variablen (${VAR:-DFLT}, ...)
  • Stringverarbeitung (${VAR#} ${VAR/} ${VAR:n:m} ...)
  • Array (indiziert, assoziativ)

3.3.4 Teil 4 – System-Administration

Neben den Grundlagen Linux/UNIX-Einführung, Linux/UNIX-Aufbau und Shell-Programmierung ist im Bereich der UNIX-, Linux- und OpenBSD-System-Administration das Beherrschen folgender Themen sinnvoll (werden im Kurs Linux/UNIX-System-Administration vermittelt):

• Installation und Konfiguration
  • System-Konfiguration (/etc, /etc/sysconfig, /etc/default, YaST)
  • Platten-Partitionierung (fdisk, cfdisk, sfdisk, parted)
  • Software-Installation (rpm, dpkg, apt, aptitude, yum, zypper, dnf, Flatpack, Snap, AppImage)
• System-Administrator (root, /root, /home)
• System-Konfiguration (/etc, /etc/sysconfig, /etc/default, YaST)
• Benutzer- und Gruppenverwaltung (useradd/mod/del, groupadd/mod/del, chsh/chage/chfn)
• Erweiterte Zugriffsrechte (SetUID, SetGID, Sticky, ext3/ReiserFS-Attribute, ACL, Extended Attributes)
• Datensuche (grep, find, locate, type/which/whence, file)
• Prozess-Kontrolle (nice, renice, ulimit, /proc, /sys)
• Datenträger verwalten (Festplatte, Floppy, CD-ROM/DVD, USB-Stick, …)
  • Verwaltungsstruktur (Verzeichnis, Dentry, Inode, Datenblock, ls -i, stat)
  • Gerätedatei (/dev, mknod, mkfifo, MAKEDEV)
  • Hardlink und symbolische Link (Inode, ln, ln -s, rm, …)
  • Dateisystem (mkfs; ext2/3/4, ReiserFS, XFS, JFS, BTRFS, ZFS, iso9660, FAT32, VFAT, exFAT, NTFS, SMBFS/CIFS, NFS)
  • Montieren/Demontieren (/etc/fstab; mount, umount, du, df, eject, /media, /mnt)
  • Prüfen/Reparieren (fsck, /lost+found)
  • Swap (mkswap, swapon, swapoff, free)
  • Tuning (tunefs, tune2fs, hdparm, sdparm, …)
  • Fehlersuche (lsof, fuser, pidof, …)
  • RAID (md = multiple disk, Raid-Tools)
  • Logical Volume Manager (LVM: pv…, vg…, lv…)
  • Disk Quota (quota, edquota, quotaon/off, quotacheck, repquota)
• Archivierung (tar, star, cpio, afio, pax, compress, gzip, bzip2, xz)
• Backup/Restore (cp, dd, dump+restore, mt, rsync)
• Automatische Programmausführung (at, crontab, batch, anacron)
• Systemsteuerung (Boot-Vorgang, Runlevel, Shutdown)
  • Bootloader (GRUB/GRUB2, lilo, /boot, /boot/grub, grub.cfg)
  • Kernel-Konfiguration (rdev, initrd, /boot, Bootparameter, config)
  • Runlevel (init, /etc/inittab, runlevel, upstart, systemd, systemctl)
  • Start/Stop-Skript (Dienstskript)
  • Dienst/Daemon (temporär + permanent: apache, mysql, ftp, telnet, …; /srv)
  • Runlevel konfigurieren (chkconfig, insserv, update-rc.d, rcconf, …)
  • System herunterfahren (shutdown, halt, reboot, init)
  • Boot-Meldung (dmesg, journalctl)
  • System-Logging (syslogd, syslog-ng, rsyslogd, logrotate, /var/log/*)
  • Name Service Cache Daemon (nscd)
  • Internet-Daemon (inetd, xinetd)
  • Systemrettung (Bootparameter, Notboot, Einbruch)
  • Unteradministrator (sudo, /etc/sudoers)
• Performance (top, uptime, iostat, pidstat, mpstat, vmstat, ifstat, sar)
• Remote-Administration (ssh, scp, sftp)
• Drucker-Einrichtung und -Verwaltung (lpd, lpd-ng, CUPS)
• Softwarepaket- und Patch-Installation/Deinstallation (rpm, dpkg, apt, aptitude, yum, zypper, dnf, Flatpack, Snap, AppImage)
• Kernel-Modul (lsmod, insmod, modprobe, rmmod, modules(.d/.conf), modprobe(.d/.conf), modules.dep)
• Software im Quellcode nutzen (tar, gzip, bzip2, configure, make)

4 Was ist wichtig?

4.1 Übungen

4.2 Fehler

Wir sammeln daher die im Kurs aufgetretenen Fehler (es finden sich immer wieder neue!) und stellen sie vor. Natürlich werden die Fehlerursachen genau erforscht und erläutert, sowie Strategien zu ihrer Vermeidung präsentiert und eingeübt.

Häufig ist gerade die schnelle und effektive Fehlersuche mit Linux/UNIX-Bordmitteln das "Salz in der (Kurs)Suppe".

4.3 Fragen

Weiterhin stellen Fragen eine Rückkopplung an den Trainer dar. Sie helfen ihm, Kenntnisstand und Fortschritte der Teilnehmer besser einzuschätzen.

Nicht zuletzt werden die anderen Teilnehmer dankbar für Ihre Fragen sein, weil durch die Klärung das Verständnis aller wächst.

4.4 Pausen

4.5 Erfahrungsaustausch

Auch kommt es immer wieder vor, dass Teilnehmer von ihnen eingesetzte "Tools" erwähnen, die den anderen Teilnehmern (und sogar uns als Trainer) nicht bekannt sind.

4.6 Weniger ist mehr

Zwischen aufeinander aufbauenden Kursen sollte daher auch genügend Zeit für die Teilnehmer bestehen, die Kursinhalte in ihrem Arbeitsumfeld einzusetzen und zu festigen (und sich Fragen für den nächsten Kurs zu überlegen ;-).

4.7 "Wie" und "Warum"

Mit dieser Vorgehensweise erwirbt man ein tiefes Verständnis dafür, wie und warum Dinge funktionieren und wieviel Aufwand wirklich dahinter steckt. Und nicht nur ein oberflächliches Wissen, das einem im Ernstfall wenig weiterhilft.

4.8 Grundlagen-Wissen

Letzten Endes ist diese Zeit sehr gut investiert, da anschließend alles leichter, schneller und fehlerfreier von der Hand geht und "Halbwissen" ausgemerzt wird.

Es spricht z.B. überhaupt nichts dagegen, auch als langjähriger "Linux/UNIX-Hase" einen Grundlagenkurs zu besuchten. Man stellt erstens fest, dass man schon viel weiß, lernt zweitens neue Dinge oder Sichtweisen kennen, die man sofort gewinnbringend nutzen kann und kann drittens auch die richtigen Fragen zu wichtigen Themen stellen, die man schon immer mal genauer wissen wollte.

4.9 Automatisierung

Ein Linux/UNIX-Administrator sollte daher programmieren können (zumindest Shell, besser noch Perl, Python oder Ruby), um einige seiner Tätigkeiten automatisieren zu können.

Administrations-Skripte machen Verwaltungs-Tätigkeiten in Computersystemen reproduzierbar, weniger fehleranfällig, beschleunigen sie und dokumentieren sie (für den Administrator selbst und für andere!).

In unseren Kursen betonen wir daher dieses wichtige Prinzip und erstellen mit den Teilnehmern kleine und größere Skripte in diesem Bereich.

4.10 Unnötige Komplexität vermeiden

• Wie gut sind die Systeme und ihr Zusammenspiel dokumentiert?
  Wird die Dokumentation bei jeder Änderung gepflegt oder
  steckt das Wissen nur in den Köpfen?

• Verstehen wir das aufgebaute System auch noch
  morgen, nächsten Monat, nächstes Jahr, in fünf Jahren?

• Wie viele Leute sind ausreichend ausgebildet und geschult?
  Ist noch genügend Knowhow vorhanden,
  wenn ein oder mehrere Mitarbeiter gehen?

• Werden die Vorgänge in unseren Systemen ständig überwacht?
  Wer wird (automatisch) informiert, falls etwas schief geht?

• Funktioniert der Backup wirklich ständig einwandfrei (z.B. inkl. aller Besitzverhältnisse, Berechtigungen und aller Sonderzeichen in Datei- und Verzeichnisnamen)?
  Sind fehlende Daten darin leicht und schnell aufzuspüren und zurückzuspielen?
  Wie lange dauert das Zurückspielen eines Vollbackups eigentlich?

• Was passiert bei einem Ausfall eines Rechners?
  Was für Auswirkungen hat dies auf das Gesamtsystem?
  Wie lange dauert das Wiederaufsetzen?
  

• Werden die notwendigen Wartungsarbeiten ständig durchgeführt?
  Werden die Systemvorgänge ausreichend mitgeloggt?

• Wird nur Symptombekämpfung durchgeführt oder
  wird die wahre Fehlerursache gesucht
  (auch wenn letzteres mehr Zeit kostet)?

• Wollen wir unsere Fehler verschweigen oder
  lernen wir lieber daraus für die Zukunft?

• Ist der Anspruch "Die Systeme müssen alle ständig laufen" nicht zu hoch?
  Sollten wir nicht periodische Wartungsfenster festlegen?

• Kommen wir vor lauter Anwendersupport auch mal zum Nachdenken,
  warum dieser Support dauernd notwendig ist?

• Ist der Wert unserer Arbeit der Geschäftsleitung bekannt?
  Oder werden wir nur als "bessere Hausmeister" betrachtet?

4.11 Man muss nicht alles wissen

• Einen guten Überblick über die Struktur und die Funktions- und Verhaltensweisen seines Betriebssystems und der darauf laufenden Dienste (Mail, LDAP, SSH, DHCP, DNS, Firewall, NTP, syslog, Web, FTP, NFS, SMB, nscd, cron, at, …) haben.

• Wissen, wie und wo man die fehlenden Informationen schnell und effizient nachschlagen kann (z.B. auch in eigenen Aufzeichnungen).

Daher legen wir Wert darauf, dass die Teilnehmer die (meist englische) Linux/UNIX-Dokumentation gründlich kennen und nutzen lernen. Das was man ständig in seiner täglichen Arbeit benötigt, prägt sich dann mit der Zeit sowieso automatisch ein.

4.12 Freude

4.13 Editor-Beherrschung

Daher legen wir Wert darauf, dass der Vi/Vim (oder auf Wunsch auch der Pico/Nano oder der Emacs/XEmacs) ohne Bauchschmerzen beherrscht wird. Diese Editoren sind nach 1-2 Stunden ohne Probleme einsetzbar (obwohl ihre Bedienung von gewohnten Editoren wie Word abweicht), wenn sie nur gut erklärt werden und etwas Zeit in Übungen investiert wird (Vi/Vim und Emacs/XEmacs sind übrigens auch unter Windows verfügbar).

4.14 10-Finger-System

Diese Berufsbilder sind allerdings fast ausgestorben. Heute geben statt dessen hochqualifizierte Fachleute ihre Texte selbst in den Computer ein. Sie arbeiten dabei aufgrund des oft verwendeten "2-Finger-Adler-Suchsystems" meist haarsträubend ineffizient.

Das Aneignen des 10-Finger-Systems lohnt sich wirklich. Das müssen Sie aber dann doch woanders lernen (z.B. mit einem der dazu frei erhältlichen Programme). Oder sich selbst beibringen (das geht tatsächlich!).

Wenn man sich ansieht, wieviele Leute freiwillig eine wahrlich besch... Schnittstelle gelernt haben, nämlich mit ein oder zwei Daumen und T9 bzw. automatischer Textvervollständigung Texte in ihr Handy einzutippen, dann ist das vielleicht doch nicht zuviel verlangt.