Bitte Beachten: Dieser Blog wird hier nicht weiter geführt! Kommentare und neue Blogposts gibt es unter http://feitel.indeedgeek.de. Dort bitte auch neue Kommentare zu diesen Beiträge erstellen.

Sonntag, 25. Mai 2008

Wissenswertes über Erlang(en)

Viele haben es ja schon mitbekommen, aber nun noch mal für den Rest der Welt: Ich habe ein neues Spielzeug gefunden! Ich bin vor kurzem durch eine Folge im Chaosradio auf die Programmiersprache Erlang gestoßen. Erlang lässt sich mit nur einem Wort beschreiben: anders (alternativ auch genial ;-).

Erlang bezeichnet sich selbst als COPL (Concurrency Oriented Programming Language). Diese Bezeichnung halte ich für sehr treffend. In Objektorientierten Sprachen dreht sich alles um Objekte und in Erlang sind es statt dessen die Prozesse. Ich habe vor kurzem einen Artikel gelesen, in dem es darum ging, dass Prozesse in Erlang doch im Grunde nichts anderes als Objekte in anderen Sprachen sind. Ich halte diesen Vergleich etwas unglücklich, da Erlang eine Funktionale Sprache ist. Am ehesten erinnerte mich Erlang an Prolog, da ich hier auch eine Art Regeln spezifizieren kann und es möglich ist darauf durch Abfragen über Matching zu zugreifen. Allerdings ist Erlang weitaus mächtiger.

Erlang wurde ursprünglich 1987 von Ericsson für Telefonanlagen entwickelt. Und ich muss sagen sie haben sehr gute Arbeit geleistet. Nichts passt besser zu Telefonanlagen als Erlang: In Erlang läuft so gut wie alles parallel. Die Prozesse sind so leichtgewichtig das auch mehrere tausende gleichzeitig von der Performance kaum Auswirkungen haben. Erlang ist hochgradig Fehlertolerant: Sollte ein Prozess abstürzen kann ein anderer diesen einfach neu starten. Und zu guter Letzt: Es ist in Erlang einfach möglich während der Laufzeit Codeteile durch neue zu ersetzen; ohne Unterbrechung der Ausführung.

Durch die Entwicklung in der Praxis ist Erlang keine akademische Sprache sondern (relativ) oft in freier Wildbahn anzutreffen. Spätestens nach der Open Source Variante, die 1998 veröffentlicht wurde, stieg die Beliebtheit rasch an. So gibt es heute eine Vielzahl von Projekten die auf Erlang aufbauen: Das berühmteste Beispiel ist wohl ejabberd ein Jabberserver. Außerdem setzt Amazon mit ihrer SimpleDB ebenso wie Facebook auf Erlang. Es gibt einen hochperformanten Webserver namens yaws und einem gigantischen Benchmark-Tool (Tsung) für z.B. Webserver. Außerdem gibt es eine Datenbank namens Mnesia die sich perfekt in Erlang integriert. Man hat so keine Tabellen mehr wie in Relationale Datenbanken sondern nutzt die Erlang eigenen Datentypen um mit der Datenbank zu kommunizieren. Außerdem kann Mnesia wie eigentlich alles in Erlang verteilt laufen so das es möglich wäre, auf einem Computer die DB im RAM (für Performance) zu halten und auf einem anderen die Datenbank auf Festplatte als Backup. Eine weitere Datenbank die auf Erlang setzt ist couchdb die Dokumenten-orientiert arbeitet.

Doch was macht Erlang so besonders? Programmiert man in einer der üblichen Sprachen macht man immer ein neuen Thread auf wenn man muss. In Erlang macht man immer einen neuen Prozess auf sobald man kann. So ist es theoretisch möglich das ein Erlang Programm auf einer Maschine mit 16 Prozessoren 16 mal schneller als auf einem Prozessor läuft. Die Prozesse in Erlang sind extrem leicht zu erstellen (sowohl von der Syntax als auch von dem Ressourcenverbrauch). Es ist möglich in Millisekunden einfach so mal 30000 Prozesse zu erstellen und wieder zu beenden ohne das die Prozessorauslastung sonderlich steigt.

