Wird auch mal Zeit, dass einer reagiert…

Dass unsere Gesellschaft es sich gut und gerne möglichst bequem macht hat Bernd schon hinreichend ausgeführt.
Dies gilt allerdings nicht nur im politischen Kontext, sondern auch im IT-Kontext.

Paradebeispiel

M$ Windows gehört aktuell der Löwenanteil des Desktop-PC-Marktes – aber nicht unbedingt der Qualität wegen, sondern u.a. aus folgendem Grund:
Einige (vor allem im gewerblichen Bereich) häufig unumgängliche “Killer-Apps” wie M$ Office oder Adobe Photoshop laufen schlichtweg nur auf Windows (oder Mac OS).
Um von diesem hoch unsicheren, kostenpflichtigen, spionierenden und nicht-quelloffenen Betriebssystem wegzukommen, muss der Benutzer zumindest folgende Hürden überwinden:

  • (darauf kommen, dass überhaupt ein Betriebssystem außer Windows und Mac OS existiert)
  • bspw. GNU/Linux herunterladen und auf CD/DVD/USB-Stick brennen
  • davon booten und das System installieren
  • sich in das System und die Unterschiede zu Windows einarbeiten
  • Alternativen für ihre Killer-Apps suchen (sofern überhaupt vorhanden!)
  • sich in letztgenannte einarbeiten…

In solchen Fällen habe ich volles Verständnis für den Sieg der Faulheit. Henry Ford hat mal gesagt:

Denken ist die schwerste Arbeit, die es gibt. Das ist wahrscheinlich auch der Grund, warum sich so wenige Leute damit beschäftigen.

Aber das geht auch viel einfacher – ohne als böser Raubkopierer vom rechten Weg abzukommen – mit …

ReactOS

ReactOS ist keine GNU/Linux-Distribution, die es sich zur Aufgabe gemacht hat, Windows äußerlich möglichst ähnlich zu sehen.
Es ist ein eigenständiges, von Grund auf geschriebenes Betriebssystem, dessen Ziel es ist, möglichst vollständig zu Windows kompatibel zu sein.
Ich selbst habe ReactOS ausprobiert und teile meine Erfahrungen hier mit euch…

Ran an die Buletten!

Wie üblich habe ich das OS in einer virtuellen Maschine ausprobiert – konkret mit VirtualBox. Nachdem ich das ISO-Abbild heruntergeladen habe erstellte ich eine neue virtuelle Maschine…

Es ist wichtig, dass das Modell der (virtuellen) Netzwerkkarte mit dem von mir gewählten übereinstimmt (3. Bild) – sonst kann es passieren, dass das Netzwerk überhaupt nicht funktioniert.
Sobald der Bootvorgang abgeschlossen war, fand ich einen Windows-XP-ähnlichen Assistenten vor – mit dem Unterschied, dass ich die Sprache frei wählen konnte. (Pfeiltasten oben/unten, dann Eingabetaste)
Sobald das vollbracht ist, muss eigentlich nur noch die Eingabetaste malträtiert werden, bis dieser Assistent durch ist…

Dann gilt es einen Neustart abzuwarten. Beim darauf folgenden Assistenten muss man fast genau so wenig den Kopf anstrengen.
Ich habe zwar Name und Organisation angegeben, hätte aber auch genau so gut immer nur direkt “weiter” drücken können…

Nachdem einem weiteren Neustart kann man auch schon loslegen. Fehlermeldungen wie diese habe ich für meinen Teil bedenkenlos weggeklickt:

Aber…

Da war noch was…

Ein gesunder Geist in einem gesunden Körper. Und ein guter Web-Browser auf einem guten Betriebssystem.
Ich habe die Firefox-Versionen 3.6, 28 und 45 aus dem ReactOS-Paketmanager (Ja, Paketmanager! 😀 ) ausprobiert und meine, dass 28 aktuell der beste Kompromiss aus Funktionalität und Stabilität ist…

Fazit

Ist ReactOS nun für den Produktivbetrieb zu empfehlen?
Meiner Meinung nach noch definitiv nicht.
Neben der o.g. mangelhaften Unterstützung von Netzwerkkarten ist das System (… wie sagt man da noch gleich politisch korrekt …) leicht absturzgefährdet.
Konkret habe ich versucht, mir Visual Studio 2015 Community herunterzuladen (erstmal nur herunterzuladen!) …

(-.-“)

Alexander Klimov
Alexander Klimov
Developer

Alexander hat 2017 seine Ausbildung zum Developer bei NETWAYS erfolgreich abgeschlossen. Als leidenschaftlicher Programmierer und begeisterter Anhänger der Idee freier Software, hat er sich dabei innerhalb kürzester Zeit in die Herzen seiner Kollegen im Development geschlichen. Wäre nicht ausgerechnet Gandhi sein Vorbild, würde er von dort aus daran arbeiten, seinen geheimen Plan, erst die Abteilung und dann die Weltherrschaft an sich zu reißen, zu realisieren - tut er aber nicht. Stattdessen beschreitet er mit der...

Schwarze Magie für GNU/Linux-Nerds

“Linux ist der beste Virenschutz”, heißt es in “Fachkreisen”. “Installiere Linux und Du wirst fortan ruhiger schlafen können!” Ähm… falsch.
Ja, Linux ist ein guter Anfang was die Herstellung der Sicherheit auf dem eigenen Rechner betrifft. Aber es hilft einem nichts ohne brain.exe. Vor allem wenn man es mit einem Magier zu tun bekommt…

Mögen die Spiele beginnen!

ps -fu nagios

Wer auf das Monitoring-System Zugriff hat, hat viel Macht.

Wo Bernd recht hat, hat er recht – nicht umsonst nimmt z. B. Gunnars Jabber-Notification-Skript Nutzername und Passwort via Umgebungsvariablen entgegen. Check- und Notification-Skripte, die diesem Beispiel nicht folgen, reißen eine Sicherheitslücke auf, die jeder Systemnutzer ganz einfach ausnutzen kann:

aklimov@icinga2:~$ ps -fu nagios
UID        PID  PPID  C STIME TTY          TIME CMD
nagios    8128     1  0 11:10 ?        00:00:00 /usr/lib/x86_64-linux-gnu/icinga2/sbin/icinga2 --no-stack-rlimit daemon -e /var/log/icinga2/error.log
nagios    8148  8128  0 11:10 ?        00:00:00 /usr/lib/x86_64-linux-gnu/icinga2/sbin/icinga2 --no-stack-rlimit daemon -e /var/log/icinga2/error.log
nagios    8433  8148  0 11:17 ?        00:00:00 /usr/lib/nagios/plugins/check_ping -6 -H ::1 -c 200,15% -w 100,5%
nagios    8434  8433  0 11:17 ?        00:00:00 /bin/ping6 -n -U -w 10 -c 5 ::1
nagios    8435  8148  0 11:17 ?        00:00:00 /usr/lib/nagios/plugins/check_ping -4 -H 127.0.0.1 -c 200,15% -w 100,5%
nagios    8436  8148  0 11:17 ?        00:00:00 /usr/lib/nagios/plugins/check_ping -H 127.0.0.1 -c 5000,100% -w 3000,80%
nagios    8437  8435  0 11:17 ?        00:00:00 /bin/ping -n -U -w 10 -c 5 127.0.0.1
nagios    8438  8436  0 11:17 ?        00:00:00 /bin/ping -n -U -w 30 -c 5 127.0.0.1

