Schulungsangebot

1 Allgemein      2.5 Weitere Kurse
 1.1 Beratung      2.6 Vermittlung
 1.2 Workshops     3 Linux/UNIX-Wissens-Katalog
 1.3 Rahmenbedingungen      3.1 Grafische Oberfläche
 1.4 Kursunterlagen      3.2 Kommandozeile im Terminal
 1.5 Weitere Angebote      3.3 Wissens-Katalog
 1.6 Windows       3.3.1 Teil 1 – Grundlagen-Wissen
2 Kursprogramm       3.3.2 Teil 2 – Aufbau-Wissen
 2.1 Linux/UNIX-Kurse       3.3.3 Teil 3 – Shell-Programmierung
  2.1.1 Grundlagen       3.3.4 Teil 4 – System-Administration
  2.1.2 Netzwerk     4 Was ist wichtig?
  2.1.3 Serveradministration      4.1 Übungen
  2.1.4 Skripting      4.2 Fehler
  2.1.5 System-Administration      4.3 Fragen
 2.2 Software-Entwicklung      4.4 Pausen
  2.2.1 Allgemein Programmierung      4.5 Erfahrungsaustausch
  2.2.2 C      4.6 Weniger ist mehr
  2.2.3 Datenbank      4.7 "Wie" und "Warum"
  2.2.4 Perl      4.8 Grundlagen-Wissen
  2.2.5 Python      4.9 Automatisierung
  2.2.6 Shell-Skript      4.10 Unnötige Komplexität vermeiden
  2.2.7 Tcl/Tk und Expect      4.11 Man muss nicht alles wissen
  2.2.8 Web      4.12 Freude
 2.3 Serveradministration      4.13 Editor-Beherrschung
 2.4 Dokumenterstellung      4.14 10-Finger-System

1 Allgemein

Wir sind ein Open Source Dienstleister, der in keinerlei Abhängigkeit zu Hard- und Software-Herstellern steht. Profitieren Sie bei der Analyse, Planung und Umsetzung Ihrer Linux-, OpenBSD-, Open Source- und Software-Projekte sowie beim Aufbau und der Wartung Ihrer heterogenen Netzwerke bestehend aus obigen Systemen zusammen mit Windows- und Apple-Rechnern von unserem langjährigen Knowhow in diesen Bereichen.

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

Wir bieten unsere Kurse auch "direkt von der Stange" an, halten es aber durchaus für sinnvoll, im Vorfeld gemeinsam mit Ihnen den gewünschten Kurs an Ihre speziellen Bedürfnisse anzupassen. Dazu benötigen wir Informationen über
  • die mit dem Kurs beabsichtigten Ziele,
  • die gewünschte Themenauswahl und
  • die Vorkenntnisse der Kursteilnehmer.
Hieraus lassen sich ein sinnvoller Kursumfang und eine sinnvolle Kursdauer ableiten. Die bei jedem Kurs angegebene Dauer ist daher als ungefähre Angabe zu betrachten.

1.2 Workshops

Unter Workshop verstehen wir einen Kurs, in dem spezielle Probleme eines Kunden in Zusammenarbeit mit uns analysiert, bearbeitet und gelöst werden. Der Vorteil gegenüber einer direkten Lösung durch uns ist:
  • 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

Wir verwenden vorwiegend eigene Kursunterlagen und entwickeln diese ständig aufgrund unserer Kurserfahrungen und gemäß dem technischen Fortschritt weiter. Damit Sie sich einen Eindruck von deren Qualität und Umfang machen können, stellen wir einige Auszüge zum Download zur Verfügung.

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

Obwohl wir sehr gerne unter Linux, UNIX und OpenBSD schulen, führen wir viele unserer Kurse auch auch unter Windows durch, sofern sie weitgehend plattformunabhängig sind.

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

2 Kursprogramm

Die Kursbeschreibungen liegen als HTML-Seiten und als PDF-Dateien vor. Zur Anzeige der PDF-Dateien benötigen Sie einen PDF-Viewer, z.B. Xpdf (PDF-Viewer für X Windows) oder Foxit Reader (PDF-Viewer für MS Windows).