Threads? Prozesse? Was den nun? So gut wie alle Sprachen bieten Threads für Nebenläufigkeiten an. Erlang hingegen nur Prozesse. Der Hauptunterschied ist: Threads haben gemeinsam genutzten Speicher. Dadurch kommt es immer wieder zu Verklemmungen und Konflikte. Ein Hoher Aufwand muss betrieben werden um dies zu vermeiden. In Erlang geht man einen anderen Weg: Dort hat jeder Prozess exklusiv einen festen Speicher. Kein anderer Prozess kann ihm dazwischen funken. Die Prozesse kommunizieren untereinander durch einfache Nachrichten. Durch dieses Prinzip ist es zum Beispiel möglich ein Programm (fast) ohne umschreiben von einer Einplatzlösung auf mehrere Computer zu verteilen so dass die Programmteile miteinander kommunizieren.

Der andere Vorteil von Erlang ist seine Eigenschaft als funktionale Sprache. So gut wie alle Probleme werden Rekursiv gelöst weshalb es auch keine Schleifen gibt. Außerdem kann man Funktionen einfach in Variablen speichern wodurch man gigantische Möglichkeiten bekommt. Am Anfang muss man sich doch sehr daran gewöhnen das Variablen, die einmal gesetzt wurden nicht wieder überschrieben werden können. Erlang arbeitet nur mit simplen Datentypen wie Tupeln und Listen, allerdings ist die Sprache so gebaut das diese einfachen Konstrukte vollkommen ausreichen. Und das Beste von allem: Der Index dieser Datentypen fängt bei 1 an! (und nicht wie üblich bei 0)

Die Sprache eignet sich perfekt für Serveranwendungen auf die gleichzeitig viele Benutzer zugreifen, allerdings lässt sich auch das tk-GUI Toolkit verwenden wodurch GUI Anwendungen ebenso möglich sind. Sogar ein 3D-Modellierer namens Wings3D ist in Erlang geschrieben.

Wer mehr über Erlang wissen will, dem kann ich nur die oben schon verlinkte Chaosradio-Sendung empfehlen. Die Dokumentation findet Großteils in man-Pages statt, was für Viele etwas ungewohnt ist. Allerdings findet man auch ein sehr gutes Tutorial welches einem die Konzepte näher bringt. Zu der Entstehung der Sprache existiert ein großartiges Video welches ihr unbedingt anschauen müsst! Und zu Letzt muss ich noch unbedingt das Outro von Chaosradio verlinken welches auch ein Grund war die Sprache zu lernen (Foyer des Arts - Wissenswertes über Erlangen).

Ich dachte mir, evtl. besteht ja Interesse an einem kleinen Tutorial hier auf diesem Blog? Wenn ihr sagt euch würde die Sprache interessieren starte ich mal den Versuch ein kleines Tutorial über Erlang zu schreiben.

Donnerstag, 8. Mai 2008

Massendownload

Wie oft steht man vor einem Problem wie es simpler nicht sein könnte? Doch weil man eine besonders elegante Lösung möchte verrenkt man sich dabei beide Arme... So erging es mir gestern wieder. Mein Gedanke war aus einem Directory-Index, wie er von jedem Webserver generiert wird, alle Dateien auszulesen und herunter zu laden. Das Ergebnis sollte allerdings möglichst kurz sein und in nur einem Befehl, ohne irgendwelche Hilfsdateien anlegen zu müssen, abgeschlossen sein.

Nach stundenlangen Versuchen mit sed habe ich nun endlich heute eine Lösung gefunden mit der ich leben kann:

wget -qO- $PARAM | ruby -e "STDIN.each_line{|line| file=line.gsub!(/^<img .*> <a href=\"(.*)\">.*$/, '\1'); puts('wget '+'$PARAM'+file) unless file.nil?}"

Dabei enthält die Variable PARAM meine Webseite und evtl. weitere Parameter. Ein Beispiel wäre eine benötigte Authentifizierung: PARAM="--http-user=XY --http-passwd=XYZ http://example.org/";.

Allerdings ist meine Lösung ist mit ca. 300 Zeichen sicher nicht die kürzeste/eleganteste deshalb hier mein Aufruf: Wer schafft es besser??