Schwarze Magie ist hier noch nicht im Spiel. (Aber dieses Beispiel ist auch nur zum Aufwärmen.)

strace -p

Was tut ein Programm so alles wenn ich gerade mal nicht hinschaue? Um diese Frage zu beantworten, wird nicht zwangsläufig der Quellcode benötigt. In vielen Fällen reicht bereits strace:
aklimov@WS-AKlimov:~$ echo $$  # Prozess-ID der Shell
20901
aklimov@WS-AKlimov:~$ strace -p20901
strace: Process 20901 attached
wait4(-1,

Der Ausgabe können wir entnehmen, dass die Shell gerade darauf wartet, dass ein beliebiger Kindprozess (z. B. strace) sich beendet.
Diese Art der Hexenkunst hat sich bereits rumgesprochen und die Kernel-Entwickler haben ihre Wirkung eingedämmt. Daher konnte ich ohne weiteres nur den Elternprozess von strace als Beispiel nehmen.

gdb -p

Ich erinnere mich noch genau an diese eine AWP-Unterrichtsstunde in der Berufsschule:
Es ging darum, dass ein C/C++-Programm auf mehrere Module aufgeteilt werden kann. Mit dem static-Schlüsselwort sei es möglich, “modulglobale” Variablen zu erstellen – d. h. Variablen, die zwar global, aber nur für das eigene Modul sichtbar sind. Ein Argument des Lehrers für solche Variablen war allen Ernstes die Sicherheit. Und die Übung zu diesem Thema bestand darin, in einem Modul ein Passwort vor den anderen Modulen zu verbergen.
Wenn der wüsste…
Zunächst starte ich in einem neuen Terminal cat:
aklimov@WS-AKlimov:~$ cat
Damit haben wir auch schon unseren “Opfer”-Prozess, der im konkreten Fall auf eingehende Daten wartet.
Darauf hin öffne ich ein zweites Terminal (mit den gleichen Benutzerrechten!) und starte gdb:
aklimov@WS-AKlimov:~$ ps -ef |grep cat
aklimov  10217 10149  0 12:25 pts/11   00:00:00 cat
aklimov  11088 10298  0 12:26 pts/12   00:00:00 grep cat
aklimov@WS-AKlimov:~$ gdb -p 10217
GNU gdb (Debian 7.11.1-2+b1) 7.11.1
Copyright (C) 2016 Free Software Foundation, Inc.
(...)
Attaching to process 10217
(...)
(gdb)

Die schwarze Magie daran…

… besteht darin, dass ich nun innerhalb dieses Prozesses schalten und walten kann wie ich will. (Und sämtlichen Speicher aller Module auslesen.)
Beispielsweise kann ich den Standard-Eingabe-Datenstrom (Stdin) des Prozesses on-the-fly durch /dev/null ersetzen (ohne ihn zu verlieren):

Aktion (Beschreibung) Aktion (GDB) Datei-Deskriptoren
/dev/null öffnen (gdb) p open("/dev/null", 0)
$1 = 3
0 /dev/pts/1
3 /dev/null
Stdin sichern (gdb) p dup(0)
$2 = 4
0, 4 /dev/pts/1
3 /dev/null
Datenstrom umleiten (gdb) p dup2(3, 0)
$3 = 0
4 /dev/pts/1
0, 3 /dev/null
Redundanten Deskriptor schließen (gdb) p close(3)
$4 = 0
4 /dev/pts/1
0 /dev/null
Programm-Ausführung fortsetzen (gdb) c
Continuing.
[Inferior 1 (process 10217) exited normally]
(gdb)
N/A

Fazit

Linux nimmt einem keinerlei Sicherheitsfragen vollständig ab. Es gibt einem lediglich die Möglichkeit, sich selbst um diese zu kümmern (und sie nicht der NSA zu überlassen).
Gehet hin und sichert euch!

Alexander Klimov
Alexander Klimov
Developer

Alexander hat 2017 seine Ausbildung zum Developer bei NETWAYS erfolgreich abgeschlossen. Als leidenschaftlicher Programmierer und begeisterter Anhänger der Idee freier Software, hat er sich dabei innerhalb kürzester Zeit in die Herzen seiner Kollegen im Development geschlichen. Wäre nicht ausgerechnet Gandhi sein Vorbild, würde er von dort aus daran arbeiten, seinen geheimen Plan, erst die Abteilung und dann die Weltherrschaft an sich zu reißen, zu realisieren - tut er aber nicht. Stattdessen beschreitet er mit der...

In Datenbanken Indizes benutzen Du sollst!

… hat Bernd schon verlauten lassen.
Das heißt aber nicht, dass pauschal jede Spalte jeder Tabelle indiziert gehört – und es funktioniert. Denn bei jeder Schreiboperation müssen auch alle betroffenen Indizes mit aktualisiert werden. Dies sollte berücksichtigt werden, wenn in eine Tabelle potenziell viel geschrieben wird, aber die Lesevorgänge sich in Grenzen halten. (Beispiel: Icinga 2 DB IDO)
Im folgenden möchte ich genauer auf die Anwendungsfälle von DB-Indizes eingehen. Zwecks Demonstration habe ich eine SQLite-DB mit folgendem Schema angelegt:

CREATE TABLE myheavytable0 (
  c0 INTEGER, c1 INTEGER, c2 INTEGER, c3 INTEGER, c4 INTEGER,
  c5 INTEGER, c6 INTEGER, c7 INTEGER, c8 INTEGER, c9 INTEGER
);
CREATE TABLE myheavytable1 (
  c0 INTEGER, c1 INTEGER, c2 INTEGER, c3 INTEGER, c4 INTEGER,
  c5 INTEGER, c6 INTEGER, c7 INTEGER, c8 INTEGER, c9 INTEGER
);

(2 Tabellen mit je 10 Ganzzahlen-Spalten)
Diese Tabellen habe ich mit je 10.000.000 Zeilen Zufallszahlen befüllt. Im übrigen ist die Indizierung numerischer Spalten potenziell besser als die Indizierung von Text-Spalten.

Anwendungsfall #1: Joins

Die Herstellung von Beziehungen zwischen verschiedenen Entitätsmengen mit Hilfe von Fremdschlüsseln ist bei relationalen Datenbanken das Tagesgeschäft. Es kann sich durchaus lohnen, die entsprechenden Spalten zu indizieren.
Zwecks Demonstration wird das Schema wie folgt ergänzt:

CREATE INDEX myheavyindex0c0 ON myheavytable0 (c0);
CREATE INDEX myheavyindex0c1 ON myheavytable0 (c1);
CREATE INDEX myheavyindex1c0 ON myheavytable1 (c0);
CREATE INDEX myheavyindex1c1 ON myheavytable1 (c1);

(Die ersten 2 Spalten beider Tabellen werden jeweils einzeln indiziert.)
Die Auswirkungen können mit Messungen der Ausführungszeiten folgender Abfragen veranschaulicht werden:

Abfrage Zeit
SELECT COUNT(*) FROM myheavytable0 m0 INNER JOIN myheavytable1 m1 ON m0.c2 = m1.c3 1m 6.519s
SELECT COUNT(*) FROM myheavytable0 m0 INNER JOIN myheavytable1 m1 ON m0.c0 = m1.c3 20.836s
SELECT COUNT(*) FROM myheavytable0 m0 INNER JOIN myheavytable1 m1 ON m0.c0 = m1.c1 4.468s

Daraus folgt: Werden 2 Tabellen mit Hilfe von je einer Spalte, von denen eine indiziert ist, gejoint, ist die Abfrage etwa 3x so schnell wie mit 2 nicht-indizierten Spalten. Sind beide Spalten indiziert, ist die Abfrage fast 15x so schnell.

Anwendungsfall #2: Verrechnung mehrerer Spalten

Manchmal müssen 2 Attribute einer Entität in einer Abfrage miteinander verrechnet werden. Viele Datenbanken bieten lobenswerterweise auch die Möglichkeit, Ausdrücke zu indizieren:

CREATE INDEX myheavyindex0e0 ON myheavytable0 (c4 + c5);
Abfrage Zeit
SELECT COUNT(*) FROM myheavytable0 WHERE c0 + c1 > 8000000 1.324s
SELECT COUNT(*) FROM myheavytable0 WHERE c4 + c5 > 8000000 0.513s

Daraus folgt: Wenn ein indizierter Ausdruck abgefragt wird, ist die Abfrage fast 3x so schnell wie wenn alle am Ausdruck beteiligten Spalten einzeln indiziert sind.

Anwendungsfall #3: Filter auf mehrere Spalten

Wenn abgefragte Daten häufig auf mehreren Spalten basierend gefiltert werden, kann es sich lohnen, diese Spalten zusammen zu Indizieren:

CREATE INDEX myheavyindex0m0 ON myheavytable0 (c6, c7);
Abfrage Zeit
SELECT COUNT(*) FROM myheavytable0 WHERE c0 < 8000000 AND c1 > 8000000 12.130s
SELECT COUNT(*) FROM myheavytable0 WHERE c6 < 8000000 AND c7 > 8000000 0.445s

Daraus folgt: Bei zusammen indizierten Spalten ist die Abfrage 27x so schnell wie bei einzeln indizierten.

Fazit

Bei Nutzung von Indizes hängt viel vom Einzelfall ab. Im Zweifelsfall sollte ein Fachmann zu Rate gezogen werden.

Alexander Klimov
Alexander Klimov
Developer

Alexander hat 2017 seine Ausbildung zum Developer bei NETWAYS erfolgreich abgeschlossen. Als leidenschaftlicher Programmierer und begeisterter Anhänger der Idee freier Software, hat er sich dabei innerhalb kürzester Zeit in die Herzen seiner Kollegen im Development geschlichen. Wäre nicht ausgerechnet Gandhi sein Vorbild, würde er von dort aus daran arbeiten, seinen geheimen Plan, erst die Abteilung und dann die Weltherrschaft an sich zu reißen, zu realisieren - tut er aber nicht. Stattdessen beschreitet er mit der...

Ich arbeite nicht mit Git – Git arbeitet für mich

Immer wenn ich daran denke, was für ein praktisches Werkzeug Git doch ist, setzt es noch einen drauf. Als ob mir git bisect nicht schon genug Arbeit abnehmen würde, bin ich jetzt auch noch über git rerere gestolpert.

Was ist git rerere?

git rerere ist standardmäßig inaktiv und kann mit folgendem Befehl aktiviert werden:

$ git config --global rerere.enabled true

Sobald das getan ist, zeichnet Git auf, wie der Entwickler Zusammenführungs-Konflikte auflöst und verwendet diese Aufzeichnungen ggf. wieder.

Erklärung am Beispiel

Wir beginnen mit einem leeren Repository, das wir mit ein paar Commits füllen:

$ mkdir rerere-demo && cd $_
$ git init
Initialisierte leeres Git-Repository in /home/aklimov/rerere-demo/.git/
$ echo A >Buchstabensalat.txt
$ git add Buchstabensalat.txt
$ git commit -m A
[master (Basis-Commit) 4d1a53f] A
 1 file changed, 1 insertion(+)
 create mode 100644 Buchstabensalat.txt
$ echo B >>Buchstabensalat.txt
$ git commit -am B
[master fe71b2b] B
 1 file changed, 1 insertion(+)
$ git checkout HEAD^
$ echo C >>Buchstabensalat.txt
$ git commit -am C
[losgelöster HEAD 181ad2e] C
 1 file changed, 1 insertion(+)
$ git checkout -

Nun sollten wir so einen Baum vorfinden:

$ git --no-pager log --oneline --graph --decorate=full master 181ad2e
* 181ad2e C
| * fe71b2b (HEAD -> refs/heads/master) B
|/
* 4d1a53f A

Jetzt versuchen wir, die Commits B und C zusammenzuführen, was natürlich erfolgreich fehlschlagen wird. Wir müssen also den Konflikt manuell auflösen:

$ git merge 181ad2e
automatischer Merge von Buchstabensalat.txt
KONFLIKT (Inhalt): Merge-Konflikt in Buchstabensalat.txt
Recorded preimage for 'Buchstabensalat.txt'
Automatischer Merge fehlgeschlagen; beheben Sie die Konflikte und committen Sie dann das Ergebnis.
$ git --no-pager diff
diff --cc Buchstabensalat.txt
index 35d242b,8ec30d8..0000000
--- a/Buchstabensalat.txt
+++ b/Buchstabensalat.txt
@@@ -1,2 -1,2 +1,6 @@@
  A
++<<<<<<< HEAD
 +B
++=======
+ C
++>>>>>>> 181ad2e
$ git --no-pager diff
diff --cc Buchstabensalat.txt
index 35d242b,8ec30d8..0000000
--- a/Buchstabensalat.txt
+++ b/Buchstabensalat.txt
@@@ -1,2 -1,2 +1,3 @@@
  A
 +B
+ C
$ git add Buchstabensalat.txt
$ git commit --no-edit
Recorded resolution for 'Buchstabensalat.txt'.
[master 279715c] Merge commit '181ad2e'
$ git --no-pager log --oneline --graph --decorate=full
*   279715c (HEAD -> refs/heads/master) Merge commit '181ad2e'
|\
| * 181ad2e C
* | fe71b2b B
|/
* 4d1a53f A

Die Wirkung von git rerere macht sich bereits bei den rot hervorgehobenen Zeilen bemerkbar. An diesen Stellen wird aufgezeichnet, wie die Konflikt-Datei vorher bzw. nachher ausgesehen hat. Um zu sehen, was uns das bringt, verwerfen wir den Merge-Commit und führen erneut zusammen:

$ git reset --hard HEAD^
HEAD ist jetzt bei fe71b2b B
$ git --no-pager log --oneline --graph --decorate=full master 181ad2e
* 181ad2e C
| * fe71b2b (HEAD -> refs/heads/master) B
|/
* 4d1a53f A
$ git merge 181ad2e
automatischer Merge von Buchstabensalat.txt
KONFLIKT (Inhalt): Merge-Konflikt in Buchstabensalat.txt
Resolved 'Buchstabensalat.txt' using previous resolution.
Automatischer Merge fehlgeschlagen; beheben Sie die Konflikte und committen Sie dann das Ergebnis.
$ git --no-pager diff
diff --cc Buchstabensalat.txt
index 35d242b,8ec30d8..0000000
--- a/Buchstabensalat.txt
+++ b/Buchstabensalat.txt
@@@ -1,2 -1,2 +1,3 @@@
  A
 +B
+ C
$ git add Buchstabensalat.txt
$ git commit --no-edit
[master cb5c96b] Merge commit '181ad2e'
$ git --no-pager log --oneline --graph --decorate=full
*   cb5c96b (HEAD -> refs/heads/master) Merge commit '181ad2e'
|\
| * 181ad2e C
* | fe71b2b B
|/
* 4d1a53f A

Wie wir sehen können, hat Git, unmittelbar nachdem es einen Konflikt entdeckt hat, diesen automatisch mit Hilfe der vorher gespeicherten Aufzeichnung aufgelöst.

Da geht noch was

Selbstverständlich ist die Funktionalität von git rerere nicht auf so einfache Fälle beschränkt. Nehmen wir einmal an, dass wir nicht alleine an diesem Repository arbeiten und ein Kollege bereits etwas in den master-Zweig hochgeladen hat:

$ git checkout fe71b2b
$ vi Buchstabensalat.txt
$ git commit -am D
[losgelöster HEAD 779312b] D
 1 file changed, 1 insertion(+)
$ git checkout -
$ git --no-pager log --oneline --graph --decorate=full master 779312b
* 779312b D
| *   cb5c96b (HEAD -> refs/heads/master) Merge commit '181ad2e'
| |\
|/ /
| * 181ad2e C
* | fe71b2b B
|/
* 4d1a53f A

Wir müssen also unseren Merge-Commit über D legen, bevor wir pushen können:

$ git rebase --preserve-merges 779312b
Resolved 'Buchstabensalat.txt' using previous resolution.
automatischer Merge von Buchstabensalat.txt
KONFLIKT (Inhalt): Merge-Konflikt in Buchstabensalat.txt
Automatischer Merge fehlgeschlagen; beheben Sie die Konflikte und committen Sie dann das Ergebnis.
Error redoing merge cb5c96bcb52306dfbdcc8c728c6d356efa3ed9da
$ git --no-pager diff
diff --cc Buchstabensalat.txt
index f5a7bda,8ec30d8..0000000
--- a/Buchstabensalat.txt
+++ b/Buchstabensalat.txt
@@@ -1,3 -1,2 +1,4 @@@
 +D
  A
 +B
+ C
$ git add Buchstabensalat.txt
$ git rebase --continue
[losgelöster HEAD 5096395] Merge commit '181ad2e'
Successfully rebased and updated refs/heads/master.
$ git --no-pager log --oneline --graph --decorate=full
*   5096395 (HEAD -> refs/heads/master) Merge commit '181ad2e'
|\
| * 181ad2e C
* | 779312b D
* | fe71b2b B
|/
* 4d1a53f A

Fazit

Ich kann nicht für alle erdenklichen Teams sprechen, aber wir bei Icinga Web 2 werden uns jedenfalls nicht mehr absprechen müssen, wer gerade Konflikte auflöst und wer pushen darf. 🙂

Alexander Klimov
Alexander Klimov
Developer

Alexander hat 2017 seine Ausbildung zum Developer bei NETWAYS erfolgreich abgeschlossen. Als leidenschaftlicher Programmierer und begeisterter Anhänger der Idee freier Software, hat er sich dabei innerhalb kürzester Zeit in die Herzen seiner Kollegen im Development geschlichen. Wäre nicht ausgerechnet Gandhi sein Vorbild, würde er von dort aus daran arbeiten, seinen geheimen Plan, erst die Abteilung und dann die Weltherrschaft an sich zu reißen, zu realisieren - tut er aber nicht. Stattdessen beschreitet er mit der...

Jetzt wird der lahmen Schlange der Prozess gemacht

Python poweredEiner meiner Kollegen ist in diesem Beitrag bereits auf Python-betriebene Web-Server (WSGI) eingegangen. Ein mit make_server() erstellter Standard-WSGI-Server kann zur selben Zeit leider nur eine Anfrage bearbeiten, da weder Multithreading, noch Multiprocessing Verwendung finden. Mit dem Wissen wie es geht ist dies relativ einfach nachzurüsten und genau darauf will ich im folgenden eingehen.

Threads oder Prozesse?

Die Threadsicherheit von Python steht außer Frage. Die Umsetzung lässt allerdings zu wünschen übrig: Der Global Interpreter Lock verhindert gleichzeitiges Ausführen von Python-Bytecode in mehreren Threads. Somit sind Threads in Python mehr oder weniger für die Katz und es bleiben nur noch die Prozesse.
Diese können etwas umständlicher zu verwalten sein, bringen aber dafür zumindest einen wesentlichen Vorteil mit sich: Die einzelnen Prozesse sind voneinander komplett unabhängig.
Daraus folgt: Wenn ein Prozess abstürzt, bleibt der Rest davon unberührt. Daraus wiederum folgt: Wenn ein Prozess “amok läuft” kann er problemlos “abgeschossen” werden, um die System-Ressourcen nicht weiter zu belasten. (Im realen Leben undenkbar.)

Ein Server für alle Netzwerk-Schnittstellen

Wer weiß, dass seine Anwendung immer auf allen Netzwerk-Schnittstellen (oder nur auf einer) wird lauschen sollen, der hat ungleich weniger Aufwand bei der Implementierung:

from socket import AF_INET
from SocketServer import ForkingMixIn
from wsgiref.simple_server import make_server, WSGIServer
class ForkingWSGIServer(ForkingMixIn, WSGIServer):
    address_family = AF_INET
def app(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/plain')])
    yield 'Hallo Welt!'
if __name__ == '__main__':
    make_server('0.0.0.0', 8080, app, server_class=ForkingWSGIServer).serve_forever()

 

Erklärung

Nach der Python-üblichen Unmenge an Importen wird die Klasse ForkingWSGIServer definiert – ein WSGIServer kombiniert mit dem ForkingMixIn. Dies funktioniert einwandfrei, da WSGIServer von BaseHTTPServer.HTTPServer erbt und letztgenannter wiederum ein SocketServer.TCPServer ist. HTTPServer, WSGIServer und ForkingMixIn überschreiben völlig unterschiedliche Methoden und kommen sich somit nicht in die Quere.
Darauf folgt eine beispielhafte WSGI-Anwendung, die theoretisch durch alles erdenkliche ersetzt werden kann.
Schlussendlich wird ein ForkingWSGIServer erstellt und er wird angewiesen, für einen unbestimmten Zeitraum die beispielhafte WSGI-Anwendung auf Port 8080 anzubieten.

Arbeitsweise

Der Server wird für jede ankommende HTTP-Anfrage einen neuen Prozess starten und diesen sie bearbeiten lassen. Während dessen kann er bereits einen neuen Prozess für die nächste schon wartende Anfrage erzeugen, usw..

Den Server sauber herunterfahren

Wenn der oben beschriebene Server z.B. via Strg-C o.ä. beendet wird, werden alle aktiven Verbindungen abrupt abgebrochen. Wenn das unerwünscht ist, kann der Server wie folgt erweitert werden:

import os
import sys
from signal import signal, SIGTERM
if __name__ == '__main__':
    signal(SIGTERM, (lambda signum, frame: sys.exit()))
    try:
        make_server('0.0.0.0', 8080, app, server_class=ForkingWSGIServer).serve_forever()
    finally:
        try:
            while True:
                os.wait()
        except OSError:
            pass

 

Erklärung

Kurz vor dem Start des Servers wird ein Signal-Handler registriert. Dieser sorgt dafür, dass der Python-Interpreter sich sauber beendet (sys.exit()) wenn er ein TERM-Signal erhält.
Diese Art der Beendigung wird abgefangen, um vor dem tatsächlichen Stopp auf alle noch laufenden Kindprozesse zu warten.

Ergebnis

Strg-C funktioniert zwar immer noch nicht so wie es soll, aber dafür der kill-Befehl.

Ein Server pro Netzwerk-Schnittstelle

Obwohl die gerade beschriebene Implementation einfach und schnell zu bewerkstelligen ist, kommt es vor, dass eine Anwendung auf mehreren, aber nicht auf allen Netzwerk-Schnittstellen lauschen soll. Hierzu muss der Haupt-Prozess für jede Schnittstelle einen weiteren Prozess, den eigentlichen WSGI-Server, erstellen.

import os
import sys
from multiprocessing import Process
from signal import signal, SIGTERM
from socket import AF_INET, AF_INET6
from SocketServer import ForkingMixIn
from time import sleep
from wsgiref.simple_server import make_server, WSGIServer
def print_msg(prefix, msg):
    print >>sys.stderr, '<{0}> {1}'.format(prefix, msg)
class ForkingWSGIServer(ForkingMixIn, WSGIServer):
    address_family = AF_INET
class ForkingWSGI6Server(ForkingWSGIServer):
    address_family = AF_INET6
def app(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/plain')])
    yield 'Hallo Welt!'
def run_forking_server(host, port, address_family=AF_INET):
    pid = os.getpid()
    print_msg(pid, 'Serving on {0}:{1}..'.format(host, port))
    server_class = ForkingWSGI6Server if address_family == AF_INET6 else ForkingWSGIServer
    try:
        make_server(host, port, app, server_class=server_class).serve_forever()
    finally:
        print_msg(pid, 'Shutting down..')
        try:
            while True:
                os.wait()
        except OSError:
            pass
        print_msg(pid, 'Exiting..')
if __name__ == '__main__':
    signal(SIGTERM, (lambda signum, frame: sys.exit()))
    processes = []
    port = 8080
    for (address_family, host) in (
        (AF_INET, '127.0.0.1'), (AF_INET6, '::1')
    ):
        p = Process(target=run_forking_server, args=(host, port, address_family))
        p.daemon = False
        p.start()
        processes.append(p)
    prefix = '{0} (root)'.format(os.getpid())
    print_msg(prefix, 'Waiting for SIGTERM..')
    try:
        while True:
            sleep(86400)
    finally:
        print_msg(prefix, 'Shutting down..')
        for p in processes:
            print_msg(prefix, 'Terminating {0}..'.format(p.pid))
            p.terminate()
        for p in processes:
            print_msg(prefix, 'Joining {0}..'.format(p.pid))
            p.join()
        print_msg(prefix, 'Exiting..')

 

Erklärung

Nach Registrierung des uns schon bekannten Signal-Handlers wird für jede Schnittstelle ein Prozess erstellt. Danach legt sich der Haupt-Prozess schlafen und wartet darauf, von einem SIGTERM aufgeweckt zu werden. Wenn das eintritt, terminiert er alle seine Kindprozesse und wartet, bis sie sich beendet haben.
Ein jeder dieser Kindprozesse startet wie gehabt einen WSGI-Server und wartet auf die Beendigung seiner Kindprozesse wenn ein SIGTERM eintrifft.

Fazit

Der vorgestellte Code ist rein demonstrativer Natur und entsprechend minimalistisch aufgebaut. Der Ursprung aller Dinge ist klein und dementsprechend ist noch viel Luft nach oben. Viel Spaß beim ausprobieren!
Vorausgesetzte Python-Version: 2.6 oder 2.7

Alexander Klimov
Alexander Klimov
Developer

Alexander hat 2017 seine Ausbildung zum Developer bei NETWAYS erfolgreich abgeschlossen. Als leidenschaftlicher Programmierer und begeisterter Anhänger der Idee freier Software, hat er sich dabei innerhalb kürzester Zeit in die Herzen seiner Kollegen im Development geschlichen. Wäre nicht ausgerechnet Gandhi sein Vorbild, würde er von dort aus daran arbeiten, seinen geheimen Plan, erst die Abteilung und dann die Weltherrschaft an sich zu reißen, zu realisieren - tut er aber nicht. Stattdessen beschreitet er mit der...

Azubis erzählen: September 2015 Alexander

This entry is part 9 of 12 in the series Azubis erzählen

Name: Alexander Klimov
Ausbildungsberuf: Fachinformatiker für Anwendungsentwicklung
Abteilung: Development
Lehrjahr: 2

C hat keine DLLs, sondern nur Headers”, sagte einst einer meiner ehemaligen Berufsschulklassenkollegen.
Solch grob fahrlässige fachbezogene Aussagen gebe ich nicht von mir – zumindest seit ich bei NETWAYS ausgebildet werde. Das Gegenteil des obigen Zitats habe ich hier nicht gelernt, dafür aber einige andere sehr interessante Sachen, die ich diesmal vorstellen will.

Git

Wer von den Fachinformatiker-Auszubildenden kennt das nicht: In der Berufsschule wird im Fach Anwendungsentwicklung und Programmierung ein Programm schrittweise weiterentwickelt und es wird einem nahe gelegt, vor jeder größeren Erweiterung des Programms den Quellcode zu sichern, um ggf. auf einen älteren Stand zugreifen zu können. Für diesen Zweck ist die Versionskontrolle Git viel besser geeignet – nicht zuletzt auch weil das Pflegen von vielen Versionen viel “attraktiver” ist. Ich hatte zu meinem Glück immer meinen Laptop dabei und kaum ein Programm, dessen Entwicklung nicht auf eine Schulstunde beschränkt war, ohne Git entwickelt.

$ mkdir AWP/Parkautomat && cd $_
$ git init
$ editor parkautomat.cpp && git add $_
$ git commit -m "Implementiere einen übertrieben übertriebenen Parkautomaten"
$ editor parkautomat.cpp && git add $_
$ git commit -m "Statte den Parkautomaten mit Funktionalität, die kein Mensch braucht, aus"

Zuletzt hat mich ein Kollege das Bisect-Kommando gelehrt. Dieses Wissen habe ich natürlich guten Willens bei nächstbester Gelegenheit weitergegeben.

Vim

Als ich bei NETWAYS angefangen habe, habe ich ernsthaft noch den Texteditor Nano verwendet – mit Ausreden wie “er genügt meinen Ansprüchen”. Aber kaum dass mir ein schönes neues Werkzeug in die Hände fällt, lasse ich den alten, primitiven Kram hinter mir. Auch in der Berufsschule hat der Editor gute Dienste geleistet. Es fiel mir viel leichter, damit zu arbeiten, als mit dem an der Schule propagierten Visual Studio. (Da liest mein Banknachbar in der 1. AWP-Stunde die 5-10-seitige bilderreiche Einführung in das letztgenannte Programm, während ich das zu schreibende Hallo-Welt-Programm schon längst mit Vim abgetippt und mit GCC kompiliert habe. Und – wer hätte das gedacht 😉 – es funktionierte!) Auch ich gehöre mittlerweile zu den Programmierern, die an ihrer .vimrc hängen.

$ cat ~/.vimrc
set bg=dark nu mouse=a ai et sts=4
sy on
nmap <F4> :qa<CR>
language de_DE.utf8
highlight Normal guibg=Black guifg=White

Puppet

… ist aus einer komplexen und automatisierten IT-Welt wie unserer nicht wegzudenken. Ob viele gleichartige Systeme aufwandarm aufgesetzt werden müssen oder die Entwicklungsumgebungs-VM eines Projektes mit einer Komanndozeile einsatzbereit sein muss – Puppet ist des Systemadministrators Freund und Helfer. Alleine die verglichen mit der konventionellen Bash verkürzte, intuitive und anti-redundante schreibweise für häufig verwendete Komponenten machen die Sprache attraktiv. Die Möglichkeit, Abhängigkeiten der Komponenten untereinander explizit zu definieren, nötigt bei komplexeren Beschaffungen der Systeme regelrecht zur Nutzung von Puppet. Im Rahmen eines Umbaus von Icinga Web 2 habe ich den Aufbau und die Funktionsweise von Puppet kennen gelernt. Mit Hilfe dieses Wissens habe ich für das jüngste von mir betreute Projekt von Grund auf Puppet-Manifeste geschrieben, um mir und anderen die Entwicklung zu erleichtern. Folgendes Beispiel installiert den Apache-Webserver auf Debian/Ubuntu, Fedora/RHEL, openSUSE/SLES und darauf basierenden Systemen:

$apache = $osfamily ? {
  'Debian' => 'apache2',
  'Suse'   => 'apache2',
  'RedHat' => 'httpd',
}
package { $apache:
  ensure => latest,
}
-> service { $apache:
  ensure => running,
  enable => true,
}

SQL

Angesichts des hohen Datenaufkommens, das Anwendungen heutzutage zu bewältigen haben, sind relationale Datenbanken unverzichtbar. Die Vielzahl unterschiedlicher Datenbankmanagementsysteme fordert einen möglichst großen gemeinsamen Nenner der Abfragesprachen. Dieser wurde mit SQL 1986 geschaffen und ist – nicht nur meiner Meinung nach – absolute Pflichtlektüre eines jeden werdenden Fachinformatikers. Im Rahmen der Entwicklung einer Stammdatenverwaltungssoftware bin ich dieser interessanten Thematik gelehrt worden – und auch in der Berufsschule soll das noch auf mich zukommen. Einer der größten Nutzen relationaler Datenbanken ist die Möglichkeit, Datensätze nur ein mal speichern zu müssen und mehrfach darauf verweisen zu können. Folgendes Beispiel ist eine Abfrage der Klassen und -leitungen von Schülern:

SELECT sn.name, k.name, ln.name
FROM schueler AS s
INNER JOIN klasse AS k ON k.id=s.klasse_id
INNER JOIN lehrer AS l ON l.id=k.lehrer_id
INNER JOIN natuerliche_person AS sn ON sn.id=s.natuerliche_person_id
INNER JOIN natuerliche_person AS ln ON ln.id=l.natuerliche_person_id;

Die Personalien von Schülern und Lehrern und evtl. anderen natürlichen Personen werden hierbei – da gleichartige Datensätze – in einer Tabelle gespeichert. Da bspw. ein Lehrer mehrere Klassenleitungen haben kann, wird er nur ein mal gespeichert und über lehrer.id referenziert, um Redundanz zu vermeiden.

Fazit

Lehrjahre sind zwar keine Herrenjahre, können aber eine große Bereicherung sein – vor allem für die kommenden Herrenjahre. Und mein vergangenes Lehrjahr hat gezeigt: Sich reinzuhängen lohnt sich – auch bei den unbeliebten Berufsschulfächern.

Alexander Klimov
Alexander Klimov
Developer

Alexander hat 2017 seine Ausbildung zum Developer bei NETWAYS erfolgreich abgeschlossen. Als leidenschaftlicher Programmierer und begeisterter Anhänger der Idee freier Software, hat er sich dabei innerhalb kürzester Zeit in die Herzen seiner Kollegen im Development geschlichen. Wäre nicht ausgerechnet Gandhi sein Vorbild, würde er von dort aus daran arbeiten, seinen geheimen Plan, erst die Abteilung und dann die Weltherrschaft an sich zu reißen, zu realisieren - tut er aber nicht. Stattdessen beschreitet er mit der...

Eine Taste für alle Fälle

Trotz der Stabilität von GNU/Linux kann es vor allem bei Vorabversionen u. U. vorkommen, dass sich das System aufhängt und nicht mehr auf Eingaben reagiert. Wer auf diesen Fall vorbereitet ist, muss im Zweifelsfall nicht gleich den Stecker ziehen und evtl. wertvolle Daten verlieren.

Magische S-Abf-Taste

Die Magische S-Abf-Taste ermöglicht es Benutzern, die vor einer physischen Tastatur sitzen, dem Kernel direkt Befehle zu erteilen. Je nach Distribution/Standard-Konfiguration muss dieser Kanal zuerst überhaupt freigeschaltet werden:

# sysctl kernel.sysrq=502

Zwecks Persistenz muss der Datei /etc/sysctl.conf eine entsprechende Zeile hinzugefügt (bzw. angepasst) werden:

kernel.sysrq=502

Nun ist es an der Zeit, die Taste zu testen. Dazu kann – vorzugsweise in einer Konsole (Strg+Alt+F2) – die Tastenkombination Alt+SysAbf+H, die die Hilfe anzeigen lässt, verwendet werden (Alt drücken und halten, SysAbf drücken und loslassen, H drücken und loslassen, Alt loslassen). Im Erfolgsfall kann zukünftig bspw. ein nicht mehr reagierender X-Server mit Alt+SysAbf+K abgeschossen werden.

Laptops und Netbooks

… haben meist eine kompakte(re) Tastatur im Vergleich zu Schreibtischrechnern mit weniger Tasten und evtl. keiner SysAbf-Taste. Eine vorhandene Druck-Taste muss nicht zwingend auch die SysAbf-Taste stellen. Um deren Funktionalität trotzdem nutzen zu können, muss eine andere Taste “umgebogen” werden. Hierzu wird in einer Konsole showkey -s eingegeben. Dieses Kommando müsste folgende Ausgabe erzeugen:

KB-Modus war UNICODE
[ Wenn Sie das unter X probieren, muss es nicht funktionieren,
 da der X Server ebenfalls von /dev/console liest. ]
Drücken Sie eine Taste (Programmende 10 s nach dem letzten Tastendruck)...
0x9c

Nun muss die umzubiegende Taste – bspw. die Windows-Taste – gedrückt und losgelassen werden. Dies sollte folgende Ausgabe erzeugen:

0xe0 0x5b 0xe0 0xdb

Von diesen 4 Hexadezimalzahlen steht die erste Hälfte (0xe05b) für das Drücken und die zweite für das Loslassen der Taste. Nun kann die Windows-Taste mit folgendem Kommando umgebogen werden:

# setkeycodes e05b 99

Die 99 steht hierbei für die SysAbf-Taste.

$ grep -Fwe KEY_SYSRQ /usr/include/linux/input.h
#define KEY_SYSRQ        99
$

Zwecks Persistenz muss dieses Kommando automatisch beim Systemstart ausgeführt werden. Dies kann z. B. wie folgt eingerichtet werden:

# echo "
# Make the Windows key working like SysRq
@reboot root $(which setkeycodes) e05b 99" >>/etc/crontab

Fazit

Die meisten häufig genutzten Distributionen haben alles nötige schon von Haus aus eingerichtet. Meiner Meinung nach ist diese Anleitung trotzdem zumindest für Nutzer von Systemen wie Arch, Fedora oder Debian Testing absolutes Pflichtprogramm. Möglichen Datenverlusten einen Riegel vorzuschieben kann keinesfalls schaden.

Alexander Klimov
Alexander Klimov
Developer

Alexander hat 2017 seine Ausbildung zum Developer bei NETWAYS erfolgreich abgeschlossen. Als leidenschaftlicher Programmierer und begeisterter Anhänger der Idee freier Software, hat er sich dabei innerhalb kürzester Zeit in die Herzen seiner Kollegen im Development geschlichen. Wäre nicht ausgerechnet Gandhi sein Vorbild, würde er von dort aus daran arbeiten, seinen geheimen Plan, erst die Abteilung und dann die Weltherrschaft an sich zu reißen, zu realisieren - tut er aber nicht. Stattdessen beschreitet er mit der...

Reverse proxying vom Feinsten

Kibana stellt seit Version 4 den Web-Server selbst. Dieser fungiert auch als (transparenter) Proxy zwischen dem Klienten und Elasticsearch. Dennoch scheint kaum einer (der Entwickler), sich Gedanken um die Sicherheit gemacht zu haben. Hinz und Kunz werden beim Versuch, auf Kibana zuzugreifen, von nichts und niemandem (außer vielleicht der Firewall) aufgehalten. Das ist – vor allem in (größeren) Produktionsumgebungen – nicht unbedingt die wünschenswerteste Situation. Dennoch muss deswegen noch lange niemand gleich Kibana patchen (oder sich vor den nächsten Zug werfen). Diese Lücke kann auch ein Reverse Proxy schließen.

Was ist ein Reverse Proxy?

Während ein konventioneller Proxy einem Klienten die Verbindung zu n Diensten ermöglicht – also für den Klienten von ihm gestellte Anfragen an Dienste weiter reicht – macht ein Reverse Proxy das Gegenteil. Er nimmt von n Klienten Anfragen, die für einen Dienst bestimmt sind, entgegen (und reicht diese entsprechend weiter).
Anwendungsbeispiele:

  • Cache
  • Lastverteiler
  • Honeypot
  • (zusätzliche) Firewall

Abschirmung von Kibana

Der Apache HTTPd kann bspw. als Reverse Proxy dienen und muss dafür wie folgt konfiguriert werden:

ProxyPass / http://127.0.0.1:5601/
ProxyPassReverse / http://127.0.0.1:5601/

Dadurch wird Apache angewiesen, alle (`/‘) Anfragen an Kibana weiterzuleiten und die Antworten entsprechend an die Klienten zurück zu senden.
Natürlich ist das an und für sich noch keine Abschirmung. Allerdings kann Apache (ganz einfach) mit Passwort-Authentifizierung, SSL u.v.m. ausgestattet werden.
Beispielkonfiguration:

<VirtualHost *:443>
    SSLEngine on
    SSLCertificateFile /etc/pki/tls/certs/localhost.crt
    SSLCertificateKeyFile /etc/pki/tls/private/localhost.key
    ProxyPass / http://127.0.0.1:5601/
    ProxyPassReverse / http://127.0.0.1:5601/
    <Location />
        AuthType Basic
        AuthName "Top secret"
        AuthBasicProvider file
        AuthUserFile /etc/httpd/passwd
        Require valid-user
    </Location>
</VirtualHost>

Und schon können wir etwas ruhiger schlafen. 🙂

Alexander Klimov
Alexander Klimov
Developer

Alexander hat 2017 seine Ausbildung zum Developer bei NETWAYS erfolgreich abgeschlossen. Als leidenschaftlicher Programmierer und begeisterter Anhänger der Idee freier Software, hat er sich dabei innerhalb kürzester Zeit in die Herzen seiner Kollegen im Development geschlichen. Wäre nicht ausgerechnet Gandhi sein Vorbild, würde er von dort aus daran arbeiten, seinen geheimen Plan, erst die Abteilung und dann die Weltherrschaft an sich zu reißen, zu realisieren - tut er aber nicht. Stattdessen beschreitet er mit der...

Wo bin ich?

GNU/Linux-Distributionen gibt es wie Sand am Meer. Doch welche habe ich nun vor mir?
Natürlich wird sich kaum einer, der vor dem Recher, den er täglich nutzt, sitzt (und nicht unter Alzheimer leidet), diese Frage stellen. Aber stellen wir uns einmal vor, ein IT-Dienstleister muss – vor Ort – das ihm noch unbekannte System eines Kunden betreuen. Oder: die Arbeitsschritte einer plattformübergreifenden Anwendung hängen davon ab, auf welcher Distribution letztgenannte ausgeführt wird.
Letztgenannter Fall lag bei Icinga Web 2 vor. Vom Benutzer – zwecks Installation – manuell auszuführende Befehle hängen von der Distribution, auf der Icinga Web 2 installiert wird, ab. Das Problem: diese Information muss möglichst Distributionsneutral abgefragt werden. Die Lösung: /etc/os-release.
Letztgenannte Datei ist erweiterbar – und vor allem einfach zu analysieren:

'/(?<!.)\s*ID\s*=\s*([\'"]?)(.*?)\1\s*(?!.)/msi'

Mit diesem PCRE-PHP-String lässt sich jede Zeile der Datei darauf überprüfen, ob sie die Information, die wir haben wollen, enthält. Letztgenannte kann direkt extrahiert werden.
Aber leider gibt es nicht nur die tollen, neuen Distros, die auf systemd bauen – sondern auch solche, die schon fast Jahrzehnte auf dem Buckel haben (können). Diese haben nur ihre spezifischen Release-Files. Es folgen ein paar Beispiele:

  • /etc/fedora-release
  • /etc/centos-release
  • /etc/redhat-release
  • /etc/SuSE-release

Nur die Existenz der 2 letztgenannten Dateien zu überprüfen ist sehr unprezise, da bspw. /etc/redhat-release auch auf CentOS vorhanden ist. /etc/SuSE-release findet sich sowohl auf openSUSE, als auch auf SLES.
Wem das zu aufwändig ist – der kann auch von Icinga 2 gebrauch machen:

$ icinga2 --version
icinga2 - The Icinga 2 network monitoring daemon (version: v2.3.0-...)
Copyright (c) 2012-2015 Icinga Development Team (https://www.icinga.org)
.
.
.
System information:
  Operating system: Linux
  Operating system version: 3.13.0-48-generic
  Architecture: x86_64
  Distribution: CentOS release 6.5 (Final)

Fazit: systemd hat auch seine Vorteile. 😉

Alexander Klimov
Alexander Klimov
Developer

Alexander hat 2017 seine Ausbildung zum Developer bei NETWAYS erfolgreich abgeschlossen. Als leidenschaftlicher Programmierer und begeisterter Anhänger der Idee freier Software, hat er sich dabei innerhalb kürzester Zeit in die Herzen seiner Kollegen im Development geschlichen. Wäre nicht ausgerechnet Gandhi sein Vorbild, würde er von dort aus daran arbeiten, seinen geheimen Plan, erst die Abteilung und dann die Weltherrschaft an sich zu reißen, zu realisieren - tut er aber nicht. Stattdessen beschreitet er mit der...

Azubis erzählen: April 2015 Alexander

This entry is part 5 of 12 in the series Azubis erzählen

Name: Alexander Klimov
Ausbildungsberuf: Fachinformatiker für Anwendungsentwicklung
Abteilung: Development
Lehrjahr: 1

Hallo Menschen!
Diesmal bin ich an der Reihe, Euch meinen Ausbildungsberuf nahezubringen.
Doch zuerst ein paar Angaben zu meiner Wenigkeit:
Ich heiße Alexander. Ich bin 20 Jahre jung und im 1. Lehrjahr. Mein Ausbildungsberuf heißt Fachinformatiker für Anwendungsentwicklung und mich erwartet im kommenden Lehrjahr erst mal die Zwischenprüfung. Die Abschlussprüfung sollte im Lehrjahr darauf folgen. Meine Kollegen Nadja und Marius mögen schon weiter sein, aber – wie ich gerne zu sagen pflege – kommt Zeit, kommt Rat! Neben der unglaublich spannenden Berufsschule bin ich in der Development-Abteilung von NETWAYS tätig.
Die Berufsbezeichnung ist relativ selbsterklärend. Meine (Haupt-)Aufgabe besteht darin, Anwendungen (weiter) zu entwickeln. Im Folgenden möchte ich euch ein paar davon vorstellen.

Icinga Web 2

An unserem PHP-Framework Icinga Web 2 gibt es noch alle Hände voll zu schrauben (schließlich soll es irgendwann mal fertig werden) – kein Wunder, dass der Löwenanteil meiner bisherigen Ausbildung diesem Projekt gewidmet war.
Icinga LogoNeben dem Erlernen der unglaublich tollen Programmiersprache PHP war es mir vergönnt, viele kleinere Fehler zu beheben und die Puppet-Manifeste radikal umzubauen, um Letztgenannte überschaubar(er) zu machen. Das Problem bestand darin, dass (fast) alles (fast 800 Zeilen) sich in einer .pp-Datei befand – und das hat den Code nicht viel übersichtlicher gemacht. Meine Aufgabe bestand darin, das Ganze zu modularisieren. Das hat zwar eine ganze Weile gedauert, aber mittlerweile ist es geschafft!

DbMaint

Das von mir Mitte 2014 entwickelte DbMaint soll u. a. beim Aktualisieren von Icinga 2 dazugehörige Datenbanken mit auf den neusten Stand bringen – und somit den Administrationsaufwand verringern. Für Debian gab es zwar schon dbconfig-common, aber in RPM-basierenden GNU-Distributionen fehlte ein derartiges Werkzeug.
DbMaint war in Python zu realisieren und sollte sowohl MySQL als auch PostgreSQL unterstützen. Als ob letztgenanntes nicht schon aufwändig genug war, lagen mir – dank RHEL 5 – Steine im Weg. Dieser Weg war entsprechend steinig und schwer – trotzdem ist mir die Fertigstellung gelungen.

Stammdaten-Verwaltung

Momentan verantworte ich die Fertigstellung eines Icinga Web 2 Moduls, das Stammdaten von Kunden verwalten soll. Dazu zählen bspw. Verträge und (im Rahmen letztgenannter) erworbene Produkte/Dienstleistungen. Da die voraussichtliche Datenmenge nicht überschaubar ist, kommt dafür nur eine relationale Datenbank in Frage. Sich mit solchen zu beschäftigen fand ich spannend und lehrreich. (Überhaupt lerne ich im Betrieb eine ganze Menge interessanter Sachen – die Berufsschule lasse ich an dieser Stelle mal unkommentiert..)
Zuerst hatte ich das Datenbankschema zu planen – wie die Datenbank aufgebaut sein soll und was sie überhaupt speichern soll. Danach sollte das Modul für Icinga Web 2 programmiert werden. Es soll die gespeicherten Daten anzeigen und auch das Hinzufügen, Bearbeiten und Löschen ermöglichen. (Für Leute, die sich nicht mit Datenbanken/SQL auskennen oder gerade keine Lust haben, viele/längere SQL-Abfragen abzutippen. 😉 )
Exploits of a MomAn dieser Stelle darf ich eine Lanze für Icinga Web 2 brechen, denn ohne seine Infrastruktur wäre ich so gut wie aufgeschmissen.

Fazit

In diesem Beruf reicht es nicht, in die Tasten hauen zu können – auch Köpfchen anstrengen will gelernt sein. Und wer auch um die Ecke denken kann – der findet bei uns bestimmt die richtige Stelle für sich.

Alexander Klimov
Alexander Klimov
Developer

Alexander hat 2017 seine Ausbildung zum Developer bei NETWAYS erfolgreich abgeschlossen. Als leidenschaftlicher Programmierer und begeisterter Anhänger der Idee freier Software, hat er sich dabei innerhalb kürzester Zeit in die Herzen seiner Kollegen im Development geschlichen. Wäre nicht ausgerechnet Gandhi sein Vorbild, würde er von dort aus daran arbeiten, seinen geheimen Plan, erst die Abteilung und dann die Weltherrschaft an sich zu reißen, zu realisieren - tut er aber nicht. Stattdessen beschreitet er mit der...