2.1 Linux/UNIX-Kurse

Mit diesen Kursen können Sie die Grundlagen von Linux, UNIX und OpenBSD, die Shell-Programmierung, die System- und Netzwerk-Administration sowie die Absicherung und Überwachung von Netzwerken erlernen.

2.1.1 Grundlagen

2.1.2 Netzwerk

2.1.3 Serveradministration

2.1.4 Skripting

2.1.5 System-Administration

2.2 Software-Entwicklung

Mit diesen Kursen können Sie sowohl allgemeine Konzepte der Programmierung und die Programmiertools unter Linux und OpenBSD als auch die Programmier-Sprachen C, Perl, PHP, Shell, Awk/Sed sowie die in der Web-Programmierung häufig eingesetzten LAMP-Systeme (Linux, Apache, MySQL, PostgreSQL, PHP/Perl) und die (Programmier-)Sprachen CSS, HTML, JavaScript, MySQL, PostgreSQL, XML erlernen.

2.2.1 Allgemein Programmierung

2.2.2 C

2.2.3 Datenbank

2.2.4 Perl

2.2.5 Python

2.2.6 Shell-Skript

2.2.7 Tcl/Tk und Expect

2.2.8 Web

2.3 Serveradministration

Mit diesen Kursen können Sie die unter Linux und OpenBSD häufig eingesetzten Serverdienste Apache, MySQL, PostgreSQL, OpenLDAP, Postfix, Qmail, Sendmail, Exim und Samba erlernen.

2.4 Dokumenterstellung

Mit diesen Kursen können Sie die unter Linux und OpenBSD wichtigsten Werkzeuge zur Texterfassung, Programmierung und Dokument-Erstellung erlernen.

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

Aufgrund unserer Kontakte zu anderen erfahrenen Trainern und Schulungs-Anbietern können wir Ihnen auch Kurse zu folgenden Themen vermitteln (ohne Mehrkosten):
  • 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

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.

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

Sinnvoll ist auch ein grundlegendes Verständnis in folgenden Bereichen, um immer wieder auftretende Aufgaben der Daten-Verarbeitung und System-Administration automatisieren zu können. Z.B. wird man häufig die Ausgabe von Programmen weiterverarbeiten wollen, um die relevanten Daten auszufiltern und an andere Programme zu übergeben (wird im Kurs Linux/UNIX-Aufbau vermittelt):
  • 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

Während die beiden obigen Teile das für die Kommandozeile notwendige Wissen bereitstellen, ist für die tägliche Arbeit das Automatisieren von Tätigkeiten per Shell-Skript sehr wichtig.

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?

Aus den Erfahrungen der vielen von uns durchgeführten Kurse haben wir folgende Regeln abgeleitet, die wir in unseren Kursen berücksichtigen:

4.1 Übungen

Wir legen Wert darauf, dass die Teilnehmer das Gelernte sofort am Rechner üben und festigen ("learning by doing"). Auf jeden Theorieteil folgt daher eine Übungsphase mit speziell konzipierten Übungen, zu denen es anschließend auch Musterlösungen gibt.

4.2 Fehler

Ein Kurs, in dem alles glatt läuft, hat seinen Zweck nicht erfüllt. Es ist wichtig, Fehler zu machen, um sie in Zukunft vermeiden zu können. Wenn nicht im Kurs, wann dann soll man Fehler machen? Und aus Fehlern kann man wirklich viel lernen. Keine Angst vor den anderen Teilnehmern (und dem Trainer), bei allen geht mal was schief!

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

Folgenden Satz kennen Sie sicherlich: "Es gibt keine dummen Fragen, sondern nur dumme Antworten". Als Trainer haben wir schon oft erlebt, dass sich gerade aus einer scheinbar "dummen" Teilnehmerfrage Einsichten ergeben können, die auch uns vorher nicht bewusst oder sogar nicht bekannt waren. Daher freuen wir uns über jede Teilnehmerfrage!

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