Anmerkung: 1.) Überprüft meine Zeile nicht ob es sich wirklich um eine Index Seite handelt und 2.) weiß ich nicht ob es bei allen Index-Seiten funktioniert. Bisher habe ich es glaube ich nur mit Apache-generierten Standard Seiten getestet. Diese kann man allerdings nach belieben anpassen so das es dann evtl. nicht mehr funktioniert. Beim ISS bin ich recht sicher das es nicht geht ... wird der getrost ignoriert. Wenn jemand sonst noch ein Szenario hat, immer her damit!

Montag, 5. Mai 2008

Sinnlose Spielerei ...

... aber trotzdem interessant. Gerade habe ich etwas mit meinen Boot Optionen herum gespielt. Dabei bin ich zufällig auf ein nettes Tool namens Bootchart gestoßen. Dieses Programm analysiert den Boot Prozess und stellt diesen Grafisch da. Ich geb mal eine Kurzeinführung wie man das Programm unter Gentoo zum laufen bringt. Für andere Distributionen sollte die Installation ähnlich verlaufen. Alternativ gibt es in der README noch eine andere Möglichkeit.

Zuerst muss das Paket app-benchmarks/bootchart installiert werden. Da das Programm als masked gekennzeichnet ist muss man die folgende Zeile in die Datei einfügen: echo "~app-benchmarks/bootchart-0.9 ~x86" > /etc/portage/package.keywords. Anschließend das Paket gleich mergen. Dabei unbedingt darauf achten, dass das Java UseFlag aktiviert ist, da sonst später nicht automatisch Bilder erstellt werden.

Nun kommt die Konfiguration dran. In der Datei /etc/conf.d/rc die folgende Option einstellen: RC_BOOTCHART="yes" außerdem in /etc/bootchartd.conf die Option AUTO_RENDER="yes" aktivieren. Wenn man sonst noch etwas wünscht wie zum Beispiel ein anderer Outputpfad oder ein anderes Format kann man dies hier ebenfalls angeben.

Wenn man nun neu startet kann man eine grafische Darstellung des Bootprozesses unter /var/log/bootchart.png (oder so ähnlich, je nach Einstellungen in der Config-Datei) bewundern.

Um ehrlich zu sein ist das ganze (wie Benchmarks allgemein) relativ sinnlos, aber nett anzusehen. Deshalb los, los, ich will euren Bootprozess bewundern ;-). Ich mach schon mal den Anfang:

Donnerstag, 24. April 2008

R.I.P. Lidl

Lidl ist durch ihre Mitarbeiter / Kundenüberwachung in letzter Zeit eigentlich genug in Kritik geraten. Man sollte sich nach diesen Vorwürfen nochmal überlegen ob man dort wirklich einkaufen will. Aber bei diesem Super Angebot heute konnte ich nicht widerstehen:

500 GB externe SATA Festplatte in Aluminiumgehäuse mit Netzwerk-, eSATA- und USB-Anschluss für gerade mal 139 EURO

Und da meine eine externe Festplatte vor kurzem sowieso seinen Geist aufgegeben hat, war dies (trotz Lidl) ein verlockendes Angebot. Soweit zur Theorie... Ich also vor genau drei Wochen um 9:00 Uhr vor dem Lidl gestanden und wollte eben diese Festplatte. Nachdem ich sie nirgends gefunden habe bin ich gleich an die Kasse um dort nachzufragen. Ich dachte ja ich höre nicht recht als man mir sagte, dass die Filiale nur zwei Festplatten geliefert bekommen hat. Ich mich natürlich erstmal total aufgeregt da dies ja nicht das erste Mal ist, dass Lidl vorher groß Werbung macht und dann kaum Exemplare auf Lager hat.

Die Mitarbeiterin, verwies mich allerdings sofort (anscheinend passiert das öfters...) auf die Service-Hotline die groß über dem Ausgang hängt. Ich natürlich gleich mein Handy ausgepackt und versucht dort anzurufen. Aber ich war wohl nicht der Einzige, der mit Lidl seine Probleme hatte. Gegen 11:30 habe ich dann endlich jemanden erreicht, der mir versicherte, dass es eigentlich nicht möglich sei. Er würde versuchen eine andere Festplatte vom Lager zu meiner Filiale zu schicken. Nachdem ich ihm (zugegeben etwas ungern) meine Kontaktdaten gegeben habe versprach er die Festplatte auf meinem Namen zu hinterlegen.

Eine Woche später wurde ich wieder angerufen. Im Lager sind noch Festplatten verfügbar und wenn ich noch Interesse habe, würde man mir eine in meine Filiale schicken. Ich hab mich natürlich erstmal gefreut und gewartet das sich, wie versprochen, meine Filiale meldet sobald die Platte dort eingetroffen ist.

Nachdem ich am Dienstag noch immer nichts von meiner Platte gehört habe, fragte ich halt nochmal nach (Die Nummer hatte ich ja mittlerweile eingespeichert). Wer hätte es gedacht? Mein Platte ist natürlich schon längst in der Filiale, man hatte nur vergessen mich anzurufen. Ich also gleich Abends zum Lidl und Platte abgeholt.

Ab hier wird es Technisch: Nachdem das Teil ja ein Netzwerkanschluss mitbringt bin ich davon ausgegangen das dort ein UNIX sein Dienst verrichtet und mir die Daten per SMB, FTP, NFS etc. zur Verfügung stellt. Das ganze kann man dann über ein Webinterface Verwalten (IP/DHCP etc.). Die Realität sah leider etwas anders aus: Das Laufwerk war von Targa und arbeitete mit ndas dazu in Wikipedia:

Network Direct Attached Storage (NDAS) ist ein proprietäres System für Speichermedien (meist Festplatten), die ohne einen PC oder Server direkt an ein Netzwerk angeschlossen werden können und auf dem Zielsystem wie ein lokaler Datenträger erscheinen.

Software war natürlich dafür nur Windows dabei allerdings habe ich auf der Herstellerseite auch ein "Source"-Paket gefunden. Bis auf ein paar Libs, die nur binär vorliegen, kann man es sich also kompilieren. Das Gentoo-Paket hat etwas ärger gemacht, deswegen habe ich es selbst kompiliert.

Das ganze läuft nun so ab: Die Platte hat eine eindeutige ID. Über die muss man die Platte auf jedem PC, auf dem man sie nutzen möchte, registrieren. Anschließend muss man einen ndas Dienst starten der schaut ob die Platte im Netzwerk ist. Wenn ja erscheint sie dann als Blockdevice und man kann sie wie gewohnt mounten. Blöder weiße kann immer nur ein Computer die Festplatte mounten und zwei mal ist mir beim unmount mein Laptop eingefroren (was mir unter Linux zuvor noch nie passiert ist). Und was das Fass zum überlaufen brachte: Die Funktion mit der ich ein erneutes Suchen nach der Platte anstoßen kann ist nicht eingebaut. So muss man immer den Dienst neu starten um zu suchen. Alles in allem muss ich sagen die Technik ist absoluter Bullshit!

Fazit: Ich habe die Platte gestern zurück getragen und hab mein Geld wieder abgeholt. Auch wenn das Angebot wirklich gut war, ist die Technik dahinter einfach nicht zu gebrauchen. Dann leg ich lieber noch 20€ drauf und hab eine funktionierende Festplatte. Ich muss sagen ich bin einerseits davon enttäuscht wie Lidl verkauft, da sie einfach absichtlich möglichst wenig Festplatten ausliefern. Andererseits auch was Lidl verkauft. Würde nicht mein Miteinkäufer unbedingt immer bei Lidl einkaufen wollen, würde ich wohl in nächster Zeit einen großen Bogen um Lidl machen. (Außer evtl. zum Spaß)

Montag, 7. April 2008

Ich kann nicht Programmieren...

... zumindest kam es mir letzte Woche so vor. Für eine Vorlesung musste ich einen (bis jetzt) vereinfachten Single Sign On - Server schreiben. Da wie gesagt dies bisher nur ein Prototyp ist, war die Implementierung relativ simpel und die Anwendung lief recht schnell. Die nächste Aufgabe bestand daraus den Prototyp mit vorgegebenen Unittests zu testen.

GRAUSAM! Ich dachte naja, zwei drei Tests werden wohl rot sein, aber das gut 60% fehlschlägt hat mich dann doch sehr betroffen gemacht. Die meisten Fehler waren einfach eine fehlende Überprüfung auf Null oder eine vergessene Negation in einer If Abfrage. Ich habe mich darauf hin gleich gefragt warum die Tests so schlecht ausgefallen sind bzw. was man besser machen könnte um solche Fehler zu vermeiden.