Wir orientieren uns mit den Pausen an den Bedürfnissen der Teilnehmer. Sie können daher jederzeit im Kurs eine Pause einfordern, wenn Sie das Gefühl haben, es wird zu viel. Danach geht es oft viel leichter weiter…

4.5 Erfahrungsaustausch

Die Teilnehmer haben aufgrund ihrer spezifischen Ausbildung und ihrer Situation am Arbeitsplatz unterschiedliche Erfahrungen gesammelt. Dieses Spektrum an positiven (und negativen) Erfahrungen kann man im Rahmen eines Kurses nutzen, um seinen "Horizont zu erweitern".

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

Unsere Devise ist: Nicht zu viele Themen auf einmal behandeln, diese dafür aber gründlich. Oberflächliches "Wissen" schafft nur Probleme (z.B. im Bereich der IT-Sicherheit).

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"

Nur "Rumklicken" und dann läuft's schon (wie so häufig unter Windows) bringt leider wenig. Gerade bei Linux/UNIX und Open Source ist der Blick hinter die Kulissen/unter die Haube möglich und erwünscht. Daher arbeiten wir in den Kursen wenig mit grafischen Oberflächen, sondern hauptsächlich auf der Kommandozeile.

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

Viele Chefs sagen zu ihren Mitarbeitern: "Das können Sie schon, dazu brauchen Sie keinen Kurs mehr. Besuchen Sie doch gleich den Fortgeschrittenen-Kurs". Gerade im Bereich Linux/UNIX sind jedoch Grundlagen sehr wichtig, da man sie ständig benötigt und sie das effiziente Arbeiten erst ermöglichen.

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

Computer wurden zur Automatisierung von Vorgängen geschaffen — dazu gehört auch und gerade die System-Administration. Wer ständig die gleichen administrativen Vorgänge manuell per Tastatur oder Mausklick durchführt, macht etwas falsch.

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

Die wahre Kunst in der System-Administration und bei der Software-Entwicklung ist: Unnötige Komplexität vermeiden! So schön anzusehen blinkende Hardware und Software mit farbigen GUIs auch sind — und wie beeindruckend viel Geld dafür auch ausgegeben wird — entscheidend sind ganz andere Dinge:

  • 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?

Daher betonen wir in unseren Kursen den Grundsatz "Unnötige Komplexität vermeiden soweit es irgendwie geht". Die Systeme werden sowieso im Laufe der Zeit ganz von alleine immer komplexer, das muss man nicht auch noch selbst forcieren.

4.11 Man muss nicht alles wissen

Die vielen Details eines Betriebssystems und der darauf laufenden Dienste, Server und Softwarepakete kann man nicht alle auswendig wissen. Vor allem, wenn man sie nicht ständig in der täglichen Arbeit benötigt. Statt dessen sollte man:

  • 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

Linux/UNIX ist ein Betriebssystem, an dem viele hoch qualifizierte Leute vor allem auch aus Spaß und Freude an der Arbeit mitgewirkt haben (und immer noch mitwirken). Diese Freude ist an vielen Stellen zu spüren (z.B. sind einige Kommandos und Begriffe als kleine Witze gemeint) und wir weisen im Rahmen unserer Kurse immer wieder darauf hin.

4.13 Editor-Beherrschung

Egal ob Anwender, System-Administrator oder Software-Entwickler, alle müssen täglich große Mengen an Text oder Kommandos eingeben und bearbeiten. Dazu sollte man einen überall verfügbaren Standard-Editor beherrschen und ihn für seine Zwecke konfigurieren können.

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

Großer Effizienz-Gewinn ist zu erreichen, wenn man Texte schnell und blind tippen kann (mit dem 10-Finger-System ohne dabei auf die Tastatur zu sehen, sondern auf den Bildschirm), wie das früher mal Sekretärinnen und Setzer gelernt haben.

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.

70 Kurse (0 neu)