Natürlich Methoden wie Unittests, Design by Contract, TDD, etc. sind in aller Munde aber mal ehrlich, nutzt ihr die bei jedem Projekt so ausführlich wie man sollte? Ich bestreite nicht den Nutzen dieser Techniken, auch bin ich mir durchaus benutzt das diese bzw. vergleichbare Techniken in ernsthaften Projekten unabdingbar sind aber ich finde es sind immer noch zu viele Barrieren vorhanden so das die Techniken wirklich Sinn geben. Ich weiß nicht genau wie ich sagen soll, deshalb gibt es mal paar Beispiele:

Ein Unittest ist schnell geschrieben, aber man muss ja prinzipiell jede Mögliche Kombination von Input und Output Werten bzw. auch an Zuständen im System Abdecken. Ein enges System aus Unittests halte ich für sehr sinnvoll, aber wenn sich beispielsweise ein Nutzer mit Name und Passwort an einem Server anmelden will. Was muss ich alles Testen? Was ist wenn Nutzername und/oder Passwort Null sind? Was ist wenn Nutzer und/oder Passwort falsch sind? Was ist wenn der Server nicht erreichbar ist? Was ist wenn der Nutzer bereits angemeldet ist? Was ist wenn der Nutzer überhaupt nicht im System vorhanden ist? Was ist wenn Nutzername und/oder Passwort ein Leerer String sind? Und so weiter. Mir fällt bestimmt noch mehr ein. Und das nur für einen Vorgang! Man stelle sich das mal in einem Komplexen System vor! Außerdem ergibt sich früher oder später die otwendigkeit von Mock Objekten und GUI Tests. Diese Spirale dreht sich so lange hoch bis ich irgendwann mehr Testcode als produktiven Code habe. Und genau hier tritt für mich ein Widerspruch zwischen Theorie und Praxis auf. Ich weiß das es gut ist, ich weiß das man es braucht, aber ich habe keine Ahnung wie man sinnvoll (sowohl logistisch als auch zeitlich) alle Fälle abdecken soll.

Andere Möglichkeit sind Pre- Postconditons. Hier tritt, außer dem Umfangproblem der Unittests, auch noch das Problem der Mangelnden Verbreitung auf. Die Sprachen, die ich mehr oder weniger kenne (Java, Ruby, C(++), Python, Bash, Prolog(:D), ...) bringen Conditions von Haus aus nicht mit. Deshalb bleiben mir zwei Möglichkeiten: Entweder ich lade mir eine zusätzliche Erweiterung der Programmiersprache dazu (was leider wieder andere Probleme wie Kompatibilität und Overhead mit sich bringt) oder ich arbeite mit Asserts. Bringt meine Sprache der Wahl schon Asserts mit habe ich es etwas einfacher. Ansonsten muss man sich erst eine Assert Funktion schreiben (wofür es gerade in Ruby einige sehr schöne Ansätze gibt!). Das Problem was ich hier wieder sehe ist einfach das es keine gezielte Notation der Conditions gibt. Ich habe einfach am Anfang (oder auch am Ende) meiner Funktion 10,20 oder auch mehr Zeilen mit Assert Statements die alle Fälle die mir einfallen abdecken sollten. Blöd nur wenn die Methode selbst nur 5 Zeilen hat. Besser wäre ein Ansatz mit dem man durch die Erweiterung der Sprache eine gesonderte Syntax innerhalb des Methodenkopfes einführt. Und selbst da macht einem die Vielzahl der Möglichen Input- und Output-Werte Kopfzerbrechen.

Ich habe jetzt mal die beiden Methoden herausgegriffen und meine Bedenken dazu geäußert. Ich komme aber irgendwie aus diesem Widerspruch nicht heraus. Um robusten Code zu schreiben muss ich alle Fälle abdecken, wenn ich alle Fälle abdecke, komme ich nicht dazu Code zu schreiben. Klar der Mittelweg ist der beste, aber das dachte ich bei meinem Projekt auch und dann waren doch 60% rot. Es muss doch eine Möglichkeit geben schnell und kurz während ich die Methode schreibe alle Fälle auszuschließen die nicht auftreten dürfen. So eine Technik kann nur funktionieren wenn sei nebenbei, schon fast automatisch, abläuft (sei es nun wirklich automatisiert oder einfach nur durch den Autor). Aber irgendwie kämpfen die Methoden die mir spontan einfallen alle mit massig Overhead.

Wie handhabt ihr das? Schon mal TDD versucht? Geht es euch Ähnlich? Ich bin für Vorschläge dankbar!

Montag, 31. März 2008

Kurzes Statement an alle Programmierer

Aus aktuellem Anlass 3 kurze Statements an alle Programmierer da draußen:

Wenn ihr glaubt man kann durch das Einsetzten toller Tools, Editoren oder Libraries bessere Programme schreiben, dann könnt ihr nicht programmieren!
Ich sehe es an Eclipse: IntelliSense, Projektverwaltung, Wizards alles schön und gut, ich arbeite trotzdem ungern damit! Eclipse hat tausend Einstellungsmöglichkeiten aber versucht mal die Einrückung auf zwei Leerzeichen einzustellen. Warum zum Teufel mach ich tausend Menüpunkte statt einer Configdatei? Warum muss ich eine halbe Minute warten bis ich Eclipse gestartet hab nur um zu schauen ob Änderungen im SVN sind? VIM ist für mich mit Abstand der beste Editor obwohl ich ihn bei weitem noch nicht so bedienen kann wie ich es gerne hätte. Dort ist einfach alles einstellbar, so wie es für jeden richtig ist. Für was brauche ich IntelliSense wenn ich eine Doku hab? Für was brauche ich ein SVN-Plugin wenn ich svn als Programm habe? Eclipse steht nur im Weg wenn man programmiert. Sicher Programmiert es sich so schneller weil man einfach nur seinen Methodennamen vervollständigen lassen muss aber genau in dem Moment gibt man das Denken an die IDE ab. Bevor ich in Eclipse ein Projekt erstellt habe bin ich mit VIM fertig.
Wenn ihr glaubt man kann aus einem UML-Diagramm, einem GUI-Designer oder Anderweitig auch nur Programmteile zusammenklicken, dann konntet ihr noch nie programmieren!
Programmieren hat zu einem kleinen Teil etwas mit einer planbaren Engineeringtätigkeit zu tun. Der Rest besteht aus Erfahrung und einem künstlerischem Prozess. Mit Kunst meine ich keine schöne GUI sondern viel mehr ist es eine Art von künstlerischem Ausdruck. Etwas, das durchaus mit dem spielen eines Instrumentes gleich kommt. KEIN Editor schafft es dies durch ein paar Code-Templates die man im Hintergrund platziert zu komprimieren. Sie gaukeln nur ein schnelles Ergebnis vor bis man ein gewissen Detailgrad erreicht hat und dann kommt der GAU weil der Editor nur noch im Weg steht und komplexe Dinge nicht mehr möglich sind.
Wenn ihr glaub, man muss nicht stetig weiterlernen, dann werdet ihr auch nie programmieren können!
Je nach dem was man als Programmiersprache definiert sollten zwei neue Sprachen im Jahr locker drinnen sein. Jeden Monat ein Buch zu einem neuen Thema sollte auch möglich sein. Bevor man sich mit einem neuen Thema beschäftigt => Buch lesen. Bevor man versucht etwas durch probieren zum laufen zu bekommen => Buch lesen. Ziel ist es zu wissen was man tut und nicht Beispiele aus einem Online Tutorial herauszukopieren und zu hoffen das es Funktioniert!

Schlechte Programme sind das Übel der Neuzeit. Früher gab es die Pest, heute reichen dazu ein paar Programmierer. Programmieren hat nichts mit Syntax zu tun. Programmieren ist einfach ein Gefühl welches sich durch Code ausdrückt!

Anmerkung: Das ganze ist natürlich (mal wieder) übertrieben und nicht ganz ernst gemeint. Deswegen ist es leider nicht weniger wahr.

Samstag, 15. März 2008

ssh-agent Startscript

Nachdem ich zufällig auf einige interessante Möglichkeiten von SSH gestoßen bin entschloss ich mich vor meinen Semesterferien das Buch "SSH, The Secure Shell" auszuleihen. Ich muss sagen wenn dieses Buch ist schon fast die SSH Spezifikation. Dort steht wirklich alles drinnen. Zum Lesen völlig ungeeignet allerdings für Ideen und zum Nachblättern gar nicht mal so schlecht.

So bin ich auch auf Authentifikation über SSH-Keys gestoßen. Normalerweise gibt man sein Passwort ein, wenn man sich auf einem Server anmeldet. SSH-Keys funktionieren allerdings eher wie GPG Verschlüsselung. Man generiert einen Public Key, den man auf allen Servern, bei denen man sich anmelden möchte, hinterlegt. Außerdem noch einen Privat Key mit dem sich jeder, bei allen Server auf denen der Public Key hinterlegt ist, anmelden kann. Das funktioniert einfach, in dem der Server mit dem Public-Key eine Challenge verschlüsselt und diese dem Client zusendet. Dieser entschlüsselt die Nachricht wieder und sendet es zurück. Stimmen die Nachrichten beim Server überein wird der Nutzer rein gelassen. Allerdings kann dann wie schon gesagt jeder der den Private Key kennt auch auf den Server zugreifen. Um dies etwas zu erschweren kann man ein Passwort definieren das für den Privaten Key benötigt wird. Man sieht schon, im Grunde nichts anderes als GPG. In Wirklichkeit kann man sogar (mit den nötigen Einstellungen) seinen GPG Key dafür nutzen.

Nun hat man zwar SSH-Key, allerdings darf man nun wieder jedes mal sein Passwort eingeben. Man hat also nichts gewonnen. Dafür gibt es nun (ebenfalls aus der GPG-Welt bekannt) einen Agent, der die Key einmal lädt, dabei das Passwort abfragt und anschließend auf Anfragen reagiert. So muss man nicht jedes mal neu sein Passwort eingeben. Sehr praktische Geschichte! Leider ist die Syntax etwas umständlich und auch muss jeder Key einzeln geladen werden. Deshalb habe ich mir etwas den Kopf zerbrochen wie man dies automatisieren kann. Dabei ist das folgende Script entstanden. Es schaut bei jedem Aufruf (in der Regel sobald sich eine neue Shell öffnet) ob der SSH-Agent läuft. Außerdem lädt es die Keys Automatisch so das man nur noch die Passwörter eingeben muss. Außerdem ermöglicht es über die beiden Funktionen start-ssh-agent und load-ssh-indentities dies auch Manuell durchzuführen.

Um zu verstehen wie das Script funktioniert muss man sich erst einmal anschauen wie der ssh-agent bekannt gibt es es ihn gibt. Ruft man ihn einfach mit dem ssh-agent Kommando auf (was der falsche Weg ist), erscheinen einige Variablen. Diese Variablen sind wichtig damit der ssh-Client auf den Agent zugreifen kann. Der Agent selbst läuft vom Terminal losgelöst. Er wird also nicht beendet wenn die Session beendet wird sondern läuft im Hintergrund weiter. Einer der richtigen Wege (es gibt mehrere Möglichkeiten) wäre eval `ssh-agent`. Hier wird zuerst der ssh-agent aufgerufen und die Ausgaben ausgeführt. So werden die Variablen im aktuellen Terminal bekannt gegeben. Möchte man nun auch in einer anderen Session auf den Agent zugreifen muss man dort auch einfach nur die Variablen bekannt machen. Da der Agent wie gesagt unabhängig von der aktuellen Session läuft interessiert es nicht aus welcher Shell er gestartet wurde.

$ ssh-agent
SSH_AUTH_SOCK=/tmp/ssh-Yvpvk13029/agent.13029; export SSH_AUTH_SOCK;
SSH_AGENT_PID=13045; export SSH_AGENT_PID;
echo Agent pid 13045;

Mein kleines Script macht im Grunde nichts anderes als diese Variablen in einer Datei zu speichern und bei jedem anmelden diese einzulesen. Außerdem lädt es alle Identitäten die in in dem Verzeichnis ~/.ssh/keys/ liegen. Wichtig ist, dass dort nur Private-Keys liegen dürfen; keine Public-Keys!

# Lädt alle Indentitäten im Verzeichnis ~/.ssh/keys/
function load-ssh-indentities() {
  # Prüft erst ob ein tty verfügbar ist
  if tty -s ; then
    for FILE in ~/.ssh/keys/* ; do
      ssh-add $FILE
    done
  fi
}

# Startet den SSH-Agent mit einer Indentitäten-Lifetime von einer Stunde
# und schreibt die Variablen in die ~/.ssh_agent_vars Datei
function start-ssh-agent() {
  eval `ssh-agent -s -t 3600`
  echo -e "export SSH_AGENT_PID=$SSH_AGENT_PID\nexport SSH_AUTH_SOCK=$SSH_AUTH_SOCK" > ~/.ssh_agent_vars \
  && echo "SSH-Agent gestartet"
}

# Fragt erst nach ob Indentitäten geladern werden sollen.
function _ask_load_ssh_indentities() {
  echo "Indentitäten laden? (y/N)"
  read ANSWER
  ( [ "$ANSWER" = "y" ] || [ "$ANSWER" = "Y" ] ) && load-ssh-Indentitäten
}

# Die Variable SSH_AUTH_SOCK wird für den SSH-Agent benötigt und sollte gesetzt sein wenn er läuft.
if [ "$SSH_AUTH_SOCK" = "" ]; then
  # Es wird geprüft ob die Datei ~/.ssh_agent_vars vorhanden ist.
  if [ -f ~/.ssh_agent_vars ]; then
    # Wenn ja wird diese Includiert und geprüft ob die Variablen darin noch gültig sind.
    source ~/.ssh_agent_vars

    # Prüft ob es ein ssh-agent Prozess mit der PID gibt und das Socket existiert.
    if ( ps -p $SSH_AGENT_PID  | grep -q ssh-agent ) && [ -e $SSH_AUTH_SOCK ]; then
      # SSH-Agent ist gestartet Vorhandene Indentitäten werden angezeigt.
      echo "SSH-Agent ist bereits gestartet Geladene Indentitäten:"
      ssh-add -l
    else
      # Die Variablen sind nicht mehr gültig. Datei wird gelöscht und SSH-Agent wird neu gestartet.
      echo "~/.ssh_agent_vars Datei existiert aber es ist kein Agent gestartet. Starte Agent."
      rm ~/.ssh_agent_vars
      start-ssh-agent && _ask_load_ssh_indentities
    fi
  else
    # Datei ist nicht vorhanden. Es wird geprüft ob SSH-Agent läuft.
    if ps u -C ssh-agent | grep -q ssh-agent ; then 
      echo "SSH-Agent läuft aber es existiert keine ~/.ssh_agent_vars Datei!"
      echo "SSH-Agent muss gestoppt werden und mit 'start-ssh-agent' neu gestartet"
      # Weiteres Vorgehen dem User überlassen
    else
      # Wenn nicht wird er gestartet.
      start-ssh-agent && _ask_load_ssh_indentities
    fi
  fi
else
  # Variable ist schon gesetzt. Es wird geprüft ob SSH-Agent auch wirklich läuft
  if ps u -C ssh-agent | grep -q ssh-agent ; then 
    echo "SSH-Agent ist bereits gestartet. Geladen Indentitäten:"
    ssh-add -l
  else
    # Tritt nur bei Subshells auf, wenn die Variable in die Subshell
    # übergeben wurde obwohl der Agent schon beendet wurde.
    echo "SSH_AUTH_SOCK Variable ist gesetzt aber SSH-Agent läuft nicht!"
    # Weiteres Vorgehen dem User überlassen
  fi
fi

Das Script muss am besten in die Datei ~/.bashrc eingefügt werden. Dabei ist wichtig, dass dies nicht in einer Subshell ausgeführt werden darf. Deshalb direkt in die bashrc kopieren oder mittels source einbinden. Da es sonst Namespace-Probleme mit Variablen und Funktionen gibt darf es nicht über exec eingebunden werden (deshalb auch kein #!/bin/bash am Anfang).

Für Kritik und Verbesserungsvorschläge bin ich immer offen. Getestet habe ich das Script bis jetzt mit Bash 3.2.17 und zsh 4.3.4. Einziger Kritikpunkt den ich schon jetzt von meiner Seite habe: Das Script merkt natürlich nicht wenn der User nicht mehr angemeldet ist. Da der Agent unabhängig von der Session ist läuft er einfach weiter auch wenn der User schon längst über alle Berge ist. Das ist in so weit ein Problem da man theoretisch einen Speicherdump des ssh-agent Prozesses machen kann und dann alle Keys vorfindet. Um dies zu verhindern habe ich die 60 Minuten Sperre eingebaut. So scheißt der Agent nach 60 Minuten alle Keys raus und man muss sie neu laden. Leider ist das etwas unschön. Ich habe allerdings (noch) keine bessere Idee.